|
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 /*
|
|
|
23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
|
|
|
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>
|
|
|
47
|
|
|
48 #include <sys/sata/impl/sata.h>
|
|
|
49 #include <sys/sata/sata_hba.h>
|
|
|
50 #include <sys/sata/sata_defs.h>
|
|
|
51 #include <sys/sata/sata_cfgadm.h>
|
|
|
52
|
|
|
53
|
|
|
54
|
|
|
55 /* Debug flags - defined in sata.h */
|
|
|
56 int sata_debug_flags = 0;
|
|
|
57 /*
|
|
|
58 * Flags enabling selected SATA HBA framework functionality
|
|
|
59 */
|
|
|
60 #define SATA_ENABLE_QUEUING 1
|
|
|
61 #define SATA_ENABLE_NCQ 2
|
|
|
62 #define SATA_ENABLE_PROCESS_EVENTS 4
|
|
|
63 static int sata_func_enable = SATA_ENABLE_PROCESS_EVENTS;
|
|
|
64
|
|
|
65 #ifdef SATA_DEBUG
|
|
|
66 #define SATA_LOG_D(args) sata_log args
|
|
|
67 #else
|
|
|
68 #define SATA_LOG_D(arg)
|
|
|
69 #endif
|
|
|
70
|
|
|
71
|
|
|
72 /*
|
|
|
73 * SATA cb_ops functions
|
|
|
74 */
|
|
|
75 static int sata_hba_open(dev_t *, int, int, cred_t *);
|
|
|
76 static int sata_hba_close(dev_t, int, int, cred_t *);
|
|
|
77 static int sata_hba_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
|
|
|
78
|
|
|
79 /*
|
|
|
80 * SCSA required entry points
|
|
|
81 */
|
|
|
82 static int sata_scsi_tgt_init(dev_info_t *, dev_info_t *,
|
|
|
83 scsi_hba_tran_t *, struct scsi_device *);
|
|
|
84 static int sata_scsi_tgt_probe(struct scsi_device *,
|
|
|
85 int (*callback)(void));
|
|
|
86 static void sata_scsi_tgt_free(dev_info_t *, dev_info_t *,
|
|
|
87 scsi_hba_tran_t *, struct scsi_device *);
|
|
|
88 static int sata_scsi_start(struct scsi_address *, struct scsi_pkt *);
|
|
|
89 static int sata_scsi_abort(struct scsi_address *, struct scsi_pkt *);
|
|
|
90 static int sata_scsi_reset(struct scsi_address *, int);
|
|
|
91 static int sata_scsi_getcap(struct scsi_address *, char *, int);
|
|
|
92 static int sata_scsi_setcap(struct scsi_address *, char *, int, int);
|
|
|
93 static struct scsi_pkt *sata_scsi_init_pkt(struct scsi_address *,
|
|
|
94 struct scsi_pkt *, struct buf *, int, int, int, int, int (*)(caddr_t),
|
|
|
95 caddr_t);
|
|
|
96 static void sata_scsi_destroy_pkt(struct scsi_address *, struct scsi_pkt *);
|
|
|
97 static void sata_scsi_dmafree(struct scsi_address *, struct scsi_pkt *);
|
|
|
98 static void sata_scsi_sync_pkt(struct scsi_address *, struct scsi_pkt *);
|
|
|
99 static int sata_scsi_get_name(struct scsi_device *, char *, int);
|
|
|
100
|
|
|
101
|
|
|
102 /*
|
|
|
103 * Local functions
|
|
|
104 */
|
|
|
105 static void sata_remove_hba_instance(dev_info_t *);
|
|
|
106 static int sata_validate_sata_hba_tran(dev_info_t *, sata_hba_tran_t *);
|
|
|
107 static void sata_probe_ports(sata_hba_inst_t *);
|
|
|
108 static int sata_reprobe_port(sata_hba_inst_t *, sata_device_t *);
|
|
|
109 static void sata_make_device_nodes(dev_info_t *, sata_hba_inst_t *);
|
|
|
110 static dev_info_t *sata_create_target_node(dev_info_t *, sata_hba_inst_t *,
|
|
|
111 sata_address_t *);
|
|
|
112 static int sata_validate_scsi_address(sata_hba_inst_t *,
|
|
|
113 struct scsi_address *, sata_device_t *);
|
|
|
114 static int sata_validate_sata_address(sata_hba_inst_t *, int, int, int);
|
|
|
115 static sata_pkt_t *sata_pkt_alloc(sata_pkt_txlate_t *, int (*)(caddr_t));
|
|
|
116 static void sata_pkt_free(sata_pkt_txlate_t *);
|
|
|
117 static int sata_dma_buf_setup(sata_pkt_txlate_t *, int, int (*)(caddr_t),
|
|
|
118 caddr_t, ddi_dma_attr_t *);
|
|
|
119 static int sata_probe_device(sata_hba_inst_t *, sata_device_t *);
|
|
|
120 static sata_drive_info_t *sata_get_device_info(sata_hba_inst_t *,
|
|
|
121 sata_device_t *);
|
|
|
122 static int sata_identify_device(sata_hba_inst_t *, sata_drive_info_t *);
|
|
|
123 static struct buf *sata_alloc_local_buffer(sata_pkt_txlate_t *, int);
|
|
|
124 static void sata_free_local_buffer(sata_pkt_txlate_t *);
|
|
|
125 static uint64_t sata_check_capacity(sata_drive_info_t *);
|
|
|
126 void sata_adjust_dma_attr(sata_drive_info_t *, ddi_dma_attr_t *,
|
|
|
127 ddi_dma_attr_t *);
|
|
|
128 static int sata_fetch_device_identify_data(sata_hba_inst_t *,
|
|
|
129 sata_drive_info_t *);
|
|
|
130 static void sata_update_port_info(sata_hba_inst_t *, sata_device_t *);
|
|
|
131 static void sata_update_port_scr(sata_port_scr_t *, sata_device_t *);
|
|
|
132 static int sata_set_udma_mode(sata_hba_inst_t *, sata_drive_info_t *);
|
|
|
133
|
|
|
134 /* Event processing functions */
|
|
|
135 static void sata_event_daemon(void *);
|
|
|
136 static void sata_event_thread_control(int);
|
|
|
137 static void sata_process_controller_events(sata_hba_inst_t *sata_hba_inst);
|
|
|
138 static void sata_process_device_reset(sata_hba_inst_t *, sata_address_t *);
|
|
|
139 static void sata_process_port_failed_event(sata_hba_inst_t *,
|
|
|
140 sata_address_t *);
|
|
|
141 static void sata_process_port_link_events(sata_hba_inst_t *,
|
|
|
142 sata_address_t *);
|
|
|
143 static void sata_process_device_detached(sata_hba_inst_t *, sata_address_t *);
|
|
|
144 static void sata_process_device_attached(sata_hba_inst_t *, sata_address_t *);
|
|
|
145 static void sata_process_port_pwr_change(sata_hba_inst_t *, sata_address_t *);
|
|
|
146 static void sata_process_cntrl_pwr_level_change(sata_hba_inst_t *);
|
|
|
147 static int sata_restore_drive_settings(sata_hba_inst_t *,
|
|
|
148 sata_drive_info_t *);
|
|
|
149
|
|
|
150 /* Local functions for ioctl */
|
|
|
151 static int32_t sata_get_port_num(sata_hba_inst_t *, struct devctl_iocdata *);
|
|
|
152 static void sata_cfgadm_state(sata_hba_inst_t *, int32_t,
|
|
|
153 devctl_ap_state_t *);
|
|
|
154 static dev_info_t *sata_get_target_dip(dev_info_t *, int32_t);
|
|
|
155 static dev_info_t *sata_devt_to_devinfo(dev_t);
|
|
|
156
|
|
|
157 /* Local translation functions */
|
|
|
158 static int sata_txlt_inquiry(sata_pkt_txlate_t *);
|
|
|
159 static int sata_txlt_test_unit_ready(sata_pkt_txlate_t *);
|
|
|
160 static int sata_txlt_start_stop_unit(sata_pkt_txlate_t *);
|
|
|
161 static int sata_txlt_read_capacity(sata_pkt_txlate_t *);
|
|
|
162 static int sata_txlt_request_sense(sata_pkt_txlate_t *);
|
|
|
163 static int sata_txlt_read(sata_pkt_txlate_t *);
|
|
|
164 static int sata_txlt_write(sata_pkt_txlate_t *);
|
|
|
165 static int sata_txlt_atapi(sata_pkt_txlate_t *);
|
|
|
166 static int sata_txlt_log_sense(sata_pkt_txlate_t *);
|
|
|
167 static int sata_txlt_log_select(sata_pkt_txlate_t *);
|
|
|
168 static int sata_txlt_mode_sense(sata_pkt_txlate_t *);
|
|
|
169 static int sata_txlt_mode_select(sata_pkt_txlate_t *);
|
|
|
170 static int sata_txlt_synchronize_cache(sata_pkt_txlate_t *);
|
|
|
171 static int sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *);
|
|
|
172
|
|
|
173 static int sata_hba_start(sata_pkt_txlate_t *, int *);
|
|
|
174 static int sata_txlt_invalid_command(sata_pkt_txlate_t *);
|
|
|
175 static int sata_txlt_lba_out_of_range(sata_pkt_txlate_t *);
|
|
|
176 static void sata_txlt_rw_completion(sata_pkt_t *);
|
|
|
177 static void sata_txlt_atapi_completion(sata_pkt_t *);
|
|
|
178 static void sata_txlt_nodata_cmd_completion(sata_pkt_t *);
|
|
|
179
|
|
|
180 static struct scsi_extended_sense *sata_immediate_error_response(
|
|
|
181 sata_pkt_txlate_t *, int);
|
|
|
182 static struct scsi_extended_sense *sata_arq_sense(sata_pkt_txlate_t *);
|
|
|
183
|
|
|
184 /* Local functions */
|
|
|
185 static void sata_identdev_to_inquiry(sata_hba_inst_t *, sata_drive_info_t *,
|
|
|
186 uint8_t *);
|
|
|
187 static int sata_build_msense_page_1(sata_drive_info_t *, int, uint8_t *);
|
|
|
188 static int sata_build_msense_page_8(sata_drive_info_t *, int, uint8_t *);
|
|
|
189 static int sata_build_msense_page_1a(sata_drive_info_t *, int, uint8_t *);
|
|
|
190 static int sata_build_msense_page_1c(sata_drive_info_t *, int, uint8_t *);
|
|
|
191 static int sata_mode_select_page_8(sata_pkt_txlate_t *,
|
|
|
192 struct mode_cache_scsi3 *, int, int *, int *, int *);
|
|
|
193 static void sata_save_drive_settings(sata_drive_info_t *);
|
|
|
194 static void sata_show_drive_info(sata_hba_inst_t *, sata_drive_info_t *);
|
|
|
195
|
|
|
196 static void sata_log(sata_hba_inst_t *, uint_t, char *fmt, ...);
|
|
|
197
|
|
|
198 /*
|
|
|
199 * SATA Framework will ignore SATA HBA driver cb_ops structure and
|
|
|
200 * register following one with SCSA framework.
|
|
|
201 * Open & close are provided, so scsi framework will not use its own
|
|
|
202 */
|
|
|
203 static struct cb_ops sata_cb_ops = {
|
|
|
204 sata_hba_open, /* open */
|
|
|
205 sata_hba_close, /* close */
|
|
|
206 nodev, /* strategy */
|
|
|
207 nodev, /* print */
|
|
|
208 nodev, /* dump */
|
|
|
209 nodev, /* read */
|
|
|
210 nodev, /* write */
|
|
|
211 sata_hba_ioctl, /* ioctl */
|
|
|
212 nodev, /* devmap */
|
|
|
213 nodev, /* mmap */
|
|
|
214 nodev, /* segmap */
|
|
|
215 nochpoll, /* chpoll */
|
|
|
216 ddi_prop_op, /* cb_prop_op */
|
|
|
217 0, /* streamtab */
|
|
|
218 D_NEW | D_MP, /* cb_flag */
|
|
|
219 CB_REV, /* rev */
|
|
|
220 nodev, /* aread */
|
|
|
221 nodev /* awrite */
|
|
|
222 };
|
|
|
223
|
|
|
224
|
|
|
225 extern struct mod_ops mod_miscops;
|
|
|
226 extern uchar_t scsi_cdb_size[];
|
|
|
227
|
|
|
228 static struct modlmisc modlmisc = {
|
|
|
229 &mod_miscops, /* Type of module */
|
|
|
230 "Generic SATA Driver v%I%" /* module name */
|
|
|
231 };
|
|
|
232
|
|
|
233
|
|
|
234 static struct modlinkage modlinkage = {
|
|
|
235 MODREV_1,
|
|
|
236 (void *)&modlmisc,
|
|
|
237 NULL
|
|
|
238 };
|
|
|
239
|
|
|
240 /*
|
|
|
241 * Default sata pkt timeout. Used when a target driver scsi_pkt time is zero,
|
|
|
242 * i.e. when scsi_pkt has not timeout specified.
|
|
|
243 */
|
|
|
244 static int sata_default_pkt_time = 60; /* 60 seconds */
|
|
|
245
|
|
|
246 /*
|
|
|
247 * Mutexes protecting structures in multithreaded operations.
|
|
|
248 * Because events are relatively rare, a single global mutex protecting
|
|
|
249 * data structures should be sufficient. To increase performance, add
|
|
|
250 * separate mutex per each sata port and use global mutex only to protect
|
|
|
251 * common data structures.
|
|
|
252 */
|
|
|
253 static kmutex_t sata_mutex; /* protects sata_hba_list */
|
|
|
254 static kmutex_t sata_log_mutex; /* protects log */
|
|
|
255
|
|
|
256 static char sata_log_buf[256];
|
|
|
257
|
|
|
258 /*
|
|
|
259 * Linked list of HBA instances
|
|
|
260 */
|
|
|
261 static sata_hba_inst_t *sata_hba_list = NULL;
|
|
|
262 static sata_hba_inst_t *sata_hba_list_tail = NULL;
|
|
|
263 /*
|
|
|
264 * Pointer to per-instance SATA HBA soft structure is stored in sata_hba_tran
|
|
|
265 * structure and in sata soft state.
|
|
|
266 */
|
|
|
267
|
|
|
268 /*
|
|
|
269 * Event daemon related variables
|
|
|
270 */
|
|
|
271 static kmutex_t sata_event_mutex;
|
|
|
272 static kcondvar_t sata_event_cv;
|
|
|
273 static kthread_t *sata_event_thread = NULL;
|
|
|
274 static int sata_event_thread_terminate = 0;
|
|
|
275 static int sata_event_pending = 0;
|
|
|
276 static int sata_event_thread_active = 0;
|
|
|
277 extern pri_t minclsyspri;
|
|
|
278
|
|
|
279 /* Warlock directives */
|
|
|
280
|
|
|
281 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_hba_tran))
|
|
|
282 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_device))
|
|
|
283 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_ops))
|
|
|
284 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_extended_sense))
|
|
|
285 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_arq_status))
|
|
|
286 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_attr))
|
|
|
287 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_cookie_t))
|
|
|
288 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", devctl_ap_state))
|
|
|
289 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_list))
|
|
|
290 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_list))
|
|
|
291 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_next))
|
|
|
292 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_prev))
|
|
|
293 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", \
|
|
|
294 sata_hba_inst::satahba_scsi_tran))
|
|
|
295 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_tran))
|
|
|
296 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_dip))
|
|
|
297 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_hba_inst::satahba_attached))
|
|
|
298 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_inst::satahba_dev_port))
|
|
|
299 _NOTE(MUTEX_PROTECTS_DATA(sata_hba_inst::satahba_mutex,
|
|
|
300 sata_hba_inst::satahba_event_flags))
|
|
|
301 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
|
|
|
302 sata_cport_info::cport_devp))
|
|
|
303 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_devp))
|
|
|
304 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_cport_info::cport_addr))
|
|
|
305 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
|
|
|
306 sata_cport_info::cport_dev_type))
|
|
|
307 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_dev_type))
|
|
|
308 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
|
|
|
309 sata_cport_info::cport_state))
|
|
|
310 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_state))
|
|
|
311 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_dev_type))
|
|
|
312 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_sata_drive))
|
|
|
313 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_dev_port))
|
|
|
314 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_num_dev_ports))
|
|
|
315
|
|
|
316 /* End of warlock directives */
|
|
|
317
|
|
|
318 /* ************** loadable module configuration functions ************** */
|
|
|
319
|
|
|
320 int
|
|
|
321 _init()
|
|
|
322 {
|
|
|
323 int rval;
|
|
|
324
|
|
|
325 mutex_init(&sata_mutex, NULL, MUTEX_DRIVER, NULL);
|
|
|
326 mutex_init(&sata_event_mutex, NULL, MUTEX_DRIVER, NULL);
|
|
|
327 mutex_init(&sata_log_mutex, NULL, MUTEX_DRIVER, NULL);
|
|
|
328 cv_init(&sata_event_cv, NULL, CV_DRIVER, NULL);
|
|
|
329 if ((rval = mod_install(&modlinkage)) != 0) {
|
|
|
330 #ifdef SATA_DEBUG
|
|
|
331 cmn_err(CE_WARN, "sata: _init: mod_install failed\n");
|
|
|
332 #endif
|
|
|
333 mutex_destroy(&sata_log_mutex);
|
|
|
334 cv_destroy(&sata_event_cv);
|
|
|
335 mutex_destroy(&sata_event_mutex);
|
|
|
336 mutex_destroy(&sata_mutex);
|
|
|
337 }
|
|
|
338 return (rval);
|
|
|
339 }
|
|
|
340
|
|
|
341 int
|
|
|
342 _fini()
|
|
|
343 {
|
|
|
344 int rval;
|
|
|
345
|
|
|
346 if ((rval = mod_remove(&modlinkage)) != 0)
|
|
|
347 return (rval);
|
|
|
348
|
|
|
349 mutex_destroy(&sata_log_mutex);
|
|
|
350 cv_destroy(&sata_event_cv);
|
|
|
351 mutex_destroy(&sata_event_mutex);
|
|
|
352 mutex_destroy(&sata_mutex);
|
|
|
353 return (rval);
|
|
|
354 }
|
|
|
355
|
|
|
356 int
|
|
|
357 _info(struct modinfo *modinfop)
|
|
|
358 {
|
|
|
359 return (mod_info(&modlinkage, modinfop));
|
|
|
360 }
|
|
|
361
|
|
|
362
|
|
|
363
|
|
|
364 /* ********************* SATA HBA entry points ********************* */
|
|
|
365
|
|
|
366
|
|
|
367 /*
|
|
|
368 * Called by SATA HBA from _init().
|
|
|
369 * Registers HBA driver instance/sata framework pair with scsi framework, by
|
|
|
370 * calling scsi_hba_init().
|
|
|
371 *
|
|
|
372 * SATA HBA driver cb_ops are ignored - SATA HBA framework cb_ops are used
|
|
|
373 * instead. SATA HBA framework cb_ops pointer overwrites SATA HBA driver
|
|
|
374 * cb_ops pointer in SATA HBA driver dev_ops structure.
|
|
|
375 * SATA HBA framework cb_ops supplies cb_open cb_close and cb_ioctl vectors.
|
|
|
376 *
|
|
|
377 * Return status of the scsi_hba_init() is returned to a calling SATA HBA
|
|
|
378 * driver.
|
|
|
379 */
|
|
|
380 int
|
|
|
381 sata_hba_init(struct modlinkage *modlp)
|
|
|
382 {
|
|
|
383 int rval;
|
|
|
384 struct dev_ops *hba_ops;
|
|
|
385
|
|
|
386 SATADBG1(SATA_DBG_HBA_IF, NULL,
|
|
|
387 "sata_hba_init: name %s \n",
|
|
|
388 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo);
|
|
|
389 /*
|
|
|
390 * Fill-up cb_ops and dev_ops when necessary
|
|
|
391 */
|
|
|
392 hba_ops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops;
|
|
|
393 /*
|
|
|
394 * Provide pointer to SATA dev_ops
|
|
|
395 */
|
|
|
396 hba_ops->devo_cb_ops = &sata_cb_ops;
|
|
|
397
|
|
|
398 /*
|
|
|
399 * Register SATA HBA with SCSI framework
|
|
|
400 */
|
|
|
401 if ((rval = scsi_hba_init(modlp)) != 0) {
|
|
|
402 SATADBG1(SATA_DBG_HBA_IF, NULL,
|
|
|
403 "sata_hba_init: scsi hba init failed\n", NULL);
|
|
|
404 return (rval);
|
|
|
405 }
|
|
|
406
|
|
|
407 return (0);
|
|
|
408 }
|
|
|
409
|
|
|
410
|
|
|
411 /* HBA attach stages */
|
|
|
412 #define HBA_ATTACH_STAGE_SATA_HBA_INST 1
|
|
|
413 #define HBA_ATTACH_STAGE_SCSI_ATTACHED 2
|
|
|
414 #define HBA_ATTACH_STAGE_SETUP 4
|
|
|
415 #define HBA_ATTACH_STAGE_LINKED 8
|
|
|
416
|
|
|
417
|
|
|
418 /*
|
|
|
419 *
|
|
|
420 * Called from SATA HBA driver's attach routine to attach an instance of
|
|
|
421 * the HBA.
|
|
|
422 *
|
|
|
423 * For DDI_ATTACH command:
|
|
|
424 * sata_hba_inst structure is allocated here and initialized with pointers to
|
|
|
425 * SATA framework implementation of required scsi tran functions.
|
|
|
426 * The scsi_tran's tran_hba_private field is used by SATA Framework to point
|
|
|
427 * to the soft structure (sata_hba_inst) allocated by SATA framework for
|
|
|
428 * SATA HBA instance related data.
|
|
|
429 * The scsi_tran's tran_hba_private field is used by SATA framework to
|
|
|
430 * store a pointer to per-HBA-instance of sata_hba_inst structure.
|
|
|
431 * The sata_hba_inst structure is cross-linked to scsi tran structure.
|
|
|
432 * Among other info, a pointer to sata_hba_tran structure is stored in
|
|
|
433 * sata_hba_inst. The sata_hba_inst structures for different HBA instances are
|
|
|
434 * linked together into the list, pointed to by sata_hba_list.
|
|
|
435 * On the first HBA instance attach the sata event thread is initialized.
|
|
|
436 * Attachment points are created for all SATA ports of the HBA being attached.
|
|
|
437 * All HBA instance's SATA ports are probed and type of plugged devices is
|
|
|
438 * determined. For each device of a supported type, a target node is created.
|
|
|
439 *
|
|
|
440 * DDI_SUCCESS is returned when attachment process is successful,
|
|
|
441 * DDI_FAILURE is returned otherwise.
|
|
|
442 *
|
|
|
443 * For DDI_RESUME command:
|
|
|
444 * Not implemented at this time (postponed until phase 2 of the development).
|
|
|
445 */
|
|
|
446 int
|
|
|
447 sata_hba_attach(dev_info_t *dip, sata_hba_tran_t *sata_tran,
|
|
|
448 ddi_attach_cmd_t cmd)
|
|
|
449 {
|
|
|
450 sata_hba_inst_t *sata_hba_inst;
|
|
|
451 scsi_hba_tran_t *scsi_tran = NULL;
|
|
|
452 int hba_attach_state = 0;
|
|
|
453
|
|
|
454 SATADBG3(SATA_DBG_HBA_IF, NULL,
|
|
|
455 "sata_hba_attach: node %s (%s%d)\n",
|
|
|
456 ddi_node_name(dip), ddi_driver_name(dip),
|
|
|
457 ddi_get_instance(dip));
|
|
|
458
|
|
|
459 if (cmd == DDI_RESUME) {
|
|
|
460 /*
|
|
|
461 * Postponed until phase 2 of the development
|
|
|
462 */
|
|
|
463 return (DDI_FAILURE);
|
|
|
464 }
|
|
|
465
|
|
|
466 if (cmd != DDI_ATTACH) {
|
|
|
467 return (DDI_FAILURE);
|
|
|
468 }
|
|
|
469
|
|
|
470 /* cmd == DDI_ATTACH */
|
|
|
471
|
|
|
472 if (sata_validate_sata_hba_tran(dip, sata_tran) != SATA_SUCCESS) {
|
|
|
473 SATA_LOG_D((NULL, CE_WARN,
|
|
|
474 "sata_hba_attach: invalid sata_hba_tran"));
|
|
|
475 return (DDI_FAILURE);
|
|
|
476 }
|
|
|
477 /*
|
|
|
478 * Allocate and initialize SCSI tran structure.
|
|
|
479 * SATA copy of tran_bus_config is provided to create port nodes.
|
|
|
480 */
|
|
|
481 scsi_tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP);
|
|
|
482 if (scsi_tran == NULL)
|
|
|
483 return (DDI_FAILURE);
|
|
|
484 /*
|
|
|
485 * Allocate soft structure for SATA HBA instance.
|
|
|
486 * There is a separate softstate for each HBA instance.
|
|
|
487 */
|
|
|
488 sata_hba_inst = kmem_zalloc(sizeof (struct sata_hba_inst), KM_SLEEP);
|
|
|
489 ASSERT(sata_hba_inst != NULL); /* this should not fail */
|
|
|
490 mutex_init(&sata_hba_inst->satahba_mutex, NULL, MUTEX_DRIVER, NULL);
|
|
|
491 hba_attach_state |= HBA_ATTACH_STAGE_SATA_HBA_INST;
|
|
|
492
|
|
|
493 /*
|
|
|
494 * scsi_trans's tran_hba_private is used by SATA Framework to point to
|
|
|
495 * soft structure allocated by SATA framework for
|
|
|
496 * SATA HBA instance related data.
|
|
|
497 */
|
|
|
498 scsi_tran->tran_hba_private = sata_hba_inst;
|
|
|
499 scsi_tran->tran_tgt_private = NULL;
|
|
|
500
|
|
|
501 scsi_tran->tran_tgt_init = sata_scsi_tgt_init;
|
|
|
502 scsi_tran->tran_tgt_probe = sata_scsi_tgt_probe;
|
|
|
503 scsi_tran->tran_tgt_free = sata_scsi_tgt_free;
|
|
|
504
|
|
|
505 scsi_tran->tran_start = sata_scsi_start;
|
|
|
506 scsi_tran->tran_reset = sata_scsi_reset;
|
|
|
507 scsi_tran->tran_abort = sata_scsi_abort;
|
|
|
508 scsi_tran->tran_getcap = sata_scsi_getcap;
|
|
|
509 scsi_tran->tran_setcap = sata_scsi_setcap;
|
|
|
510 scsi_tran->tran_init_pkt = sata_scsi_init_pkt;
|
|
|
511 scsi_tran->tran_destroy_pkt = sata_scsi_destroy_pkt;
|
|
|
512
|
|
|
513 scsi_tran->tran_dmafree = sata_scsi_dmafree;
|
|
|
514 scsi_tran->tran_sync_pkt = sata_scsi_sync_pkt;
|
|
|
515
|
|
|
516 scsi_tran->tran_reset_notify = NULL;
|
|
|
517 scsi_tran->tran_get_bus_addr = NULL;
|
|
|
518 scsi_tran->tran_quiesce = NULL;
|
|
|
519 scsi_tran->tran_unquiesce = NULL;
|
|
|
520 scsi_tran->tran_bus_reset = NULL;
|
|
|
521
|
|
|
522 if (scsi_hba_attach_setup(dip, sata_tran->sata_tran_hba_dma_attr,
|
|
|
523 scsi_tran, 0) != DDI_SUCCESS) {
|
|
|
524 #ifdef SATA_DEBUG
|
|
|
525 cmn_err(CE_WARN, "?SATA: %s%d hba scsi attach failed",
|
|
|
526 ddi_driver_name(dip), ddi_get_instance(dip));
|
|
|
527 #endif
|
|
|
528 goto fail;
|
|
|
529 }
|
|
|
530 hba_attach_state |= HBA_ATTACH_STAGE_SCSI_ATTACHED;
|
|
|
531
|
|
|
532 if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "sata")) {
|
|
|
533 if (ddi_prop_update_int(DDI_DEV_T_NONE, dip,
|
|
|
534 "sata", 1) != DDI_PROP_SUCCESS) {
|
|
|
535 SATA_LOG_D((NULL, CE_WARN, "sata_hba_attach: "
|
|
|
536 "failed to create hba sata prop"));
|
|
|
537 goto fail;
|
|
|
538 }
|
|
|
539 }
|
|
|
540
|
|
|
541 /*
|
|
|
542 * Save pointers in hba instance soft state.
|
|
|
543 */
|
|
|
544 sata_hba_inst->satahba_scsi_tran = scsi_tran;
|
|
|
545 sata_hba_inst->satahba_tran = sata_tran;
|
|
|
546 sata_hba_inst->satahba_dip = dip;
|
|
|
547
|
|
|
548 hba_attach_state |= HBA_ATTACH_STAGE_SETUP;
|
|
|
549
|
|
|
550 /*
|
|
|
551 * Create events thread if not created yet.
|
|
|
552 */
|
|
|
553 sata_event_thread_control(1);
|
|
|
554
|
|
|
555 /*
|
|
|
556 * Link this hba instance into the list.
|
|
|
557 */
|
|
|
558 mutex_enter(&sata_mutex);
|
|
|
559
|
|
|
560
|
|
|
561 sata_hba_inst->satahba_next = NULL;
|
|
|
562 sata_hba_inst->satahba_prev = sata_hba_list_tail;
|
|
|
563 if (sata_hba_list == NULL) {
|
|
|
564 sata_hba_list = sata_hba_inst;
|
|
|
565 }
|
|
|
566 if (sata_hba_list_tail != NULL) {
|
|
|
567 sata_hba_list_tail->satahba_next = sata_hba_inst;
|
|
|
568 }
|
|
|
569 sata_hba_list_tail = sata_hba_inst;
|
|
|
570 mutex_exit(&sata_mutex);
|
|
|
571 hba_attach_state |= HBA_ATTACH_STAGE_LINKED;
|
|
|
572
|
|
|
573 /*
|
|
|
574 * Create SATA HBA devctl minor node for sata_hba_open, close, ioctl
|
|
|
575 * SATA HBA driver should not use its own open/close entry points.
|
|
|
576 *
|
|
|
577 * Make sure that instance number doesn't overflow
|
|
|
578 * when forming minor numbers.
|
|
|
579 */
|
|
|
580 ASSERT(ddi_get_instance(dip) <= (L_MAXMIN >> INST_MINOR_SHIFT));
|
|
|
581 if (ddi_create_minor_node(dip, "devctl", S_IFCHR,
|
|
|
582 INST2DEVCTL(ddi_get_instance(dip)),
|
|
|
583 DDI_NT_SATA_NEXUS, 0) != DDI_SUCCESS) {
|
|
|
584 #ifdef SATA_DEBUG
|
|
|
585 cmn_err(CE_WARN, "sata_hba_attach: "
|
|
|
586 "cannot create devctl minor node");
|
|
|
587 #endif
|
|
|
588 goto fail;
|
|
|
589 }
|
|
|
590
|
|
|
591
|
|
|
592 /*
|
|
|
593 * Set-up kstats here, if necessary.
|
|
|
594 * (postponed until phase 2 of the development).
|
|
|
595 */
|
|
|
596
|
|
|
597
|
|
|
598 /*
|
|
|
599 * Probe controller ports. This operation will describe a current
|
|
|
600 * controller/port/multipliers/device configuration and will create
|
|
|
601 * attachment points.
|
|
|
602 * We may end-up with just a controller with no devices attached.
|
|
|
603 */
|
|
|
604 sata_probe_ports(sata_hba_inst);
|
|
|
605
|
|
|
606 /*
|
|
|
607 * Create child nodes for all possible target devices currently
|
|
|
608 * attached to controller's ports and port multiplier device ports.
|
|
|
609 */
|
|
|
610 sata_make_device_nodes(sata_tran->sata_tran_hba_dip, sata_hba_inst);
|
|
|
611
|
|
|
612 sata_hba_inst->satahba_attached = 1;
|
|
|
613 return (DDI_SUCCESS);
|
|
|
614
|
|
|
615 fail:
|
|
|
616 if (hba_attach_state & HBA_ATTACH_STAGE_LINKED) {
|
|
|
617 (void) sata_remove_hba_instance(dip);
|
|
|
618 if (sata_hba_list == NULL)
|
|
|
619 sata_event_thread_control(0);
|
|
|
620 }
|
|
|
621 if (hba_attach_state & HBA_ATTACH_STAGE_SETUP)
|
|
|
622 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata");
|
|
|
623
|
|
|
624 if (hba_attach_state & HBA_ATTACH_STAGE_SCSI_ATTACHED)
|
|
|
625 (void) scsi_hba_detach(dip);
|
|
|
626
|
|
|
627 if (hba_attach_state & HBA_ATTACH_STAGE_SATA_HBA_INST) {
|
|
|
628 mutex_destroy(&sata_hba_inst->satahba_mutex);
|
|
|
629 kmem_free((void *)sata_hba_inst,
|
|
|
630 sizeof (struct sata_hba_inst));
|
|
|
631 scsi_hba_tran_free(scsi_tran);
|
|
|
632 }
|
|
|
633
|
|
|
634 sata_log(NULL, CE_WARN, "?SATA: %s%d hba attach failed",
|
|
|
635 ddi_driver_name(dip), ddi_get_instance(dip));
|
|
|
636
|
|
|
637 return (DDI_FAILURE);
|
|
|
638 }
|
|
|
639
|
|
|
640
|
|
|
641 /*
|
|
|
642 * Called by SATA HBA from to detach an instance of the driver.
|
|
|
643 *
|
|
|
644 * For DDI_DETACH command:
|
|
|
645 * Free local structures allocated for SATA HBA instance during
|
|
|
646 * sata_hba_attach processing.
|
|
|
647 *
|
|
|
648 * Returns DDI_SUCCESS when HBA was detached, DDI_FAILURE otherwise.
|
|
|
649 *
|
|
|
650 * For DDI_SUSPEND command:
|
|
|
651 * Not implemented at this time (postponed until phase 2 of the development)
|
|
|
652 * Returnd DDI_SUCCESS.
|
|
|
653 *
|
|
|
654 * When the last HBA instance is detached, the event daemon is terminated.
|
|
|
655 *
|
|
|
656 * NOTE: cport support only, no port multiplier support.
|
|
|
657 */
|
|
|
658 int
|
|
|
659 sata_hba_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
|
|
|
660 {
|
|
|
661 dev_info_t *tdip;
|
|
|
662 sata_hba_inst_t *sata_hba_inst;
|
|
|
663 scsi_hba_tran_t *scsi_hba_tran;
|
|
|
664 sata_cport_info_t *cportinfo;
|
|
|
665 sata_drive_info_t *sdinfo;
|
|
|
666 int ncport;
|
|
|
667
|
|
|
668 SATADBG3(SATA_DBG_HBA_IF, NULL, "sata_hba_detach: node %s (%s%d)\n",
|
|
|
669 ddi_node_name(dip), ddi_driver_name(dip), ddi_get_instance(dip));
|
|
|
670
|
|
|
671 switch (cmd) {
|
|
|
672 case DDI_DETACH:
|
|
|
673
|
|
|
674 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
|
|
|
675 return (DDI_FAILURE);
|
|
|
676
|
|
|
677 sata_hba_inst = scsi_hba_tran->tran_hba_private;
|
|
|
678 if (sata_hba_inst == NULL)
|
|
|
679 return (DDI_FAILURE);
|
|
|
680
|
|
|
681 if (scsi_hba_detach(dip) == DDI_FAILURE) {
|
|
|
682 sata_hba_inst->satahba_attached = 1;
|
|
|
683 return (DDI_FAILURE);
|
|
|
684 }
|
|
|
685
|
|
|
686 /*
|
|
|
687 * Free all target nodes - at this point
|
|
|
688 * devices should be at least offlined
|
|
|
689 * otherwise scsi_hba_detach() should not be called.
|
|
|
690 */
|
|
|
691 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst);
|
|
|
692 ncport++) {
|
|
|
693 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
|
|
|
694 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
|
|
|
695 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
|
|
|
696 if (sdinfo != NULL) {
|
|
|
697 tdip = sata_get_target_dip(dip,
|
|
|
698 ncport);
|
|
|
699 if (tdip != NULL) {
|
|
|
700 if (ndi_devi_offline(tdip,
|
|
|
701 NDI_DEVI_REMOVE) !=
|
|
|
702 NDI_SUCCESS) {
|
|
|
703 SATA_LOG_D((
|
|
|
704 sata_hba_inst,
|
|
|
705 CE_WARN,
|
|
|
706 "sata_hba_detach: "
|
|
|
707 "Target node not "
|
|
|
708 "removed !"));
|
|
|
709 return (DDI_FAILURE);
|
|
|
710 }
|
|
|
711 }
|
|
|
712 }
|
|
|
713 }
|
|
|
714 }
|
|
|
715 /*
|
|
|
716 * Disable sata event daemon processing for this HBA
|
|
|
717 */
|
|
|
718 sata_hba_inst->satahba_attached = 0;
|
|
|
719
|
|
|
720 /*
|
|
|
721 * Remove event daemon thread, if it is last HBA instance.
|
|
|
722 */
|
|
|
723
|
|
|
724 mutex_enter(&sata_mutex);
|
|
|
725 if (sata_hba_list->satahba_next == NULL) {
|
|
|
726 mutex_exit(&sata_mutex);
|
|
|
727 sata_event_thread_control(0);
|
|
|
728 mutex_enter(&sata_mutex);
|
|
|
729 }
|
|
|
730 mutex_exit(&sata_mutex);
|
|
|
731
|
|
|
732 /* Remove this HBA instance from the HBA list */
|
|
|
733 sata_remove_hba_instance(dip);
|
|
|
734
|
|
|
735 /*
|
|
|
736 * At this point there should be no target nodes attached.
|
|
|
737 * Detach and destroy device and port info structures.
|
|
|
738 */
|
|
|
739 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst);
|
|
|
740 ncport++) {
|
|
|
741 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
|
|
|
742 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
|
|
|
743 sdinfo =
|
|
|
744 cportinfo->cport_devp.cport_sata_drive;
|
|
|
745 if (sdinfo != NULL) {
|
|
|
746 /* Release device structure */
|
|
|
747 kmem_free(sdinfo,
|
|
|
748 sizeof (sata_drive_info_t));
|
|
|
749 }
|
|
|
750 /* Release cport info */
|
|
|
751 mutex_destroy(&cportinfo->cport_mutex);
|
|
|
752 kmem_free(cportinfo,
|
|
|
753 sizeof (sata_cport_info_t));
|
|
|
754 }
|
|
|
755 }
|
|
|
756
|
|
|
757 scsi_hba_tran_free(sata_hba_inst->satahba_scsi_tran);
|
|
|
758
|
|
|
759 mutex_destroy(&sata_hba_inst->satahba_mutex);
|
|
|
760 kmem_free((void *)sata_hba_inst,
|
|
|
761 sizeof (struct sata_hba_inst));
|
|
|
762
|
|
|
763 return (DDI_SUCCESS);
|
|
|
764
|
|
|
765 case DDI_SUSPEND:
|
|
|
766 /*
|
|
|
767 * Postponed until phase 2
|
|
|
768 */
|
|
|
769 return (DDI_FAILURE);
|
|
|
770
|
|
|
771 default:
|
|
|
772 return (DDI_FAILURE);
|
|
|
773 }
|
|
|
774 }
|
|
|
775
|
|
|
776
|
|
|
777 /*
|
|
|
778 * Called by an HBA drive from _fini() routine.
|
|
|
779 * Unregisters SATA HBA instance/SATA framework pair from the scsi framework.
|
|
|
780 */
|
|
|
781 void
|
|
|
782 sata_hba_fini(struct modlinkage *modlp)
|
|
|
783 {
|
|
|
784 SATADBG1(SATA_DBG_HBA_IF, NULL,
|
|
|
785 "sata_hba_fini: name %s\n",
|
|
|
786 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo);
|
|
|
787
|
|
|
788 scsi_hba_fini(modlp);
|
|
|
789 }
|
|
|
790
|
|
|
791
|
|
|
792 /*
|
|
|
793 * Default open and close routine for sata_hba framework.
|
|
|
794 *
|
|
|
795 */
|
|
|
796 /*
|
|
|
797 * Open devctl node.
|
|
|
798 *
|
|
|
799 * Returns:
|
|
|
800 * 0 if node was open successfully, error code otherwise.
|
|
|
801 *
|
|
|
802 *
|
|
|
803 */
|
|
|
804
|
|
|
805 static int
|
|
|
806 sata_hba_open(dev_t *devp, int flags, int otyp, cred_t *credp)
|
|
|
807 {
|
|
|
808 #ifndef __lock_lint
|
|
|
809 _NOTE(ARGUNUSED(credp))
|
|
|
810 #endif
|
|
|
811 int rv = 0;
|
|
|
812 dev_info_t *dip;
|
|
|
813 scsi_hba_tran_t *scsi_hba_tran;
|
|
|
814 sata_hba_inst_t *sata_hba_inst;
|
|
|
815
|
|
|
816 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_open: entered", NULL);
|
|
|
817
|
|
|
818 if (otyp != OTYP_CHR)
|
|
|
819 return (EINVAL);
|
|
|
820
|
|
|
821 dip = sata_devt_to_devinfo(*devp);
|
|
|
822 if (dip == NULL)
|
|
|
823 return (ENXIO);
|
|
|
824
|
|
|
825 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
|
|
|
826 return (ENXIO);
|
|
|
827
|
|
|
828 sata_hba_inst = scsi_hba_tran->tran_hba_private;
|
|
|
829 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0)
|
|
|
830 return (ENXIO);
|
|
|
831
|
|
|
832 mutex_enter(&sata_mutex);
|
|
|
833 if (flags & FEXCL) {
|
|
|
834 if (sata_hba_inst->satahba_open_flag != 0) {
|
|
|
835 rv = EBUSY;
|
|
|
836 } else {
|
|
|
837 sata_hba_inst->satahba_open_flag =
|
|
|
838 SATA_DEVCTL_EXOPENED;
|
|
|
839 }
|
|
|
840 } else {
|
|
|
841 if (sata_hba_inst->satahba_open_flag == SATA_DEVCTL_EXOPENED) {
|
|
|
842 rv = EBUSY;
|
|
|
843 } else {
|
|
|
844 sata_hba_inst->satahba_open_flag =
|
|
|
845 SATA_DEVCTL_SOPENED;
|
|
|
846 }
|
|
|
847 }
|
|
|
848 mutex_exit(&sata_mutex);
|
|
|
849
|
|
|
850 return (rv);
|
|
|
851 }
|
|
|
852
|
|
|
853
|
|
|
854 /*
|
|
|
855 * Close devctl node.
|
|
|
856 * Returns:
|
|
|
857 * 0 if node was closed successfully, error code otherwise.
|
|
|
858 *
|
|
|
859 */
|
|
|
860
|
|
|
861 static int
|
|
|
862 sata_hba_close(dev_t dev, int flag, int otyp, cred_t *credp)
|
|
|
863 {
|
|
|
864 #ifndef __lock_lint
|
|
|
865 _NOTE(ARGUNUSED(credp))
|
|
|
866 _NOTE(ARGUNUSED(flag))
|
|
|
867 #endif
|
|
|
868 dev_info_t *dip;
|
|
|
869 scsi_hba_tran_t *scsi_hba_tran;
|
|
|
870 sata_hba_inst_t *sata_hba_inst;
|
|
|
871
|
|
|
872 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_close: entered", NULL);
|
|
|
873
|
|
|
874 if (otyp != OTYP_CHR)
|
|
|
875 return (EINVAL);
|
|
|
876
|
|
|
877 dip = sata_devt_to_devinfo(dev);
|
|
|
878 if (dip == NULL)
|
|
|
879 return (ENXIO);
|
|
|
880
|
|
|
881 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
|
|
|
882 return (ENXIO);
|
|
|
883
|
|
|
884 sata_hba_inst = scsi_hba_tran->tran_hba_private;
|
|
|
885 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0)
|
|
|
886 return (ENXIO);
|
|
|
887
|
|
|
888 mutex_enter(&sata_mutex);
|
|
|
889 sata_hba_inst->satahba_open_flag = 0;
|
|
|
890 mutex_exit(&sata_mutex);
|
|
|
891 return (0);
|
|
|
892 }
|
|
|
893
|
|
|
894
|
|
|
895
|
|
|
896 /*
|
|
|
897 * Standard IOCTL commands for SATA hotplugging.
|
|
|
898 * Implemented DEVCTL_AP commands:
|
|
|
899 * DEVCTL_AP_CONNECT
|
|
|
900 * DEVCTL_AP_DISCONNECT
|
|
|
901 * DEVCTL_AP_CONFIGURE
|
|
|
902 * DEVCTL_UNCONFIGURE
|
|
|
903 * DEVCTL_AP_CONTROL
|
|
|
904 *
|
|
|
905 * Commands passed to default ndi ioctl handler:
|
|
|
906 * DEVCTL_DEVICE_GETSTATE
|
|
|
907 * DEVCTL_DEVICE_ONLINE
|
|
|
908 * DEVCTL_DEVICE_OFFLINE
|
|
|
909 * DEVCTL_DEVICE_REMOVE
|
|
|
910 * DEVCTL_DEVICE_INSERT
|
|
|
911 * DEVCTL_BUS_GETSTATE
|
|
|
912 *
|
|
|
913 * All other cmds are passed to HBA if it provide ioctl handler, or failed
|
|
|
914 * if not.
|
|
|
915 *
|
|
|
916 * Returns:
|
|
|
917 * 0 if successful,
|
|
|
918 * error code if operation failed.
|
|
|
919 *
|
|
|
920 * NOTE: Port Multiplier is not supported.
|
|
|
921 *
|
|
|
922 */
|
|
|
923
|
|
|
924 static int
|
|
|
925 sata_hba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
|
|
|
926 int *rvalp)
|
|
|
927 {
|
|
|
928 #ifndef __lock_lint
|
|
|
929 _NOTE(ARGUNUSED(credp))
|
|
|
930 _NOTE(ARGUNUSED(rvalp))
|
|
|
931 #endif
|
|
|
932 int rv = 0;
|
|
|
933 int32_t comp_port = -1;
|
|
|
934 dev_info_t *dip, *tdip;
|
|
|
935 devctl_ap_state_t ap_state;
|
|
|
936 struct devctl_iocdata *dcp = NULL;
|
|
|
937 scsi_hba_tran_t *scsi_hba_tran;
|
|
|
938 sata_hba_inst_t *sata_hba_inst;
|
|
|
939 sata_device_t sata_device;
|
|
|
940 sata_drive_info_t *sdinfo;
|
|
|
941 sata_cport_info_t *cportinfo;
|
|
|
942 int cport, pmport, qual;
|
|
|
943 int rval = SATA_SUCCESS;
|
|
|
944
|
|
|
945 dip = sata_devt_to_devinfo(dev);
|
|
|
946 if (dip == NULL)
|
|
|
947 return (ENXIO);
|
|
|
948
|
|
|
949 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
|
|
|
950 return (ENXIO);
|
|
|
951
|
|
|
952 sata_hba_inst = scsi_hba_tran->tran_hba_private;
|
|
|
953 if (sata_hba_inst == NULL)
|
|
|
954 return (ENXIO);
|
|
|
955
|
|
|
956 if (sata_hba_inst->satahba_tran == NULL)
|
|
|
957 return (ENXIO);
|
|
|
958
|
|
|
959 switch (cmd) {
|
|
|
960
|
|
|
961 case DEVCTL_DEVICE_GETSTATE:
|
|
|
962 case DEVCTL_DEVICE_ONLINE:
|
|
|
963 case DEVCTL_DEVICE_OFFLINE:
|
|
|
964 case DEVCTL_DEVICE_REMOVE:
|
|
|
965 case DEVCTL_BUS_GETSTATE:
|
|
|
966 /*
|
|
|
967 * There may be more cases that we want to pass to default
|
|
|
968 * handler rather then fail them.
|
|
|
969 */
|
|
|
970 return (ndi_devctl_ioctl(dip, cmd, arg, mode, 0));
|
|
|
971 }
|
|
|
972
|
|
|
973 /* read devctl ioctl data */
|
|
|
974 if (cmd != DEVCTL_AP_CONTROL) {
|
|
|
975 if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS)
|
|
|
976 return (EFAULT);
|
|
|
977
|
|
|
978 if ((comp_port = sata_get_port_num(sata_hba_inst, dcp)) ==
|
|
|
979 -1) {
|
|
|
980 if (dcp)
|
|
|
981 ndi_dc_freehdl(dcp);
|
|
|
982 return (EINVAL);
|
|
|
983 }
|
|
|
984
|
|
|
985 cport = SCSI_TO_SATA_CPORT(comp_port);
|
|
|
986 pmport = SCSI_TO_SATA_PMPORT(comp_port);
|
|
|
987 /* Only cport is considered now, i.e. SATA_ADDR_CPORT */
|
|
|
988 qual = SATA_ADDR_CPORT;
|
|
|
989 if (sata_validate_sata_address(sata_hba_inst, cport, pmport,
|
|
|
990 qual) != 0) {
|
|
|
991 ndi_dc_freehdl(dcp);
|
|
|
992 return (EINVAL);
|
|
|
993 }
|
|
|
994
|
|
|
995 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
|
|
|
996 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
|
|
|
997 cport_mutex);
|
|
|
998 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) {
|
|
|
999 /*
|
|
|
1000 * Cannot process ioctl request now. Come back later.
|
|
|
1001 */
|
|
|
1002 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
|
|
|
1003 cport_mutex);
|
|
|
1004 ndi_dc_freehdl(dcp);
|
|
|
1005 return (EBUSY);
|
|
|
1006 }
|
|
|
1007 /* Block event processing for this port */
|
|
|
1008 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY;
|
|
|
1009 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
|
|
|
1010
|
|
|
1011 sata_device.satadev_addr.cport = cport;
|
|
|
1012 sata_device.satadev_addr.pmport = pmport;
|
|
|
1013 sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
|
|
|
1014 sata_device.satadev_rev = SATA_DEVICE_REV;
|
|
|
1015 }
|
|
|
1016
|
|
|
1017 switch (cmd) {
|
|
|
1018
|
|
|
1019 case DEVCTL_AP_DISCONNECT:
|
|
|
1020 /*
|
|
|
1021 * Normally, cfgadm sata plugin will try to offline
|
|
|
1022 * (unconfigure) device before this request. Nevertheless,
|
|
|
1023 * if a device is still configured, we need to
|
|
|
1024 * attempt to offline and unconfigure device first, and we will
|
|
|
1025 * deactivate the port regardless of the unconfigure
|
|
|
1026 * operation results.
|
|
|
1027 *
|
|
|
1028 * DEVCTL_AP_DISCONNECT invokes
|
|
|
1029 * sata_hba_inst->satahba_tran->
|
|
|
1030 * sata_tran_hotplug_ops->sata_tran_port_deactivate().
|
|
|
1031 * If successful, the device structure (if any) attached
|
|
|
1032 * to a port is removed and state of the port marked
|
|
|
1033 * appropriately.
|
|
|
1034 * Failure of the port_deactivate may keep port in
|
|
|
1035 * the active state, or may fail the port.
|
|
|
1036 */
|
|
|
1037
|
|
|
1038 /* Check the current state of the port */
|
|
|
1039 if (sata_reprobe_port(sata_hba_inst, &sata_device) !=
|
|
|
1040 SATA_SUCCESS) {
|
|
|
1041 rv = EIO;
|
|
|
1042 break;
|
|
|
1043 }
|
|
|
1044 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
|
|
|
1045 cport_mutex);
|
|
|
1046 if (cportinfo->cport_state &
|
|
|
1047 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) {
|
|
|
1048 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
|
|
|
1049 cport_mutex);
|
|
|
1050 rv = EIO;
|
|
|
1051 break;
|
|
|
1052 }
|
|
|
1053 /*
|
|
|
1054 * set port's dev_state to not ready - this will disable
|
|
|
1055 * an access to an attached device.
|
|
|
1056 */
|
|
|
1057 cportinfo->cport_state &= ~SATA_STATE_READY;
|
|
|
1058
|
|
|
1059 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
|
|
|
1060 sdinfo = cportinfo->cport_devp.cport_sata_drive;
|
|
|
1061 ASSERT(sdinfo != NULL);
|
|
|
1062 if ((sdinfo->satadrv_type &
|
|
|
1063 (SATA_VALID_DEV_TYPE))) {
|
|
|
1064 /*
|
|
|
1065 * If a target node exists, try to offline
|
|
|
1066 * a device and remove target node.
|
|
|
1067 */
|
|
|
1068 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
|
|
|
1069 cport)->cport_mutex);
|
|
|
1070 tdip = sata_get_target_dip(dip, comp_port);
|
|
|
1071 if (tdip != NULL) {
|
|
|
1072 /* target node exist */
|
|
|
1073 if (ndi_devi_offline(tdip,
|
|
|
1074 NDI_DEVI_REMOVE) != NDI_SUCCESS) {
|
|
|
1075 /*
|
|
|
1076 * Problem
|
|
|
1077 * A target node remained
|
|
|
1078 * attached. This happens when
|
|
|
1079 * the file was open or a node
|
|
|
1080 * was waiting for resources.
|
|
|
1081 * Cannot do anything about it.
|
|
|
1082 */
|
|
|
1083 SATA_LOG_D((sata_hba_inst,
|
|
|
1084 CE_WARN,
|
|
|
1085 "sata_hba_ioctl: "
|
|
|
1086 "disconnect: cannot "
|
|
|
1087 "remove target node!!!"));
|
|
|
1088 }
|
|
|
1089 }
|
|
|
1090 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
|
|
|
1091 cport)->cport_mutex);
|
|
|
1092 /*
|
|
|
1093 * Remove and release sata_drive_info
|
|
|
1094 * structure.
|
|
|
1095 */
|
|
|
1096 if (SATA_CPORTINFO_DRV_INFO(cportinfo) !=
|
|
|
1097 NULL) {
|
|
|
1098 SATA_CPORTINFO_DRV_INFO(cportinfo) =
|
|
|
1099 NULL;
|
|
|
1100 (void) kmem_free((void *)sdinfo,
|
|
|
1101 sizeof (sata_drive_info_t));
|
|
|
1102 cportinfo->cport_dev_type =
|
|
|
1103 SATA_DTYPE_NONE;
|
|
|
1104 }
|
|
|
1105 }
|
|
|
1106 /*
|
|
|
1107 * Note: PMult info requires different handling.
|
|
|
1108 * Put PMult handling code here, when PNult is
|
|
|
1109 * supported.
|
|
|
1110 */
|
|
|
1111 }
|
|
|
1112 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
|
|
|
1113 /* Sanity check */
|
|
|
1114 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) {
|
|
|
1115 /* No physical port deactivation supported. */
|
|
|
1116 break;
|
|
|
1117 }
|
|
|
1118
|
|
|
1119 /* Just ask HBA driver to deactivate port */
|
|
|
1120 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
|
|
|
1121
|
|
|
1122 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
|
|
|
1123 (dip, &sata_device);
|
|
|
1124 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
|
|
|
1125 cport_mutex);
|
|
|
1126 sata_update_port_info(sata_hba_inst, &sata_device);
|
|
|
1127
|
|
|
1128 if (rval != SATA_SUCCESS) {
|
|
|
1129 /*
|
|
|
1130 * Port deactivation failure - do not
|
|
|
1131 * change port state unless the state
|
|
|
1132 * returned by HBA indicates a port failure.
|
|
|
1133 */
|
|
|
1134 if (sata_device.satadev_state & SATA_PSTATE_FAILED)
|
|
|
1135 cportinfo->cport_state = SATA_PSTATE_FAILED;
|
|
|
1136 rv = EIO;
|
|
|
1137 } else {
|
|
|
1138 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
|
|
|
1139 }
|
|
|
1140 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
|
|
|
1141 break;
|
|
|
1142
|
|
|
1143 case DEVCTL_AP_UNCONFIGURE:
|
|
|
1144
|
|
|
1145 /*
|
|
|
1146 * The unconfigure operation uses generic nexus operation to
|
|
|
1147 * offline a device. It leaves a target device node attached.
|
|
|
1148 * and obviously sata_drive_info attached as well, because
|
|
|
1149 * from the hardware point of view nothing has changed.
|
|
|
1150 */
|
|
|
1151 if ((tdip = sata_get_target_dip(dip, comp_port)) != NULL) {
|
|
|
1152
|
|
|
1153 if (ndi_devi_offline(tdip, NDI_UNCONFIG) !=
|
|
|
1154 NDI_SUCCESS) {
|
|
|
1155 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
1156 "sata_hba_ioctl: unconfigure: "
|
|
|
1157 "failed to unconfigure "
|
|
|
1158 "device at cport %d", cport));
|
|
|
1159 rv = EIO;
|
|
|
1160 }
|
|
|
1161 /*
|
|
|
1162 * The target node devi_state should be marked with
|
|
|
1163 * DEVI_DEVICE_OFFLINE by ndi_devi_offline().
|
|
|
1164 * This would be the indication for cfgadm that
|
|
|
1165 * the AP node occupant state is 'unconfigured'.
|
|
|
1166 */
|
|
|
1167
|
|
|
1168 } else {
|
|
|
1169 /*
|
|
|
1170 * This would indicate a failure on the part of cfgadm
|
|
|
1171 * to detect correct state of the node prior to this
|
|
|
1172 * call - one cannot unconfigure non-existing device.
|
|
|
1173 */
|
|
|
1174 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
1175 "sata_hba_ioctl: unconfigure: "
|
|
|
1176 "attempt to unconfigure non-existing device "
|
|
|
1177 "at cport %d", cport));
|
|
|
1178 rv = ENXIO;
|
|
|
1179 }
|
|
|
1180
|
|
|
1181 break;
|
|
|
1182
|
|
|
1183 case DEVCTL_AP_CONNECT:
|
|
|
1184 {
|
|
|
1185 /*
|
|
|
1186 * The sata cfgadm pluging will invoke this operation only if
|
|
|
1187 * port was found in the disconnect state (failed state
|
|
|
1188 * is also treated as the disconnected state).
|
|
|
1189 * DEVCTL_AP_CONNECT would invoke
|
|
|
1190 * sata_hba_inst->satahba_tran->
|
|
|
1191 * sata_tran_hotplug_ops->sata_tran_port_activate().
|
|
|
1192 * If successful and a device is found attached to the port,
|
|
|
1193 * the initialization sequence is executed to attach
|
|
|
1194 * a device structure to a port structure. The device is not
|
|
|
1195 * set in configured state (system-wise) by this operation.
|
|
|
1196 * The state of the port and a device would be set
|
|
|
1197 * appropriately.
|
|
|
1198 *
|
|
|
1199 * Note, that activating the port may generate link events,
|
|
|
1200 * so is is important that following processing and the
|
|
|
1201 * event processing does not interfere with each other!
|
|
|
1202 *
|
|
|
1203 * This operation may remove port failed state and will
|
|
|
1204 * try to make port active and in good standing.
|
|
|
1205 */
|
|
|
1206
|
|
|
1207 /* We only care about host sata cport for now */
|
|
|
1208
|
|
|
1209 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) != NULL) {
|
|
|
1210 /* Just let HBA driver to activate port */
|
|
|
1211
|
|
|
1212 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
|
|
|
1213 (dip, &sata_device) != SATA_SUCCESS) {
|
|
|
1214 /*
|
|
|
1215 * Port activation failure.
|
|
|
1216 */
|
|
|
1217 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
|
|
|
1218 cport)->cport_mutex);
|
|
|
1219 sata_update_port_info(sata_hba_inst,
|
|
|
1220 &sata_device);
|
|
|
1221 if (sata_device.satadev_state &
|
|
|
1222 SATA_PSTATE_FAILED) {
|
|
|
1223 cportinfo->cport_state =
|
|
|
1224 SATA_PSTATE_FAILED;
|
|
|
1225 }
|
|
|
1226 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
|
|
|
1227 cport)->cport_mutex);
|
|
|
1228 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
1229 "sata_hba_ioctl: connect: "
|
|
|
1230 "failed to activate SATA cport %d",
|
|
|
1231 cport));
|
|
|
1232 rv = EIO;
|
|
|
1233 break;
|
|
|
1234 }
|
|
|
1235 }
|
|
|
1236 /* Virgin port state - will be updated by the port re-probe. */
|
|
|
1237 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
|
|
|
1238 cport)->cport_mutex);
|
|
|
1239 cportinfo->cport_state = 0;
|
|
|
1240 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
|
|
|
1241 cport)->cport_mutex);
|
|
|
1242
|
|
|
1243 if (sata_reprobe_port(sata_hba_inst, &sata_device) ==
|
|
|
1244 SATA_FAILURE)
|
|
|
1245 rv = EIO;
|
|
|
1246
|
|
|
1247 /*
|
|
|
1248 * If there is a device attached to the port, emit
|
|
|
1249 * a message.
|
|
|
1250 */
|
|
|
1251 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
|
|
|
1252 sata_log(sata_hba_inst, CE_WARN,
|
|
|
1253 "SATA device attached at port %d", cport);
|
|
|
1254 }
|
|
|
1255 break;
|
|
|
1256 }
|
|
|
1257
|
|
|
1258 case DEVCTL_AP_CONFIGURE:
|
|
|
1259 {
|
|
|
1260 boolean_t target = TRUE;
|
|
|
1261
|
|
|
1262 /*
|
|
|
1263 * A port may be in an active or shutdown state.
|
|
|
1264 * If port is in a failed state, operation is aborted - one
|
|
|
1265 * has to use explicit connect or port activate request
|
|
|
1266 * to try to get a port into non-failed mode.
|
|
|
1267 *
|
|
|
1268 * If a port is in a shutdown state, arbitrarily invoke
|
|
|
1269 * sata_tran_port_activate() prior to any other operation.
|
|
|
1270 *
|
|
|
1271 * Verify that port state is READY and there is a device
|
|
|
1272 * of a supported type attached to this port.
|
|
|
1273 * If target node exists, a device was most likely offlined.
|
|
|
1274 * If target node does not exist, create a target node an
|
|
|
1275 * attempt to online it.
|
|
|
1276 * *
|
|
|
1277 * NO PMult or devices beyond PMult are supported yet.
|
|
|
1278 */
|
|
|
1279
|
|
|
1280 /* We only care about host controller's sata cport for now. */
|
|
|
1281 if (cportinfo->cport_state & SATA_PSTATE_FAILED) {
|
|
|
1282 rv = ENXIO;
|
|
|
1283 break;
|
|
|
1284 }
|
|
|
1285 /* Check the current state of the port */
|
|
|
1286 sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
|
|
|
1287
|
|
|
1288 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
|
|
|
1289 (dip, &sata_device);
|
|
|
1290 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
|
|
|
1291 cport_mutex);
|
|
|
1292 sata_update_port_info(sata_hba_inst, &sata_device);
|
|
|
1293 if (rval != SATA_SUCCESS ||
|
|
|
1294 (sata_device.satadev_state & SATA_PSTATE_FAILED)) {
|
|
|
1295 cportinfo->cport_state = SATA_PSTATE_FAILED;
|
|
|
1296 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
|
|
|
1297 cport_mutex);
|
|
|
1298 rv = EIO;
|
|
|
1299 break;
|
|
|
1300 }
|
|
|
1301 if (cportinfo->cport_state & SATA_PSTATE_SHUTDOWN) {
|
|
|
1302 target = TRUE;
|
|
|
1303 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
|
|
|
1304 cport_mutex);
|
|
|
1305
|
|
|
1306 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) != NULL) {
|
|
|
1307 /* Just let HBA driver to activate port */
|
|
|
1308 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
|
|
|
1309 (dip, &sata_device) != SATA_SUCCESS) {
|
|
|
1310 /*
|
|
|
1311 * Port activation failure - do not
|
|
|
1312 * change port state unless the state
|
|
|
1313 * returned by HBA indicates a port
|
|
|
1314 * failure.
|
|
|
1315 */
|
|
|
1316 mutex_enter(&SATA_CPORT_INFO(
|
|
|
1317 sata_hba_inst, cport)->cport_mutex);
|
|
|
1318 sata_update_port_info(sata_hba_inst,
|
|
|
1319 &sata_device);
|
|
|
1320 if (sata_device.satadev_state &
|
|
|
1321 SATA_PSTATE_FAILED) {
|
|
|
1322 cportinfo->cport_state =
|
|
|
1323 SATA_PSTATE_FAILED;
|
|
|
1324 }
|
|
|
1325 mutex_exit(&SATA_CPORT_INFO(
|
|
|
1326 sata_hba_inst, cport)->cport_mutex);
|
|
|
1327 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
1328 "sata_hba_ioctl: configure: "
|
|
|
1329 "failed to activate SATA cport %d",
|
|
|
1330 cport));
|
|
|
1331 rv = EIO;
|
|
|
1332 break;
|
|
|
1333 }
|
|
|
1334 }
|
|
|
1335 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
|
|
|
1336 cport_mutex);
|
|
|
1337 /* Virgin port state */
|
|
|
1338 cportinfo->cport_state = 0;
|
|
|
1339 }
|
|
|
1340 /*
|
|
|
1341 * Always reprobe port, to get current device info.
|
|
|
1342 */
|
|
|
1343 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
|
|
|
1344 if (sata_reprobe_port(sata_hba_inst, &sata_device) !=
|
|
|
1345 SATA_SUCCESS) {
|
|
|
1346 rv = EIO;
|
|
|
1347 break;
|
|
|
1348 }
|
|
|
1349 if (target == FALSE &&
|
|
|
1350 cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
|
|
|
1351 /*
|
|
|
1352 * That's the transition from "inactive" port to
|
|
|
1353 * active with device attached.
|
|
|
1354 */
|
|
|
1355 sata_log(sata_hba_inst, CE_WARN,
|
|
|
1356 "SATA device attached at port %d",
|
|
|
1357 cport);
|
|
|
1358 }
|
|
|
1359
|
|
|
1360 /*
|
|
|
1361 * This is where real configure starts.
|
|
|
1362 * Change following check for PMult support.
|
|
|
1363 */
|
|
|
1364 if (!(sata_device.satadev_type & SATA_VALID_DEV_TYPE)) {
|
|
|
1365 /* No device to configure */
|
|
|
1366 rv = ENXIO; /* No device to configure */
|
|
|
1367 break;
|
|
|
1368 }
|
|
|
1369
|
|
|
1370 /*
|
|
|
1371 * Here we may have a device in reset condition,
|
|
|
1372 * but because we are just configuring it, there is
|
|
|
1373 * no need to process the reset other than just
|
|
|
1374 * to clear device reset condition in the HBA driver.
|
|
|
1375 * Setting the flag SATA_EVNT_CLEAR_DEVICE_RESET will
|
|
|
1376 * cause a first command sent the HBA driver with the request
|
|
|
1377 * to clear device reset condition.
|
|
|
1378 */
|
|
|
1379 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
|
|
|
1380 cport_mutex);
|
|
|
1381 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
|
|
|
1382 if (sdinfo == NULL) {
|
|
|
1383 rv = ENXIO;
|
|
|
1384 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
|
|
|
1385 cport_mutex);
|
|
|
1386 break;
|
|
|
1387 }
|
|
|
1388 if (sdinfo->satadrv_event_flags &
|
|
|
1389 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET))
|
|
|
1390 sdinfo->satadrv_event_flags = 0;
|
|
|
1391 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET;
|
|
|
1392 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
|
|
|
1393
|
|
|
1394 if ((tdip = sata_get_target_dip(dip, comp_port)) != NULL) {
|
|
|
1395 /* target node still exists */
|
|
|
1396 if (ndi_devi_online(tdip, 0) != NDI_SUCCESS) {
|
|
|
1397 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
1398 "sata_hba_ioctl: configure: "
|
|
|
1399 "onlining device at cport %d failed",
|
|
|
1400 cport));
|
|
|
1401 rv = EIO;
|
|
|
1402 break;
|
|
|
1403 }
|
|
|
1404 } else {
|
|
|
1405 /*
|
|
|
1406 * No target node - need to create a new target node.
|
|
|
1407 */
|
|
|
1408 tdip = sata_create_target_node(dip, sata_hba_inst,
|
|
|
1409 &sata_device.satadev_addr);
|
|
|
1410 if (tdip == NULL) {
|
|
|
1411 /* configure failed */
|
|
|
1412 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
1413 "sata_hba_ioctl: configure: "
|
|
|
1414 "configuring device at cport %d "
|
|
|
1415 "failed", cport));
|
|
|
1416 rv = EIO;
|
|
|
1417 break;
|
|
|
1418 }
|
|
|
1419 }
|
|
|
1420
|
|
|
1421 break;
|
|
|
1422 }
|
|
|
1423
|
|
|
1424 case DEVCTL_AP_GETSTATE:
|
|
|
1425
|
|
|
1426 sata_cfgadm_state(sata_hba_inst, comp_port, &ap_state);
|
|
|
1427
|
|
|
1428 ap_state.ap_last_change = (time_t)-1;
|
|
|
1429 ap_state.ap_error_code = 0;
|
|
|
1430 ap_state.ap_in_transition = 0;
|
|
|
1431
|
|
|
1432 /* Copy the return AP-state information to the user space */
|
|
|
1433 if (ndi_dc_return_ap_state(&ap_state, dcp) != NDI_SUCCESS) {
|
|
|
1434 rv = EFAULT;
|
|
|
1435 }
|
|
|
1436 break;
|
|
|
1437
|
|
|
1438 case DEVCTL_AP_CONTROL:
|
|
|
1439 {
|
|
|
1440 /*
|
|
|
1441 * Generic devctl for hardware specific functionality
|
|
|
1442 */
|
|
|
1443 sata_ioctl_data_t ioc;
|
|
|
1444
|
|
|
1445 ASSERT(dcp == NULL);
|
|
|
1446
|
|
|
1447 /* Copy in user ioctl data first */
|
|
|
1448 #ifdef _MULTI_DATAMODEL
|
|
|
1449 if (ddi_model_convert_from(mode & FMODELS) ==
|
|
|
1450 DDI_MODEL_ILP32) {
|
|
|
1451
|
|
|
1452 sata_ioctl_data_32_t ioc32;
|
|
|
1453
|
|
|
1454 if (ddi_copyin((void *)arg, (void *)&ioc32,
|
|
|
1455 sizeof (ioc32), mode) != 0) {
|
|
|
1456 rv = EFAULT;
|
|
|
1457 break;
|
|
|
1458 }
|
|
|
1459 ioc.cmd = (uint_t)ioc32.cmd;
|
|
|
1460 ioc.port = (uint_t)ioc32.port;
|
|
|
1461 ioc.get_size = (uint_t)ioc32.get_size;
|
|
|
1462 ioc.buf = (caddr_t)(uintptr_t)ioc32.buf;
|
|
|
1463 ioc.bufsiz = (uint_t)ioc32.bufsiz;
|
|
|
1464 ioc.misc_arg = (uint_t)ioc32.misc_arg;
|
|
|
1465 } else
|
|
|
1466 #endif /* _MULTI_DATAMODEL */
|
|
|
1467 if (ddi_copyin((void *)arg, (void *)&ioc, sizeof (ioc),
|
|
|
1468 mode) != 0) {
|
|
|
1469 return (EFAULT);
|
|
|
1470 }
|
|
|
1471
|
|
|
1472 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
|
|
|
1473 "sata_hba_ioctl: DEVCTL_AP_CONTROL "
|
|
|
1474 "cmd 0x%x, port 0x%x", ioc.cmd, ioc.port);
|
|
|
1475
|
|
|
1476 /*
|
|
|
1477 * To avoid BE/LE and 32/64 issues, a get_size always returns
|
|
|
1478 * a 32-bit number.
|
|
|
1479 */
|
|
|
1480 if (ioc.get_size != 0 && ioc.bufsiz != (sizeof (uint32_t))) {
|
|
|
1481 return (EINVAL);
|
|
|
1482 }
|
|
|
1483 /* validate address */
|
|
|
1484 cport = SCSI_TO_SATA_CPORT(ioc.port);
|
|
|
1485 pmport = SCSI_TO_SATA_PMPORT(ioc.port);
|
|
|
1486 qual = SCSI_TO_SATA_ADDR_QUAL(ioc.port);
|
|
|
1487
|
|
|
1488 /* Override address qualifier - handle cport only for now */
|
|
|
1489 qual = SATA_ADDR_CPORT;
|
|
|
1490
|
|
|
1491 if (sata_validate_sata_address(sata_hba_inst, cport,
|
|
|
1492 pmport, qual) != 0)
|
|
|
1493 return (EINVAL);
|
|
|
1494
|
|
|
1495 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
|
|
|
1496 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
|
|
|
1497 cport_mutex);
|
|
|
1498 /* Is the port locked by event processing daemon ? */
|
|
|
1499 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) {
|
|
|
1500 /*
|
|
|
1501 * Cannot process ioctl request now. Come back later
|
|
|
1502 */
|
|
|
1503 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
|
|
|
1504 cport_mutex);
|
|
|
1505 return (EBUSY);
|
|
|
1506 }
|
|
|
1507 /* Block event processing for this port */
|
|
|
1508 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY;
|
|
|
1509 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
|
|
|
1510
|
|
|
1511
|
|
|
1512 sata_device.satadev_addr.cport = cport;
|
|
|
1513 sata_device.satadev_addr.pmport = pmport;
|
|
|
1514 sata_device.satadev_rev = SATA_DEVICE_REV;
|
|
|
1515
|
|
|
1516 switch (ioc.cmd) {
|
|
|
1517
|
|
|
1518 case SATA_CFGA_RESET_PORT:
|
|
|
1519 /*
|
|
|
1520 * There is no protection here for configured
|
|
|
1521 * device.
|
|
|
1522 */
|
|
|
1523
|
|
|
1524 /* Sanity check */
|
|
|
1525 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
|
|
|
1526 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
1527 "sata_hba_ioctl: "
|
|
|
1528 "sata_hba_tran missing required "
|
|
|
1529 "function sata_tran_reset_dport"));
|
|
|
1530 rv = EINVAL;
|
|
|
1531 break;
|
|
|
1532 }
|
|
|
1533
|
|
|
1534 /* handle cport only for now */
|
|
|
1535 sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
|
|
|
1536 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
|
|
|
1537 (dip, &sata_device) != SATA_SUCCESS) {
|
|
|
1538 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
1539 "sata_hba_ioctl: reset port: "
|
|
|
1540 "failed cport %d pmport %d",
|
|
|
1541 cport, pmport));
|
|
|
1542 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
|
|
|
1543 cport)->cport_mutex);
|
|
|
1544 sata_update_port_info(sata_hba_inst,
|
|
|
1545 &sata_device);
|
|
|
1546 SATA_CPORT_STATE(sata_hba_inst, cport) =
|
|
|
1547 SATA_PSTATE_FAILED;
|
|
|
1548 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
|
|
|
1549 cport)->cport_mutex);
|
|
|
1550 rv = EIO;
|
|
|
1551 }
|
|
|
1552 /*
|
|
|
1553 * Since the port was reset, it should be probed and
|
|
|
1554 * attached device reinitialized. At this point the
|
|
|
1555 * port state is unknown - it's state is HBA-specific.
|
|
|
1556 * Re-probe port to get its state.
|
|
|
1557 */
|
|
|
1558 if (sata_reprobe_port(sata_hba_inst, &sata_device) !=
|
|
|
1559 SATA_SUCCESS) {
|
|
|
1560 rv = EIO;
|
|
|
1561 break;
|
|
|
1562 }
|
|
|
1563 break;
|
|
|
1564
|
|
|
1565 case SATA_CFGA_RESET_DEVICE:
|
|
|
1566 /*
|
|
|
1567 * There is no protection here for configured
|
|
|
1568 * device.
|
|
|
1569 */
|
|
|
1570
|
|
|
1571 /* Sanity check */
|
|
|
1572 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
|
|
|
1573 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
1574 "sata_hba_ioctl: "
|
|
|
1575 "sata_hba_tran missing required "
|
|
|
1576 "function sata_tran_reset_dport"));
|
|
|
1577 rv = EINVAL;
|
|
|
1578 break;
|
|
|
1579 }
|
|
|
1580
|
|
|
1581 /* handle only device attached to cports, for now */
|
|
|
1582 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
|
|
|
1583
|
|
|
1584 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
|
|
|
1585 cport_mutex);
|
|
|
1586 sdinfo = sata_get_device_info(sata_hba_inst,
|
|
|
1587 &sata_device);
|
|
|
1588 if (sdinfo == NULL) {
|
|
|
1589 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
|
|
|
1590 cport)->cport_mutex);
|
|
|
1591 rv = EINVAL;
|
|
|
1592 break;
|
|
|
1593 }
|
|
|
1594 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
|
|
|
1595 cport_mutex);
|
|
|
1596
|
|
|
1597 /* only handle cport for now */
|
|
|
1598 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
|
|
|
1599 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
|
|
|
1600 (dip, &sata_device) != SATA_SUCCESS) {
|
|
|
1601 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
1602 "sata_hba_ioctl: reset device: failed "
|
|
|
1603 "cport %d pmport %d", cport, pmport));
|
|
|
1604 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
|
|
|
1605 cport)->cport_mutex);
|
|
|
1606 sata_update_port_info(sata_hba_inst,
|
|
|
1607 &sata_device);
|
|
|
1608 /*
|
|
|
1609 * Device info structure remains
|
|
|
1610 * attached. Another device reset or
|
|
|
1611 * port disconnect/connect and re-probing is
|
|
|
1612 * needed to change it's state
|
|
|
1613 */
|
|
|
1614 sdinfo->satadrv_state &= ~SATA_STATE_READY;
|
|
|
1615 sdinfo->satadrv_state |=
|
|
|
1616 SATA_DSTATE_FAILED;
|
|
|
1617 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
|
|
|
1618 cport)->cport_mutex);
|
|
|
1619 rv = EIO;
|
|
|
1620 }
|
|
|
1621 /*
|
|
|
1622 * Since the device was reset, we expect reset event
|
|
|
1623 * to be reported and processed.
|
|
|
1624 */
|
|
|
1625 break;
|
|
|
1626
|
|
|
1627 case SATA_CFGA_RESET_ALL:
|
|
|
1628 {
|
|
|
1629 int tcport;
|
|
|
1630
|
|
|
1631 /*
|
|
|
1632 * There is no protection here for configured
|
|
|
1633 * devices.
|
|
|
1634 */
|
|
|
1635 /* Sanity check */
|
|
|
1636 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
|
|
|
1637 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
1638 "sata_hba_ioctl: "
|
|
|
1639 "sata_hba_tran missing required "
|
|
|
1640 "function sata_tran_reset_dport"));
|
|
|
1641 rv = EINVAL;
|
|
|
1642 break;
|
|
|
1643 }
|
|
|
1644
|
|
|
1645 /*
|
|
|
1646 * Need to lock all ports, not just one.
|
|
|
1647 * If any port is locked by event processing, fail
|
|
|
1648 * the whole operation.
|
|
|
1649 * One port is already locked, but for simplicity
|
|
|
1650 * lock it again.
|
|
|
1651 */
|
|
|
1652 for (tcport = 0;
|
|
|
1653 tcport < SATA_NUM_CPORTS(sata_hba_inst);
|
|
|
1654 tcport++) {
|
|
|
1655 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
|
|
|
1656 tcport)->cport_mutex);
|
|
|
1657 if (((SATA_CPORT_INFO(sata_hba_inst, tcport)->
|
|
|
1658 cport_event_flags) &
|
|
|
1659 SATA_EVNT_LOCK_PORT_BUSY) != 0) {
|
|
|
1660 rv = EBUSY;
|
|
|
1661 mutex_exit(
|
|
|
1662 &SATA_CPORT_INFO(sata_hba_inst,
|
|
|
1663 tcport)->cport_mutex);
|
|
|
1664 break;
|
|
|
1665 } else {
|
|
|
1666 SATA_CPORT_INFO(sata_hba_inst,
|
|
|
1667 tcport)->cport_event_flags |=
|
|
|
1668 SATA_APCTL_LOCK_PORT_BUSY;
|
|
|
1669 }
|
|
|
1670 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
|
|
|
1671 tcport)->cport_mutex);
|
|
|
1672 }
|
|
|
1673
|
|
|
1674 if (rv == 0) {
|
|
|
1675 /*
|
|
|
1676 * All cports successfully locked.
|
|
|
1677 * Reset main SATA controller only for now -
|
|
|
1678 * no PMult.
|
|
|
1679 */
|
|
|
1680 sata_device.satadev_addr.qual =
|
|
|
1681 SATA_ADDR_CNTRL;
|
|
|
1682
|
|
|
1683 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
|
|
|
1684 (dip, &sata_device) != SATA_SUCCESS) {
|
|
|
1685 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
1686 "sata_hba_ioctl: reset controller "
|
|
|
1687 "failed"));
|
|
|
1688 rv = EIO;
|
|
|
1689 }
|
|
|
1690
|
|
|
1691 /*
|
|
|
1692 * Since ports were reset, they should be
|
|
|
1693 * re-probed and attached devices
|
|
|
1694 * reinitialized.
|
|
|
1695 * At this point port states are unknown,
|
|
|
1696 * Re-probe ports to get their state -
|
|
|
1697 * cports only for now.
|
|
|
1698 */
|
|
|
1699 for (tcport = 0;
|
|
|
1700 tcport < SATA_NUM_CPORTS(sata_hba_inst);
|
|
|
1701 tcport++) {
|
|
|
1702 sata_device.satadev_addr.cport =
|
|
|
1703 tcport;
|
|
|
1704 sata_device.satadev_addr.qual =
|
|
|
1705 SATA_ADDR_CPORT;
|
|
|
1706
|
|
|
1707 if (sata_reprobe_port(sata_hba_inst,
|
|
|
1708 &sata_device) != SATA_SUCCESS)
|
|
|
1709 rv = EIO;
|
|
|
1710
|
|
|
1711 }
|
|
|
1712 }
|
|
|
1713 /*
|
|
|
1714 * Unlock all ports
|
|
|
1715 */
|
|
|
1716 for (tcport = 0;
|
|
|
1717 tcport < SATA_NUM_CPORTS(sata_hba_inst);
|
|
|
1718 tcport++) {
|
|
|
1719 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
|
|
|
1720 tcport)->cport_mutex);
|
|
|
1721 SATA_CPORT_INFO(sata_hba_inst, tcport)->
|
|
|
1722 cport_event_flags &=
|
|
|
1723 ~SATA_APCTL_LOCK_PORT_BUSY;
|
|
|
1724 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
|
|
|
1725 tcport)->cport_mutex);
|
|
|
1726 }
|
|
|
1727
|
|
|
1728 /*
|
|
|
1729 * This operation returns EFAULT if either reset
|
|
|
1730 * controller failed or a re-probbing of any ports
|
|
|
1731 * failed.
|
|
|
1732 * We return here, because common return is for
|
|
|
1733 * a single cport operation.
|
|
|
1734 */
|
|
|
1735 return (rv);
|
|
|
1736 }
|
|
|
1737
|
|
|
1738 case SATA_CFGA_PORT_DEACTIVATE:
|
|
|
1739 /* Sanity check */
|
|
|
1740 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) {
|
|
|
1741 rv = ENOTSUP;
|
|
|
1742 break;
|
|
|
1743 }
|
|
|
1744 /*
|
|
|
1745 * Arbitrarily unconfigure attached device, if any.
|
|
|
1746 * Even if the unconfigure fails, proceed with the
|
|
|
1747 * port deactivation.
|
|
|
1748 */
|
|
|
1749
|
|
|
1750 /* Handle only device attached to cports, for now */
|
|
|
1751 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
|
|
|
1752
|
|
|
1753 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
|
|
|
1754 cport_mutex);
|
|
|
1755 cportinfo->cport_state &= ~SATA_STATE_READY;
|
|
|
1756 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
|
|
|
1757 /*
|
|
|
1758 * Handle only device attached to cports,
|
|
|
1759 * for now
|
|
|
1760 */
|
|
|
1761 sata_device.satadev_addr.qual =
|
|
|
1762 SATA_ADDR_DCPORT;
|
|
|
1763 sdinfo = sata_get_device_info(sata_hba_inst,
|
|
|
1764 &sata_device);
|
|
|
1765 if (sdinfo != NULL &&
|
|
|
1766 (sdinfo->satadrv_type &
|
|
|
1767 SATA_VALID_DEV_TYPE)) {
|
|
|
1768 /*
|
|
|
1769 * If a target node exists, try to
|
|
|
1770 * offline a device and remove target
|
|
|
1771 * node.
|
|
|
1772 */
|
|
|
1773 mutex_exit(&SATA_CPORT_INFO(
|
|
|
1774 sata_hba_inst, cport)->cport_mutex);
|
|
|
1775 tdip = sata_get_target_dip(dip, cport);
|
|
|
1776 if (tdip != NULL) {
|
|
|
1777 /* target node exist */
|
|
|
1778 SATADBG1(SATA_DBG_IOCTL_IF,
|
|
|
1779 sata_hba_inst,
|
|
|
1780 "sata_hba_ioctl: "
|
|
|
1781 "port deactivate: "
|
|
|
1782 "target node exists.",
|
|
|
1783 NULL);
|
|
|
1784
|
|
|
1785 if (ndi_devi_offline(tdip,
|
|
|
1786 NDI_UNCONFIG) !=
|
|
|
1787 NDI_SUCCESS) {
|
|
|
1788 SATA_LOG_D((
|
|
|
1789 sata_hba_inst,
|
|
|
1790 CE_WARN,
|
|
|
1791 "sata_hba_ioctl:"
|
|
|
1792 "port deactivate: "
|
|
|
1793 "failed to "
|
|
|
1794 "unconfigure "
|
|
|
1795 "device at cport "
|
|
|
1796 "%d", cport));
|
|
|
1797 }
|
|
|
1798 if (ndi_devi_offline(tdip,
|
|
|
1799 NDI_DEVI_REMOVE) !=
|
|
|
1800 NDI_SUCCESS) {
|
|
|
1801 /*
|
|
|
1802 * Problem;
|
|
|
1803 * target node remained
|
|
|
1804 * attached.
|
|
|
1805 * Too bad...
|
|
|
1806 */
|
|
|
1807 SATA_LOG_D((
|
|
|
1808 sata_hba_inst,
|
|
|
1809 CE_WARN,
|
|
|
1810 "sata_hba_ioctl: "
|
|
|
1811 "port deactivate: "
|
|
|
1812 "failed to "
|
|
|
1813 "unconfigure "
|
|
|
1814 "device at "
|
|
|
1815 "cport %d",
|
|
|
1816 cport));
|
|
|
1817 }
|
|
|
1818 }
|
|
|
1819 mutex_enter(&SATA_CPORT_INFO(
|
|
|
1820 sata_hba_inst, cport)->cport_mutex);
|
|
|
1821 /*
|
|
|
1822 * In any case,
|
|
|
1823 * remove and release sata_drive_info
|
|
|
1824 * structure.
|
|
|
1825 * (cport attached device ony, for now)
|
|
|
1826 */
|
|
|
1827 SATA_CPORTINFO_DRV_INFO(cportinfo) =
|
|
|
1828 NULL;
|
|
|
1829 (void) kmem_free((void *)sdinfo,
|
|
|
1830 sizeof (sata_drive_info_t));
|
|
|
1831 cportinfo->cport_dev_type =
|
|
|
1832 SATA_DTYPE_NONE;
|
|
|
1833 }
|
|
|
1834 /*
|
|
|
1835 * Note: PMult info requires different
|
|
|
1836 * handling. This comment is a placeholder for
|
|
|
1837 * a code handling PMult, to be implemented
|
|
|
1838 * in phase 2.
|
|
|
1839 */
|
|
|
1840 }
|
|
|
1841 cportinfo->cport_state &= ~(SATA_STATE_PROBED |
|
|
|
1842 SATA_STATE_PROBING);
|
|
|
1843 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
|
|
|
1844 cport_mutex);
|
|
|
1845 /* handle cport only for now */
|
|
|
1846 sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
|
|
|
1847 /* Just let HBA driver to deactivate port */
|
|
|
1848 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
|
|
|
1849 (dip, &sata_device);
|
|
|
1850 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
|
|
|
1851 cport_mutex);
|
|
|
1852 sata_update_port_info(sata_hba_inst, &sata_device);
|
|
|
1853 if (rval != SATA_SUCCESS) {
|
|
|
1854 /*
|
|
|
1855 * Port deactivation failure - do not
|
|
|
1856 * change port state unless the state
|
|
|
1857 * returned by HBA indicates a port failure.
|
|
|
1858 */
|
|
|
1859 if (sata_device.satadev_state &
|
|
|
1860 SATA_PSTATE_FAILED) {
|
|
|
1861 SATA_CPORT_STATE(sata_hba_inst,
|
|
|
1862 cport) = SATA_PSTATE_FAILED;
|
|
|
1863 }
|
|
|
1864 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
1865 "sata_hba_ioctl: port deactivate: "
|
|
|
1866 "cannot deactivate SATA cport %d",
|
|
|
1867 cport));
|
|
|
1868 rv = EIO;
|
|
|
1869 } else {
|
|
|
1870 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
|
|
|
1871 }
|
|
|
1872 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
|
|
|
1873 cport_mutex);
|
|
|
1874
|
|
|
1875 break;
|
|
|
1876
|
|
|
1877 case SATA_CFGA_PORT_ACTIVATE:
|
|
|
1878 {
|
|
|
1879 boolean_t dev_existed = TRUE;
|
|
|
1880
|
|
|
1881 /* Sanity check */
|
|
|
1882 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) {
|
|
|
1883 rv = ENOTSUP;
|
|
|
1884 break;
|
|
|
1885 }
|
|
|
1886 /* handle cport only for now */
|
|
|
1887 if (cportinfo->cport_state & SATA_PSTATE_SHUTDOWN ||
|
|
|
1888 cportinfo->cport_dev_type == SATA_DTYPE_NONE)
|
|
|
1889 dev_existed = FALSE;
|
|
|
1890
|
|
|
1891 sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
|
|
|
1892 /* Just let HBA driver to activate port */
|
|
|
1893 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
|
|
|
1894 (dip, &sata_device) != SATA_SUCCESS) {
|
|
|
1895 /*
|
|
|
1896 * Port activation failure - do not
|
|
|
1897 * change port state unless the state
|
|
|
1898 * returned by HBA indicates a port failure.
|
|
|
1899 */
|
|
|
1900 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
|
|
|
1901 cport)->cport_mutex);
|
|
|
1902 sata_update_port_info(sata_hba_inst,
|
|
|
1903 &sata_device);
|
|
|
1904 if (sata_device.satadev_state &
|
|
|
1905 SATA_PSTATE_FAILED) {
|
|
|
1906 SATA_CPORT_STATE(sata_hba_inst,
|
|
|
1907 cport) = SATA_PSTATE_FAILED;
|
|
|
1908 }
|
|
|
1909 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
|
|
|
1910 cport)->cport_mutex);
|
|
|
1911 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
1912 "sata_hba_ioctl: port activate: "
|
|
|
1913 "cannot activate SATA cport %d",
|
|
|
1914 cport));
|
|
|
1915 rv = EIO;
|
|
|
1916 break;
|
|
|
1917 }
|
|
|
1918 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
|
|
|
1919 cport_mutex);
|
|
|
1920 cportinfo->cport_state &= ~SATA_PSTATE_SHUTDOWN;
|
|
|
1921 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
|
|
|
1922 cport_mutex);
|
|
|
1923
|
|
|
1924 /*
|
|
|
1925 * Re-probe port to find its current state and
|
|
|
1926 * possibly attached device.
|
|
|
1927 * Port re-probing may change the cportinfo device
|
|
|
1928 * type if device is found attached.
|
|
|
1929 * If port probing failed, the device type would be
|
|
|
1930 * set to SATA_DTYPE_NONE.
|
|
|
1931 */
|
|
|
1932 (void) sata_reprobe_port(sata_hba_inst, &sata_device);
|
|
|
1933
|
|
|
1934 if (dev_existed == FALSE &&
|
|
|
1935 cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
|
|
|
1936 /*
|
|
|
1937 * That's the transition from "inactive" port
|
|
|
1938 * state or active port without a device
|
|
|
1939 * attached to the active port state with
|
|
|
1940 * a device attached.
|
|
|
1941 */
|
|
|
1942 sata_log(sata_hba_inst, CE_WARN,
|
|
|
1943 "SATA device attached at port %d", cport);
|
|
|
1944 }
|
|
|
1945
|
|
|
1946 break;
|
|
|
1947 }
|
|
|
1948
|
|
|
1949 case SATA_CFGA_PORT_SELF_TEST:
|
|
|
1950
|
|
|
1951 /* Sanity check */
|
|
|
1952 if (SATA_SELFTEST_FUNC(sata_hba_inst) == NULL) {
|
|
|
1953 rv = ENOTSUP;
|
|
|
1954 break;
|
|
|
1955 }
|
|
|
1956 /*
|
|
|
1957 * There is no protection here for a configured
|
|
|
1958 * device attached to this port.
|
|
|
1959 */
|
|
|
1960
|
|
|
1961 /* only handle cport for now */
|
|
|
1962 sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
|
|
|
1963
|
|
|
1964 if ((*SATA_SELFTEST_FUNC(sata_hba_inst))
|
|
|
1965 (dip, &sata_device) != SATA_SUCCESS) {
|
|
|
1966 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
1967 "sata_hba_ioctl: port selftest: "
|
|
|
1968 "failed cport %d pmport %d",
|
|
|
1969 cport, pmport));
|
|
|
1970 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
|
|
|
1971 cport)->cport_mutex);
|
|
|
1972 sata_update_port_info(sata_hba_inst,
|
|
|
1973 &sata_device);
|
|
|
1974 SATA_CPORT_STATE(sata_hba_inst, cport) =
|
|
|
1975 SATA_PSTATE_FAILED;
|
|
|
1976 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
|
|
|
1977 cport)->cport_mutex);
|
|
|
1978 rv = EIO;
|
|
|
1979 break;
|
|
|
1980 }
|
|
|
1981 /*
|
|
|
1982 * Since the port was reset, it should be probed and
|
|
|
1983 * attached device reinitialized. At this point the
|
|
|
1984 * port state is unknown - it's state is HBA-specific.
|
|
|
1985 * Force port re-probing to get it into a known state.
|
|
|
1986 */
|
|
|
1987 if (sata_reprobe_port(sata_hba_inst, &sata_device) !=
|
|
|
1988 SATA_SUCCESS) {
|
|
|
1989 rv = EIO;
|
|
|
1990 break;
|
|
|
1991 }
|
|
|
1992 break;
|
|
|
1993
|
|
|
1994 case SATA_CFGA_GET_DEVICE_PATH:
|
|
|
1995 {
|
|
|
1996 char path[MAXPATHLEN];
|
|
|
1997 uint32_t size;
|
|
|
1998
|
|
|
1999 (void) strcpy(path, "/devices");
|
|
|
2000 if ((tdip = sata_get_target_dip(dip, ioc.port)) ==
|
|
|
2001 NULL) {
|
|
|
2002
|
|
|
2003 /*
|
|
|
2004 * No such device.
|
|
|
2005 * If this is a request for a size, do not
|
|
|
2006 * return EINVAL for non-exisiting target,
|
|
|
2007 * because cfgadm will indicate a meaningless
|
|
|
2008 * ioctl failure.
|
|
|
2009 * If this is a real request for a path,
|
|
|
2010 * indicate invalid argument.
|
|
|
2011 */
|
|
|
2012 if (!ioc.get_size) {
|
|
|
2013 rv = EINVAL;
|
|
|
2014 break;
|
|
|
2015 }
|
|
|
2016 } else {
|
|
|
2017 (void) ddi_pathname(tdip, path + strlen(path));
|
|
|
2018 }
|
|
|
2019 size = strlen(path) + 1;
|
|
|
2020
|
|
|
2021 if (ioc.get_size) {
|
|
|
2022 if (ddi_copyout((void *)&size,
|
|
|
2023 ioc.buf, ioc.bufsiz, mode) != 0) {
|
|
|
2024 rv = EFAULT;
|
|
|
2025 }
|
|
|
2026 } else {
|
|
|
2027 if (ioc.bufsiz != size) {
|
|
|
2028 rv = EINVAL;
|
|
|
2029 } else if (ddi_copyout((void *)&path,
|
|
|
2030 ioc.buf, ioc.bufsiz, mode) != 0) {
|
|
|
2031 rv = EFAULT;
|
|
|
2032 }
|
|
|
2033 }
|
|
|
2034 break;
|
|
|
2035 }
|
|
|
2036
|
|
|
2037 case SATA_CFGA_GET_AP_TYPE:
|
|
|
2038 {
|
|
|
2039 uint32_t type_len;
|
|
|
2040 const char *ap_type;
|
|
|
2041
|
|
|
2042 /* cport only, no port multiplier support */
|
|
|
2043 switch (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport)) {
|
|
|
2044 case SATA_DTYPE_NONE:
|
|
|
2045 ap_type = "port";
|
|
|
2046 break;
|
|
|
2047
|
|
|
2048 case SATA_DTYPE_ATADISK:
|
|
|
2049 ap_type = "disk";
|
|
|
2050 break;
|
|
|
2051
|
|
|
2052 case SATA_DTYPE_ATAPICD:
|
|
|
2053 ap_type = "cd/dvd";
|
|
|
2054 break;
|
|
|
2055
|
|
|
2056 case SATA_DTYPE_PMULT:
|
|
|
2057 ap_type = "pmult";
|
|
|
2058 break;
|
|
|
2059
|
|
|
2060 case SATA_DTYPE_UNKNOWN:
|
|
|
2061 ap_type = "unknown";
|
|
|
2062 break;
|
|
|
2063
|
|
|
2064 default:
|
|
|
2065 ap_type = "unsupported";
|
|
|
2066 break;
|
|
|
2067
|
|
|
2068 } /* end of dev_type switch */
|
|
|
2069
|
|
|
2070 type_len = strlen(ap_type) + 1;
|
|
|
2071
|
|
|
2072 if (ioc.get_size) {
|
|
|
2073 if (ddi_copyout((void *)&type_len,
|
|
|
2074 ioc.buf, ioc.bufsiz, mode) != 0) {
|
|
|
2075 rv = EFAULT;
|
|
|
2076 break;
|
|
|
2077 }
|
|
|
2078 } else {
|
|
|
2079 if (ioc.bufsiz != type_len) {
|
|
|
2080 rv = EINVAL;
|
|
|
2081 break;
|
|
|
2082 }
|
|
|
2083 if (ddi_copyout((void *)ap_type, ioc.buf,
|
|
|
2084 ioc.bufsiz, mode) != 0) {
|
|
|
2085 rv = EFAULT;
|
|
|
2086 break;
|
|
|
2087 }
|
|
|
2088 }
|
|
|
2089
|
|
|
2090 break;
|
|
|
2091 }
|
|
|
2092
|
|
|
2093 case SATA_CFGA_GET_MODEL_INFO:
|
|
|
2094 {
|
|
|
2095 uint32_t info_len;
|
|
|
2096 char ap_info[sizeof (sdinfo->satadrv_id.ai_model) + 1];
|
|
|
2097
|
|
|
2098 /*
|
|
|
2099 * This operation should return to cfgadm the
|
|
|
2100 * device model information string
|
|
|
2101 */
|
|
|
2102 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
|
|
|
2103 cport_mutex);
|
|
|
2104 /* only handle device connected to cport for now */
|
|
|
2105 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
|
|
|
2106 sdinfo = sata_get_device_info(sata_hba_inst,
|
|
|
2107 &sata_device);
|
|
|
2108 if (sdinfo == NULL) {
|
|
|
2109 rv = EINVAL;
|
|
|
2110 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
|
|
|
2111 cport)->cport_mutex);
|
|
|
2112 break;
|
|
|
2113 }
|
|
|
2114 bcopy(sdinfo->satadrv_id.ai_model, ap_info,
|
|
|
2115 sizeof (sdinfo->satadrv_id.ai_model));
|
|
|
2116 swab(ap_info, ap_info,
|
|
|
2117 sizeof (sdinfo->satadrv_id.ai_model));
|
|
|
2118 ap_info[sizeof (sdinfo->satadrv_id.ai_model)] = '\0';
|
|
|
2119
|
|
|
2120 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
|
|
|
2121 cport_mutex);
|
|
|
2122
|
|
|
2123 info_len = strlen(ap_info) + 1;
|
|
|
2124
|
|
|
2125 if (ioc.get_size) {
|
|
|
2126 if (ddi_copyout((void *)&info_len,
|
|
|
2127 ioc.buf, ioc.bufsiz, mode) != 0) {
|
|
|
2128 rv = EFAULT;
|
|
|
2129 break;
|
|
|
2130 }
|
|
|
2131 } else {
|
|
|
2132 if (ioc.bufsiz < info_len) {
|
|
|
2133 rv = EINVAL;
|
|
|
2134 break;
|
|
|
2135 }
|
|
|
2136 if (ddi_copyout((void *)ap_info, ioc.buf,
|
|
|
2137 ioc.bufsiz, mode) != 0) {
|
|
|
2138 rv = EFAULT;
|
|
|
2139 break;
|
|
|
2140 }
|
|
|
2141 }
|
|
|
2142
|
|
|
2143 break;
|
|
|
2144 }
|
|
|
2145
|
|
|
2146 case SATA_CFGA_GET_REVFIRMWARE_INFO:
|
|
|
2147 {
|
|
|
2148 uint32_t info_len;
|
|
|
2149 char ap_info[
|
|
|
2150 sizeof (sdinfo->satadrv_id.ai_fw) + 1];
|
|
|
2151
|
|
|
2152 /*
|
|
|
2153 * This operation should return to cfgadm the
|
|
|
2154 * device firmware revision information string
|
|
|
2155 */
|
|
|
2156 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
|
|
|
2157 cport_mutex);
|
|
|
2158 /* only handle device connected to cport for now */
|
|
|
2159 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
|
|
|
2160
|
|
|
2161 sdinfo = sata_get_device_info(sata_hba_inst,
|
|
|
2162 &sata_device);
|
|
|
2163 if (sdinfo == NULL) {
|
|
|
2164 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
|
|
|
2165 cport)->cport_mutex);
|
|
|
2166 rv = EINVAL;
|
|
|
2167 break;
|
|
|
2168 }
|
|
|
2169 bcopy(sdinfo->satadrv_id.ai_fw, ap_info,
|
|
|
2170 sizeof (sdinfo->satadrv_id.ai_fw));
|
|
|
2171 swab(ap_info, ap_info,
|
|
|
2172 sizeof (sdinfo->satadrv_id.ai_fw));
|
|
|
2173 ap_info[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0';
|
|
|
2174
|
|
|
2175 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
|
|
|
2176 cport_mutex);
|
|
|
2177
|
|
|
2178 info_len = strlen(ap_info) + 1;
|
|
|
2179
|
|
|
2180 if (ioc.get_size) {
|
|
|
2181 if (ddi_copyout((void *)&info_len,
|
|
|
2182 ioc.buf, ioc.bufsiz, mode) != 0) {
|
|
|
2183 rv = EFAULT;
|
|
|
2184 break;
|
|
|
2185 }
|
|
|
2186 } else {
|
|
|
2187 if (ioc.bufsiz < info_len) {
|
|
|
2188 rv = EINVAL;
|
|
|
2189 break;
|
|
|
2190 }
|
|
|
2191 if (ddi_copyout((void *)ap_info, ioc.buf,
|
|
|
2192 ioc.bufsiz, mode) != 0) {
|
|
|
2193 rv = EFAULT;
|
|
|
2194 break;
|
|
|
2195 }
|
|
|
2196 }
|
|
|
2197
|
|
|
2198 break;
|
|
|
2199 }
|
|
|
2200
|
|
|
2201 case SATA_CFGA_GET_SERIALNUMBER_INFO:
|
|
|
2202 {
|
|
|
2203 uint32_t info_len;
|
|
|
2204 char ap_info[
|
|
|
2205 sizeof (sdinfo->satadrv_id.ai_drvser) + 1];
|
|
|
2206
|
|
|
2207 /*
|
|
|
2208 * This operation should return to cfgadm the
|
|
|
2209 * device serial number information string
|
|
|
2210 */
|
|
|
2211 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
|
|
|
2212 cport_mutex);
|
|
|
2213 /* only handle device connected to cport for now */
|
|
|
2214 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
|
|
|
2215
|
|
|
2216 sdinfo = sata_get_device_info(sata_hba_inst,
|
|
|
2217 &sata_device);
|
|
|
2218 if (sdinfo == NULL) {
|
|
|
2219 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
|
|
|
2220 cport)->cport_mutex);
|
|
|
2221 rv = EINVAL;
|
|
|
2222 break;
|
|
|
2223 }
|
|
|
2224 bcopy(sdinfo->satadrv_id.ai_drvser, ap_info,
|
|
|
2225 sizeof (sdinfo->satadrv_id.ai_drvser));
|
|
|
2226 swab(ap_info, ap_info,
|
|
|
2227 sizeof (sdinfo->satadrv_id.ai_drvser));
|
|
|
2228 ap_info[sizeof (sdinfo->satadrv_id.ai_drvser)] = '\0';
|
|
|
2229
|
|
|
2230 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
|
|
|
2231 cport_mutex);
|
|
|
2232
|
|
|
2233 info_len = strlen(ap_info) + 1;
|
|
|
2234
|
|
|
2235 if (ioc.get_size) {
|
|
|
2236 if (ddi_copyout((void *)&info_len,
|
|
|
2237 ioc.buf, ioc.bufsiz, mode) != 0) {
|
|
|
2238 rv = EFAULT;
|
|
|
2239 break;
|
|
|
2240 }
|
|
|
2241 } else {
|
|
|
2242 if (ioc.bufsiz < info_len) {
|
|
|
2243 rv = EINVAL;
|
|
|
2244 break;
|
|
|
2245 }
|
|
|
2246 if (ddi_copyout((void *)ap_info, ioc.buf,
|
|
|
2247 ioc.bufsiz, mode) != 0) {
|
|
|
2248 rv = EFAULT;
|
|
|
2249 break;
|
|
|
2250 }
|
|
|
2251 }
|
|
|
2252
|
|
|
2253 break;
|
|
|
2254 }
|
|
|
2255
|
|
|
2256 default:
|
|
|
2257 rv = EINVAL;
|
|
|
2258 break;
|
|
|
2259
|
|
|
2260 } /* End of DEVCTL_AP_CONTROL cmd switch */
|
|
|
2261
|
|
|
2262 break;
|
|
|
2263 }
|
|
|
2264
|
|
|
2265 default:
|
|
|
2266 {
|
|
|
2267 /*
|
|
|
2268 * If we got here, we got an IOCTL that SATA HBA Framework
|
|
|
2269 * does not recognize. Pass ioctl to HBA driver, in case
|
|
|
2270 * it could process it.
|
|
|
2271 */
|
|
|
2272 sata_hba_tran_t *sata_tran = sata_hba_inst->satahba_tran;
|
|
|
2273 dev_info_t *mydip = SATA_DIP(sata_hba_inst);
|
|
|
2274
|
|
|
2275 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
|
|
|
2276 "IOCTL 0x%2x not supported in SATA framework, "
|
|
|
2277 "passthrough to HBA", cmd);
|
|
|
2278
|
|
|
2279 if (sata_tran->sata_tran_ioctl == NULL) {
|
|
|
2280 rv = EINVAL;
|
|
|
2281 break;
|
|
|
2282 }
|
|
|
2283 rval = (*sata_tran->sata_tran_ioctl)(mydip, cmd, arg);
|
|
|
2284 if (rval != 0) {
|
|
|
2285 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
|
|
|
2286 "IOCTL 0x%2x failed in HBA", cmd);
|
|
|
2287 rv = rval;
|
|
|
2288 }
|
|
|
2289 break;
|
|
|
2290 }
|
|
|
2291
|
|
|
2292 } /* End of main IOCTL switch */
|
|
|
2293
|
|
|
2294 if (dcp) {
|
|
|
2295 ndi_dc_freehdl(dcp);
|
|
|
2296 }
|
|
|
2297 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
|
|
|
2298 cportinfo->cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY;
|
|
|
2299 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
|
|
|
2300
|
|
|
2301 return (rv);
|
|
|
2302 }
|
|
|
2303
|
|
|
2304
|
|
|
2305
|
|
|
2306
|
|
|
2307 /* ****************** SCSA required entry points *********************** */
|
|
|
2308
|
|
|
2309 /*
|
|
|
2310 * Implementation of scsi tran_tgt_init.
|
|
|
2311 * sata_scsi_tgt_init() initializes scsi_device structure
|
|
|
2312 *
|
|
|
2313 * If successful, DDI_SUCCESS is returned.
|
|
|
2314 * DDI_FAILURE is returned if addressed device does not exist
|
|
|
2315 */
|
|
|
2316
|
|
|
2317 static int
|
|
|
2318 sata_scsi_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip,
|
|
|
2319 scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
|
|
|
2320 {
|
|
|
2321 #ifndef __lock_lint
|
|
|
2322 _NOTE(ARGUNUSED(hba_dip))
|
|
|
2323 #endif
|
|
|
2324 sata_device_t sata_device;
|
|
|
2325 sata_drive_info_t *sdinfo;
|
|
|
2326 sata_hba_inst_t *sata_hba_inst;
|
|
|
2327
|
|
|
2328 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private);
|
|
|
2329
|
|
|
2330 /* Validate scsi device address */
|
|
|
2331 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address,
|
|
|
2332 &sata_device) != 0)
|
|
|
2333 return (DDI_FAILURE);
|
|
|
2334
|
|
|
2335 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
2336 sata_device.satadev_addr.cport)));
|
|
|
2337
|
|
|
2338 /* sata_device now contains a valid sata address */
|
|
|
2339 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
|
|
|
2340 if (sdinfo == NULL) {
|
|
|
2341 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
2342 sata_device.satadev_addr.cport)));
|
|
|
2343 return (DDI_FAILURE);
|
|
|
2344 }
|
|
|
2345 if (sata_device.satadev_type == SATA_DTYPE_ATAPICD) {
|
|
|
2346 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
2347 sata_device.satadev_addr.cport)));
|
|
|
2348 if (ndi_prop_update_string(DDI_DEV_T_NONE, tgt_dip,
|
|
|
2349 "variant", "atapi") != DDI_PROP_SUCCESS) {
|
|
|
2350 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
2351 "sata_scsi_tgt_init: variant atapi "
|
|
|
2352 "property could not be created"));
|
|
|
2353 return (DDI_FAILURE);
|
|
|
2354 }
|
|
|
2355 return (DDI_SUCCESS);
|
|
|
2356 }
|
|
|
2357 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
2358 sata_device.satadev_addr.cport)));
|
|
|
2359 return (DDI_SUCCESS);
|
|
|
2360 }
|
|
|
2361
|
|
|
2362 /*
|
|
|
2363 * Implementation of scsi tran_tgt_probe.
|
|
|
2364 * Probe target, by calling default scsi routine scsi_hba_probe()
|
|
|
2365 */
|
|
|
2366 static int
|
|
|
2367 sata_scsi_tgt_probe(struct scsi_device *sd, int (*callback)(void))
|
|
|
2368 {
|
|
|
2369 sata_hba_inst_t *sata_hba_inst =
|
|
|
2370 (sata_hba_inst_t *)(sd->sd_address.a_hba_tran->tran_hba_private);
|
|
|
2371 int rval;
|
|
|
2372
|
|
|
2373 rval = scsi_hba_probe(sd, callback);
|
|
|
2374
|
|
|
2375 if (rval == SCSIPROBE_EXISTS) {
|
|
|
2376 /*
|
|
|
2377 * Set property "pm-capable" on the target device node, so that
|
|
|
2378 * the target driver will not try to fetch scsi cycle counters
|
|
|
2379 * before enabling device power-management.
|
|
|
2380 */
|
|
|
2381 if ((ddi_prop_update_int(DDI_DEV_T_NONE, sd->sd_dev,
|
|
|
2382 "pm-capable", 1)) != DDI_PROP_SUCCESS) {
|
|
|
2383 sata_log(sata_hba_inst, CE_WARN,
|
|
|
2384 "device at port %d: will not be power-managed ",
|
|
|
2385 SCSI_TO_SATA_CPORT(sd->sd_address.a_target));
|
|
|
2386 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
2387 "failure updating pm-capable property"));
|
|
|
2388 }
|
|
|
2389 }
|
|
|
2390 return (rval);
|
|
|
2391 }
|
|
|
2392
|
|
|
2393 /*
|
|
|
2394 * Implementation of scsi tran_tgt_free.
|
|
|
2395 * Release all resources allocated for scsi_device
|
|
|
2396 */
|
|
|
2397 static void
|
|
|
2398 sata_scsi_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip,
|
|
|
2399 scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
|
|
|
2400 {
|
|
|
2401 #ifndef __lock_lint
|
|
|
2402 _NOTE(ARGUNUSED(hba_dip))
|
|
|
2403 #endif
|
|
|
2404 sata_device_t sata_device;
|
|
|
2405 sata_drive_info_t *sdinfo;
|
|
|
2406 sata_hba_inst_t *sata_hba_inst;
|
|
|
2407
|
|
|
2408 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private);
|
|
|
2409
|
|
|
2410 /* Validate scsi device address */
|
|
|
2411 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address,
|
|
|
2412 &sata_device) != 0)
|
|
|
2413 return;
|
|
|
2414
|
|
|
2415 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
2416 sata_device.satadev_addr.cport)));
|
|
|
2417
|
|
|
2418 /* sata_device now should contain a valid sata address */
|
|
|
2419 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
|
|
|
2420 if (sdinfo == NULL) {
|
|
|
2421 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
2422 sata_device.satadev_addr.cport)));
|
|
|
2423 return;
|
|
|
2424 }
|
|
|
2425 /*
|
|
|
2426 * We did not allocate any resources in sata_scsi_tgt_init()
|
|
|
2427 * other than property for ATAPI device, if any
|
|
|
2428 */
|
|
|
2429 if (sata_device.satadev_type == SATA_DTYPE_ATAPICD) {
|
|
|
2430 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
2431 sata_device.satadev_addr.cport)));
|
|
|
2432 if (ndi_prop_remove(DDI_DEV_T_NONE, tgt_dip, "variant") !=
|
|
|
2433 DDI_PROP_SUCCESS)
|
|
|
2434 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
2435 "sata_scsi_tgt_free: variant atapi "
|
|
|
2436 "property could not be removed"));
|
|
|
2437 } else {
|
|
|
2438 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
2439 sata_device.satadev_addr.cport)));
|
|
|
2440 }
|
|
|
2441 }
|
|
|
2442
|
|
|
2443 /*
|
|
|
2444 * Implementation of scsi tran_init_pkt
|
|
|
2445 * Upon successful return, scsi pkt buffer has DMA resources allocated.
|
|
|
2446 *
|
|
|
2447 * It seems that we should always allocate pkt, even if the address is
|
|
|
2448 * for non-existing device - just use some default for dma_attr.
|
|
|
2449 * The reason is that there is no way to communicate this to a caller here.
|
|
|
2450 * Subsequent call to sata_scsi_start may fail appropriately.
|
|
|
2451 * Simply returning NULL does not seem to discourage a target driver...
|
|
|
2452 *
|
|
|
2453 * Returns a pointer to initialized scsi_pkt, or NULL otherwise.
|
|
|
2454 */
|
|
|
2455 static struct scsi_pkt *
|
|
|
2456 sata_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt,
|
|
|
2457 struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags,
|
|
|
2458 int (*callback)(caddr_t), caddr_t arg)
|
|
|
2459 {
|
|
|
2460 sata_hba_inst_t *sata_hba_inst =
|
|
|
2461 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
|
|
|
2462 dev_info_t *dip = SATA_DIP(sata_hba_inst);
|
|
|
2463 sata_device_t sata_device;
|
|
|
2464 sata_drive_info_t *sdinfo;
|
|
|
2465 sata_pkt_txlate_t *spx;
|
|
|
2466 ddi_dma_attr_t cur_dma_attr;
|
|
|
2467 int rval;
|
|
|
2468 boolean_t new_pkt = TRUE;
|
|
|
2469
|
|
|
2470 ASSERT(ap->a_hba_tran->tran_hba_dip == dip);
|
|
|
2471
|
|
|
2472 /*
|
|
|
2473 * We need to translate the address, even if it could be
|
|
|
2474 * a bogus one, for a non-existing device
|
|
|
2475 */
|
|
|
2476 sata_device.satadev_addr.qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target);
|
|
|
2477 sata_device.satadev_addr.cport = SCSI_TO_SATA_CPORT(ap->a_target);
|
|
|
2478 sata_device.satadev_addr.pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
|
|
|
2479 sata_device.satadev_rev = SATA_DEVICE_REV;
|
|
|
2480
|
|
|
2481 if (pkt == NULL) {
|
|
|
2482 /*
|
|
|
2483 * Have to allocate a brand new scsi packet.
|
|
|
2484 * We need to operate with auto request sense enabled.
|
|
|
2485 */
|
|
|
2486 pkt = scsi_hba_pkt_alloc(dip, ap, cmdlen,
|
|
|
2487 MAX(statuslen, sizeof (struct scsi_arq_status)),
|
|
|
2488 tgtlen, sizeof (sata_pkt_txlate_t), callback, arg);
|
|
|
2489
|
|
|
2490 if (pkt == NULL)
|
|
|
2491 return (NULL);
|
|
|
2492
|
|
|
2493 /* Fill scsi packet structure */
|
|
|
2494 pkt->pkt_comp = (void (*)())NULL;
|
|
|
2495 pkt->pkt_time = 0;
|
|
|
2496 pkt->pkt_resid = 0;
|
|
|
2497 pkt->pkt_statistics = 0;
|
|
|
2498 pkt->pkt_reason = 0;
|
|
|
2499
|
|
|
2500 /*
|
|
|
2501 * pkt_hba_private will point to sata pkt txlate structure
|
|
|
2502 */
|
|
|
2503 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
|
|
|
2504 bzero(spx, sizeof (sata_pkt_txlate_t));
|
|
|
2505
|
|
|
2506 spx->txlt_scsi_pkt = pkt;
|
|
|
2507 spx->txlt_sata_hba_inst = sata_hba_inst;
|
|
|
2508
|
|
|
2509 /* Allocate sata_pkt */
|
|
|
2510 spx->txlt_sata_pkt = sata_pkt_alloc(spx, callback);
|
|
|
2511 if (spx->txlt_sata_pkt == NULL) {
|
|
|
2512 /* Could not allocate sata pkt */
|
|
|
2513 scsi_hba_pkt_free(ap, pkt);
|
|
|
2514 return (NULL);
|
|
|
2515 }
|
|
|
2516 /* Set sata address */
|
|
|
2517 spx->txlt_sata_pkt->satapkt_device = sata_device;
|
|
|
2518
|
|
|
2519 if ((bp == NULL) || (bp->b_bcount == 0))
|
|
|
2520 return (pkt);
|
|
|
2521
|
|
|
2522 spx->txlt_total_residue = bp->b_bcount;
|
|
|
2523 } else {
|
|
|
2524 new_pkt = FALSE;
|
|
|
2525 /*
|
|
|
2526 * Packet was preallocated/initialized by previous call
|
|
|
2527 */
|
|
|
2528 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
|
|
|
2529
|
|
|
2530 if ((bp == NULL) || (bp->b_bcount == 0)) {
|
|
|
2531 return (pkt);
|
|
|
2532 }
|
|
|
2533 ASSERT(spx->txlt_buf_dma_handle != NULL);
|
|
|
2534
|
|
|
2535 /* Pkt is available already: spx->txlt_scsi_pkt == pkt; */
|
|
|
2536 }
|
|
|
2537
|
|
|
2538 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp;
|
|
|
2539
|
|
|
2540 /*
|
|
|
2541 * We use an adjusted version of the dma_attr, to account
|
|
|
2542 * for device addressing limitations.
|
|
|
2543 * sata_adjust_dma_attr() will handle sdinfo == NULL which may
|
|
|
2544 * happen when a device is not yet configured.
|
|
|
2545 */
|
|
|
2546 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
2547 sata_device.satadev_addr.cport)));
|
|
|
2548 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
|
|
|
2549 &spx->txlt_sata_pkt->satapkt_device);
|
|
|
2550 /* NULL sdinfo may be passsed to sata_adjust_dma_attr() */
|
|
|
2551 sata_adjust_dma_attr(sdinfo,
|
|
|
2552 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr);
|
|
|
2553 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
2554 sata_device.satadev_addr.cport)));
|
|
|
2555 /*
|
|
|
2556 * Allocate necessary DMA resources for the packet's buffer
|
|
|
2557 */
|
|
|
2558 if ((rval = sata_dma_buf_setup(spx, flags, callback, arg,
|
|
|
2559 &cur_dma_attr)) != DDI_SUCCESS) {
|
|
|
2560 sata_pkt_free(spx);
|
|
|
2561 /*
|
|
|
2562 * If a DMA allocation request fails with
|
|
|
2563 * DDI_DMA_NOMAPPING, indicate the error by calling
|
|
|
2564 * bioerror(9F) with bp and an error code of EFAULT.
|
|
|
2565 * If a DMA allocation request fails with
|
|
|
2566 * DDI_DMA_TOOBIG, indicate the error by calling
|
|
|
2567 * bioerror(9F) with bp and an error code of EINVAL.
|
|
|
2568 */
|
|
|
2569 switch (rval) {
|
|
|
2570 case DDI_DMA_NORESOURCES:
|
|
|
2571 bioerror(bp, 0);
|
|
|
2572 break;
|
|
|
2573 case DDI_DMA_NOMAPPING:
|
|
|
2574 case DDI_DMA_BADATTR:
|
|
|
2575 bioerror(bp, EFAULT);
|
|
|
2576 break;
|
|
|
2577 case DDI_DMA_TOOBIG:
|
|
|
2578 default:
|
|
|
2579 bioerror(bp, EINVAL);
|
|
|
2580 break;
|
|
|
2581 }
|
|
|
2582 if (new_pkt == TRUE) {
|
|
|
2583 sata_pkt_free(spx);
|
|
|
2584 scsi_hba_pkt_free(ap, pkt);
|
|
|
2585 }
|
|
|
2586 return (NULL);
|
|
|
2587 }
|
|
|
2588 /* Set number of bytes that are not yet accounted for */
|
|
|
2589 pkt->pkt_resid = spx->txlt_total_residue;
|
|
|
2590 ASSERT(pkt->pkt_resid >= 0);
|
|
|
2591
|
|
|
2592 return (pkt);
|
|
|
2593 }
|
|
|
2594
|
|
|
2595 /*
|
|
|
2596 * Implementation of scsi tran_start.
|
|
|
2597 * Translate scsi cmd into sata operation and return status.
|
|
|
2598 * Supported scsi commands:
|
|
|
2599 * SCMD_INQUIRY
|
|
|
2600 * SCMD_TEST_UNIT_READY
|
|
|
2601 * SCMD_START_STOP
|
|
|
2602 * SCMD_READ_CAPACITY
|
|
|
2603 * SCMD_REQUEST_SENSE
|
|
|
2604 * SCMD_LOG_SENSE_G1 (unimplemented)
|
|
|
2605 * SCMD_LOG_SELECT_G1 (unimplemented)
|
|
|
2606 * SCMD_MODE_SENSE (specific pages)
|
|
|
2607 * SCMD_MODE_SENSE_G1 (specific pages)
|
|
|
2608 * SCMD_MODE_SELECT (specific pages)
|
|
|
2609 * SCMD_MODE_SELECT_G1 (specific pages)
|
|
|
2610 * SCMD_SYNCHRONIZE_CACHE
|
|
|
2611 * SCMD_SYNCHRONIZE_CACHE_G1
|
|
|
2612 * SCMD_READ
|
|
|
2613 * SCMD_READ_G1
|
|
|
2614 * SCMD_READ_G4
|
|
|
2615 * SCMD_READ_G5
|
|
|
2616 * SCMD_WRITE
|
|
|
2617 * SCMD_WRITE_G1
|
|
|
2618 * SCMD_WRITE_G4
|
|
|
2619 * SCMD_WRITE_G5
|
|
|
2620 * SCMD_SEEK (noop)
|
|
|
2621 *
|
|
|
2622 * All other commands are rejected as unsupported.
|
|
|
2623 *
|
|
|
2624 * Returns:
|
|
|
2625 * TRAN_ACCEPT if command was executed successfully or accepted by HBA driver
|
|
|
2626 * for execution.
|
|
|
2627 * TRAN_BADPKT if cmd was directed to invalid address.
|
|
|
2628 * TRAN_FATAL_ERROR is command was rejected due to hardware error, including
|
|
|
2629 * unexpected removal of a device or some other unspecified error.
|
|
|
2630 * TRAN_BUSY if command could not be executed becasue HBA driver or SATA
|
|
|
2631 * framework was busy performing some other operation(s).
|
|
|
2632 *
|
|
|
2633 */
|
|
|
2634 static int
|
|
|
2635 sata_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt)
|
|
|
2636 {
|
|
|
2637 sata_hba_inst_t *sata_hba_inst =
|
|
|
2638 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
|
|
|
2639 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
|
|
|
2640 sata_drive_info_t *sdinfo;
|
|
|
2641 struct buf *bp;
|
|
|
2642 int cport;
|
|
|
2643 int rval;
|
|
|
2644
|
|
|
2645 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
|
|
|
2646 "sata_scsi_start: cmd 0x%02x\n", pkt->pkt_cdbp[0]);
|
|
|
2647
|
|
|
2648 ASSERT(spx != NULL &&
|
|
|
2649 spx->txlt_scsi_pkt == pkt && spx->txlt_sata_pkt != NULL);
|
|
|
2650
|
|
|
2651 /*
|
|
|
2652 * Mutex-protected section below is just to identify device type
|
|
|
2653 * and switch to ATAPI processing, if necessary
|
|
|
2654 */
|
|
|
2655 cport = SCSI_TO_SATA_CPORT(ap->a_target);
|
|
|
2656
|
|
|
2657 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
|
|
|
2658
|
|
|
2659 sdinfo = sata_get_device_info(sata_hba_inst,
|
|
|
2660 &spx->txlt_sata_pkt->satapkt_device);
|
|
|
2661 if (sdinfo == NULL) {
|
|
|
2662 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
|
|
|
2663 spx->txlt_scsi_pkt->pkt_reason = CMD_DEV_GONE;
|
|
|
2664 return (TRAN_FATAL_ERROR);
|
|
|
2665 }
|
|
|
2666
|
|
|
2667 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) {
|
|
|
2668 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
|
|
|
2669 rval = sata_txlt_atapi(spx);
|
|
|
2670 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
|
|
|
2671 "sata_scsi_start atapi: rval %d\n", rval);
|
|
|
2672 return (rval);
|
|
|
2673 }
|
|
|
2674 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
|
|
|
2675
|
|
|
2676 /* ATA Disk commands processing starts here */
|
|
|
2677
|
|
|
2678 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
|
|
|
2679
|
|
|
2680 switch (pkt->pkt_cdbp[0]) {
|
|
|
2681
|
|
|
2682 case SCMD_INQUIRY:
|
|
|
2683 /* Mapped to identify device */
|
|
|
2684 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
|
|
|
2685 bp_mapin(bp);
|
|
|
2686 rval = sata_txlt_inquiry(spx);
|
|
|
2687 break;
|
|
|
2688
|
|
|
2689 case SCMD_TEST_UNIT_READY:
|
|
|
2690 /*
|
|
|
2691 * SAT "SATA to ATA Translation" doc specifies translation
|
|
|
2692 * to ATA CHECK POWER MODE.
|
|
|
2693 */
|
|
|
2694 rval = sata_txlt_test_unit_ready(spx);
|
|
|
2695 break;
|
|
|
2696
|
|
|
2697 case SCMD_START_STOP:
|
|
|
2698 /* Mapping depends on the command */
|
|
|
2699 rval = sata_txlt_start_stop_unit(spx);
|
|
|
2700 break;
|
|
|
2701
|
|
|
2702 case SCMD_READ_CAPACITY:
|
|
|
2703 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
|
|
|
2704 bp_mapin(bp);
|
|
|
2705 rval = sata_txlt_read_capacity(spx);
|
|
|
2706 break;
|
|
|
2707
|
|
|
2708 case SCMD_REQUEST_SENSE:
|
|
|
2709 /*
|
|
|
2710 * Always No Sense, since we force ARQ
|
|
|
2711 */
|
|
|
2712 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
|
|
|
2713 bp_mapin(bp);
|
|
|
2714 rval = sata_txlt_request_sense(spx);
|
|
|
2715 break;
|
|
|
2716
|
|
|
2717 case SCMD_LOG_SENSE_G1:
|
|
|
2718 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
|
|
|
2719 bp_mapin(bp);
|
|
|
2720 rval = sata_txlt_log_sense(spx);
|
|
|
2721 break;
|
|
|
2722
|
|
|
2723 case SCMD_LOG_SELECT_G1:
|
|
|
2724 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
|
|
|
2725 bp_mapin(bp);
|
|
|
2726 rval = sata_txlt_log_select(spx);
|
|
|
2727 break;
|
|
|
2728
|
|
|
2729 case SCMD_MODE_SENSE:
|
|
|
2730 case SCMD_MODE_SENSE_G1:
|
|
|
2731 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
|
|
|
2732 bp_mapin(bp);
|
|
|
2733 rval = sata_txlt_mode_sense(spx);
|
|
|
2734 break;
|
|
|
2735
|
|
|
2736
|
|
|
2737 case SCMD_MODE_SELECT:
|
|
|
2738 case SCMD_MODE_SELECT_G1:
|
|
|
2739 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
|
|
|
2740 bp_mapin(bp);
|
|
|
2741 rval = sata_txlt_mode_select(spx);
|
|
|
2742 break;
|
|
|
2743
|
|
|
2744 case SCMD_SYNCHRONIZE_CACHE:
|
|
|
2745 case SCMD_SYNCHRONIZE_CACHE_G1:
|
|
|
2746 rval = sata_txlt_synchronize_cache(spx);
|
|
|
2747 break;
|
|
|
2748
|
|
|
2749 case SCMD_READ:
|
|
|
2750 case SCMD_READ_G1:
|
|
|
2751 case SCMD_READ_G4:
|
|
|
2752 case SCMD_READ_G5:
|
|
|
2753 rval = sata_txlt_read(spx);
|
|
|
2754 break;
|
|
|
2755
|
|
|
2756 case SCMD_WRITE:
|
|
|
2757 case SCMD_WRITE_G1:
|
|
|
2758 case SCMD_WRITE_G4:
|
|
|
2759 case SCMD_WRITE_G5:
|
|
|
2760 rval = sata_txlt_write(spx);
|
|
|
2761 break;
|
|
|
2762
|
|
|
2763 case SCMD_SEEK:
|
|
|
2764 rval = sata_txlt_nodata_cmd_immediate(spx);
|
|
|
2765 break;
|
|
|
2766
|
|
|
2767
|
|
|
2768 /* Other cases will be filed later */
|
|
|
2769 /* postponed until phase 2 of the development */
|
|
|
2770 default:
|
|
|
2771 rval = sata_txlt_invalid_command(spx);
|
|
|
2772 break;
|
|
|
2773 }
|
|
|
2774
|
|
|
2775 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
|
|
|
2776 "sata_scsi_start: rval %d\n", rval);
|
|
|
2777
|
|
|
2778 return (rval);
|
|
|
2779 }
|
|
|
2780
|
|
|
2781 /*
|
|
|
2782 * Implementation of scsi tran_abort.
|
|
|
2783 * Abort specific pkt or all packets.
|
|
|
2784 *
|
|
|
2785 * Returns 1 if one or more packets were aborted, returns 0 otherwise
|
|
|
2786 *
|
|
|
2787 * May be called from an interrupt level.
|
|
|
2788 */
|
|
|
2789 static int
|
|
|
2790 sata_scsi_abort(struct scsi_address *ap, struct scsi_pkt *scsi_pkt)
|
|
|
2791 {
|
|
|
2792 sata_hba_inst_t *sata_hba_inst =
|
|
|
2793 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
|
|
|
2794 sata_device_t sata_device;
|
|
|
2795 sata_pkt_t *sata_pkt;
|
|
|
2796
|
|
|
2797 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
|
|
|
2798 "sata_scsi_abort: %s at target: 0x%x\n",
|
|
|
2799 scsi_pkt == NULL ? "all packets" : "one pkt", ap->a_target);
|
|
|
2800
|
|
|
2801 /* Validate address */
|
|
|
2802 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0)
|
|
|
2803 /* Invalid address */
|
|
|
2804 return (0);
|
|
|
2805
|
|
|
2806 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
2807 sata_device.satadev_addr.cport)));
|
|
|
2808 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) {
|
|
|
2809 /* invalid address */
|
|
|
2810 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
2811 sata_device.satadev_addr.cport)));
|
|
|
2812 return (0);
|
|
|
2813 }
|
|
|
2814 if (scsi_pkt == NULL) {
|
|
|
2815 /*
|
|
|
2816 * Abort all packets.
|
|
|
2817 * Although we do not have specific packet, we still need
|
|
|
2818 * dummy packet structure to pass device address to HBA.
|
|
|
2819 * Allocate one, without sleeping. Fail if pkt cannot be
|
|
|
2820 * allocated.
|
|
|
2821 */
|
|
|
2822 sata_pkt = kmem_zalloc(sizeof (sata_pkt_t), KM_NOSLEEP);
|
|
|
2823 if (sata_pkt == NULL) {
|
|
|
2824 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
2825 sata_device.satadev_addr.cport)));
|
|
|
2826 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_pkt_abort: "
|
|
|
2827 "could not allocate sata_pkt"));
|
|
|
2828 return (0);
|
|
|
2829 }
|
|
|
2830 sata_pkt->satapkt_rev = SATA_PKT_REV;
|
|
|
2831 sata_pkt->satapkt_device = sata_device;
|
|
|
2832 sata_pkt->satapkt_device.satadev_rev = SATA_DEVICE_REV;
|
|
|
2833 } else {
|
|
|
2834 if (scsi_pkt->pkt_ha_private == NULL) {
|
|
|
2835 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
2836 sata_device.satadev_addr.cport)));
|
|
|
2837 return (0); /* Bad scsi pkt */
|
|
|
2838 }
|
|
|
2839 /* extract pointer to sata pkt */
|
|
|
2840 sata_pkt = ((sata_pkt_txlate_t *)scsi_pkt->pkt_ha_private)->
|
|
|
2841 txlt_sata_pkt;
|
|
|
2842 }
|
|
|
2843
|
|
|
2844 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
2845 sata_device.satadev_addr.cport)));
|
|
|
2846 /* Send abort request to HBA */
|
|
|
2847 if ((*SATA_ABORT_FUNC(sata_hba_inst))
|
|
|
2848 (SATA_DIP(sata_hba_inst), sata_pkt,
|
|
|
2849 scsi_pkt == NULL ? SATA_ABORT_ALL_PACKETS : SATA_ABORT_PACKET) ==
|
|
|
2850 SATA_SUCCESS) {
|
|
|
2851 if (scsi_pkt == NULL)
|
|
|
2852 kmem_free(sata_pkt, sizeof (sata_pkt_t));
|
|
|
2853 /* Success */
|
|
|
2854 return (1);
|
|
|
2855 }
|
|
|
2856 /* Else, something did not go right */
|
|
|
2857 if (scsi_pkt == NULL)
|
|
|
2858 kmem_free(sata_pkt, sizeof (sata_pkt_t));
|
|
|
2859 /* Failure */
|
|
|
2860 return (0);
|
|
|
2861 }
|
|
|
2862
|
|
|
2863
|
|
|
2864 /*
|
|
|
2865 * Implementation os scsi tran_reset.
|
|
|
2866 * RESET_ALL request is translated into port reset.
|
|
|
2867 * RESET_TARGET requests is translated into a device reset,
|
|
|
2868 * RESET_LUN request is accepted only for LUN 0 and translated into
|
|
|
2869 * device reset.
|
|
|
2870 * The target reset should cause all HBA active and queued packets to
|
|
|
2871 * be terminated and returned with pkt reason SATA_PKT_RESET prior to
|
|
|
2872 * the return. HBA should report reset event for the device.
|
|
|
2873 *
|
|
|
2874 * Returns 1 upon success, 0 upon failure.
|
|
|
2875 */
|
|
|
2876 static int
|
|
|
2877 sata_scsi_reset(struct scsi_address *ap, int level)
|
|
|
2878 {
|
|
|
2879 sata_hba_inst_t *sata_hba_inst =
|
|
|
2880 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
|
|
|
2881 sata_device_t sata_device;
|
|
|
2882 int val;
|
|
|
2883
|
|
|
2884 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
|
|
|
2885 "sata_scsi_reset: level %d target: 0x%x\n",
|
|
|
2886 level, ap->a_target);
|
|
|
2887
|
|
|
2888 /* Validate address */
|
|
|
2889 val = sata_validate_scsi_address(sata_hba_inst, ap, &sata_device);
|
|
|
2890 if (val == -1)
|
|
|
2891 /* Invalid address */
|
|
|
2892 return (0);
|
|
|
2893
|
|
|
2894 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
2895 sata_device.satadev_addr.cport)));
|
|
|
2896 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) {
|
|
|
2897 /* invalid address */
|
|
|
2898 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
2899 sata_device.satadev_addr.cport)));
|
|
|
2900 return (0);
|
|
|
2901 }
|
|
|
2902 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
2903 sata_device.satadev_addr.cport)));
|
|
|
2904 if (level == RESET_ALL) {
|
|
|
2905 /* port reset - cport only */
|
|
|
2906 sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
|
|
|
2907 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
|
|
|
2908 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS)
|
|
|
2909 return (1);
|
|
|
2910 else
|
|
|
2911 return (0);
|
|
|
2912
|
|
|
2913 } else if (val == 0 &&
|
|
|
2914 (level == RESET_TARGET || level == RESET_LUN)) {
|
|
|
2915 /* reset device (device attached) */
|
|
|
2916 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
|
|
|
2917 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS)
|
|
|
2918 return (1);
|
|
|
2919 else
|
|
|
2920 return (0);
|
|
|
2921 }
|
|
|
2922 return (0);
|
|
|
2923 }
|
|
|
2924
|
|
|
2925
|
|
|
2926 /*
|
|
|
2927 * Implementation of scsi tran_getcap (get transport/device capabilities).
|
|
|
2928 * Supported capabilities:
|
|
|
2929 * auto-rqsense (always supported)
|
|
|
2930 * tagged-qing (supported if HBA supports it)
|
|
|
2931 * dma_max
|
|
|
2932 * interconnect-type (INTERCONNECT_SATA)
|
|
|
2933 *
|
|
|
2934 * Request for other capabilities is rejected as unsupported.
|
|
|
2935 *
|
|
|
2936 * Returns supported capability value, or -1 if capability is unsuppported or
|
|
|
2937 * the address is invalid (no device).
|
|
|
2938 */
|
|
|
2939
|
|
|
2940 static int
|
|
|
2941 sata_scsi_getcap(struct scsi_address *ap, char *cap, int whom)
|
|
|
2942 {
|
|
|
2943
|
|
|
2944 sata_hba_inst_t *sata_hba_inst =
|
|
|
2945 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
|
|
|
2946 sata_device_t sata_device;
|
|
|
2947 sata_drive_info_t *sdinfo;
|
|
|
2948 ddi_dma_attr_t adj_dma_attr;
|
|
|
2949 int rval;
|
|
|
2950
|
|
|
2951 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
|
|
|
2952 "sata_scsi_getcap: target: 0x%x, cap: %s\n",
|
|
|
2953 ap->a_target, cap);
|
|
|
2954
|
|
|
2955 /*
|
|
|
2956 * We want to process the capabilities on per port granularity.
|
|
|
2957 * So, we are specifically restricting ourselves to whom != 0
|
|
|
2958 * to exclude the controller wide handling.
|
|
|
2959 */
|
|
|
2960 if (cap == NULL || whom == 0)
|
|
|
2961 return (-1);
|
|
|
2962
|
|
|
2963 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) {
|
|
|
2964 /* Invalid address */
|
|
|
2965 return (-1);
|
|
|
2966 }
|
|
|
2967 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
2968 sata_device.satadev_addr.cport)));
|
|
|
2969 if ((sdinfo = sata_get_device_info(sata_hba_inst, &sata_device)) ==
|
|
|
2970 NULL) {
|
|
|
2971 /* invalid address */
|
|
|
2972 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
2973 sata_device.satadev_addr.cport)));
|
|
|
2974 return (0);
|
|
|
2975 }
|
|
|
2976
|
|
|
2977 switch (scsi_hba_lookup_capstr(cap)) {
|
|
|
2978 case SCSI_CAP_ARQ:
|
|
|
2979 rval = 1; /* ARQ supported, turned on */
|
|
|
2980 break;
|
|
|
2981
|
|
|
2982 case SCSI_CAP_SECTOR_SIZE:
|
|
|
2983 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK)
|
|
|
2984 rval = SATA_DISK_SECTOR_SIZE; /* fixed size */
|
|
|
2985 else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD)
|
|
|
2986 rval = SATA_ATAPI_SECTOR_SIZE;
|
|
|
2987 else rval = -1;
|
|
|
2988 break;
|
|
|
2989
|
|
|
2990 case SCSI_CAP_TAGGED_QING:
|
|
|
2991 /*
|
|
|
2992 * It is enough if the controller supports queuing, regardless
|
|
|
2993 * of the device. NCQ support is an internal implementation
|
|
|
2994 * feature used between HBA and the device.
|
|
|
2995 */
|
|
|
2996 if (SATA_QDEPTH(sata_hba_inst) > 1)
|
|
|
2997 rval = 1; /* Queuing supported */
|
|
|
2998 else
|
|
|
2999 rval = -1; /* Queuing not supported */
|
|
|
3000 break;
|
|
|
3001
|
|
|
3002 case SCSI_CAP_DMA_MAX:
|
|
|
3003 sata_adjust_dma_attr(sdinfo, SATA_DMA_ATTR(sata_hba_inst),
|
|
|
3004 &adj_dma_attr);
|
|
|
3005 rval = (int)adj_dma_attr.dma_attr_maxxfer;
|
|
|
3006 /* We rely on the fact that dma_attr_maxxfer < 0x80000000 */
|
|
|
3007 break;
|
|
|
3008
|
|
|
3009 case SCSI_CAP_INTERCONNECT_TYPE:
|
|
|
3010 rval = INTERCONNECT_SATA; /* SATA interconnect type */
|
|
|
3011 break;
|
|
|
3012
|
|
|
3013 default:
|
|
|
3014 rval = -1;
|
|
|
3015 break;
|
|
|
3016 }
|
|
|
3017 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
3018 sata_device.satadev_addr.cport)));
|
|
|
3019 return (rval);
|
|
|
3020 }
|
|
|
3021
|
|
|
3022 /*
|
|
|
3023 * Implementation of scsi tran_setcap
|
|
|
3024 *
|
|
|
3025 * All supported capabilities are fixed/unchangeable.
|
|
|
3026 * Returns 0 for all supported capabilities and valid device, -1 otherwise.
|
|
|
3027 */
|
|
|
3028 static int
|
|
|
3029 sata_scsi_setcap(struct scsi_address *ap, char *cap, int value, int whom)
|
|
|
3030 {
|
|
|
3031 #ifndef __lock_lint
|
|
|
3032 _NOTE(ARGUNUSED(value))
|
|
|
3033 #endif
|
|
|
3034 sata_hba_inst_t *sata_hba_inst =
|
|
|
3035 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
|
|
|
3036 sata_device_t sata_device;
|
|
|
3037 int rval;
|
|
|
3038
|
|
|
3039 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
|
|
|
3040 "sata_scsi_setcap: target: 0x%x, cap: %s\n", ap->a_target, cap);
|
|
|
3041
|
|
|
3042 /*
|
|
|
3043 * We want to process the capabilities on per port granularity.
|
|
|
3044 * So, we are specifically restricting ourselves to whom != 0
|
|
|
3045 * to exclude the controller wide handling.
|
|
|
3046 */
|
|
|
3047 if (cap == NULL || whom == 0) {
|
|
|
3048 return (-1);
|
|
|
3049 }
|
|
|
3050
|
|
|
3051 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) {
|
|
|
3052 /* Invalid address */
|
|
|
3053 return (-1);
|
|
|
3054 }
|
|
|
3055 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
3056 sata_device.satadev_addr.cport)));
|
|
|
3057 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) {
|
|
|
3058 /* invalid address */
|
|
|
3059 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
3060 sata_device.satadev_addr.cport)));
|
|
|
3061 return (0);
|
|
|
3062 }
|
|
|
3063 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
3064 sata_device.satadev_addr.cport)));
|
|
|
3065
|
|
|
3066 switch (scsi_hba_lookup_capstr(cap)) {
|
|
|
3067 case SCSI_CAP_ARQ:
|
|
|
3068 case SCSI_CAP_SECTOR_SIZE:
|
|
|
3069 case SCSI_CAP_TAGGED_QING:
|
|
|
3070 case SCSI_CAP_DMA_MAX:
|
|
|
3071 case SCSI_CAP_INTERCONNECT_TYPE:
|
|
|
3072 rval = 0; /* Capability cannot be changed */
|
|
|
3073 break;
|
|
|
3074
|
|
|
3075 default:
|
|
|
3076 rval = -1;
|
|
|
3077 break;
|
|
|
3078 }
|
|
|
3079 return (rval);
|
|
|
3080 }
|
|
|
3081
|
|
|
3082 /*
|
|
|
3083 * Implementations of scsi tran_destroy_pkt.
|
|
|
3084 * Free resources allocated by sata_scsi_init_pkt()
|
|
|
3085 */
|
|
|
3086 static void
|
|
|
3087 sata_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
|
|
|
3088 {
|
|
|
3089 sata_pkt_txlate_t *spx;
|
|
|
3090
|
|
|
3091 ASSERT(pkt != NULL);
|
|
|
3092 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
|
|
|
3093
|
|
|
3094 if (spx->txlt_buf_dma_handle != NULL) {
|
|
|
3095 /*
|
|
|
3096 * Free DMA resources - cookies and handles
|
|
|
3097 */
|
|
|
3098 ASSERT(spx->txlt_dma_cookie_list != NULL);
|
|
|
3099 (void) kmem_free(spx->txlt_dma_cookie_list,
|
|
|
3100 spx->txlt_dma_cookie_list_len * sizeof (ddi_dma_cookie_t));
|
|
|
3101 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle);
|
|
|
3102 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
|
|
|
3103 }
|
|
|
3104 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
|
|
|
3105 sata_pkt_free(spx);
|
|
|
3106
|
|
|
3107 scsi_hba_pkt_free(ap, pkt);
|
|
|
3108 }
|
|
|
3109
|
|
|
3110 /*
|
|
|
3111 * Implementation of scsi tran_dmafree.
|
|
|
3112 * Free DMA resources allocated by sata_scsi_init_pkt()
|
|
|
3113 */
|
|
|
3114
|
|
|
3115 static void
|
|
|
3116 sata_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt)
|
|
|
3117 {
|
|
|
3118 #ifndef __lock_lint
|
|
|
3119 _NOTE(ARGUNUSED(ap))
|
|
|
3120 #endif
|
|
|
3121 sata_pkt_txlate_t *spx;
|
|
|
3122
|
|
|
3123 ASSERT(pkt != NULL);
|
|
|
3124 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
|
|
|
3125
|
|
|
3126 if (spx->txlt_buf_dma_handle != NULL) {
|
|
|
3127 /*
|
|
|
3128 * Free DMA resources - cookies and handles
|
|
|
3129 */
|
|
|
3130 ASSERT(spx->txlt_dma_cookie_list != NULL);
|
|
|
3131 (void) kmem_free(spx->txlt_dma_cookie_list,
|
|
|
3132 spx->txlt_dma_cookie_list_len * sizeof (ddi_dma_cookie_t));
|
|
|
3133 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle);
|
|
|
3134 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
|
|
|
3135 }
|
|
|
3136 }
|
|
|
3137
|
|
|
3138 /*
|
|
|
3139 * Implementation of scsi tran_sync_pkt.
|
|
|
3140 *
|
|
|
3141 * The assumption below is that pkt is unique - there is no need to check ap
|
|
|
3142 */
|
|
|
3143 static void
|
|
|
3144 sata_scsi_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
|
|
|
3145 {
|
|
|
3146 #ifndef __lock_lint
|
|
|
3147 _NOTE(ARGUNUSED(ap))
|
|
|
3148 #endif
|
|
|
3149 int rval;
|
|
|
3150 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
|
|
|
3151
|
|
|
3152 if (spx->txlt_buf_dma_handle != NULL) {
|
|
|
3153 if (spx->txlt_sata_pkt != NULL &&
|
|
|
3154 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags !=
|
|
|
3155 SATA_DIR_NODATA_XFER) {
|
|
|
3156 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
|
|
|
3157 (spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags &
|
|
|
3158 SATA_DIR_WRITE) ?
|
|
|
3159 DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU);
|
|
|
3160 if (rval == DDI_SUCCESS) {
|
|
|
3161 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
|
|
|
3162 "sata_scsi_sync_pkt: sync pkt failed"));
|
|
|
3163 }
|
|
|
3164 }
|
|
|
3165 }
|
|
|
3166 }
|
|
|
3167
|
|
|
3168
|
|
|
3169
|
|
|
3170 /* ******************* SATA - SCSI Translation functions **************** */
|
|
|
3171 /*
|
|
|
3172 * SCSI to SATA pkt and command translation and SATA to SCSI status/error
|
|
|
3173 * translation.
|
|
|
3174 */
|
|
|
3175
|
|
|
3176 /*
|
|
|
3177 * Checks if a device exists and can be access and translates common
|
|
|
3178 * scsi_pkt data to sata_pkt data.
|
|
|
3179 *
|
|
|
3180 * Returns TRAN_ACCEPT if device exists and sata_pkt was set-up.
|
|
|
3181 * Returns other TRAN_XXXXX values when error occured.
|
|
|
3182 *
|
|
|
3183 * This function should be called with port mutex held.
|
|
|
3184 */
|
|
|
3185 static int
|
|
|
3186 sata_txlt_generic_pkt_info(sata_pkt_txlate_t *spx)
|
|
|
3187 {
|
|
|
3188 sata_drive_info_t *sdinfo;
|
|
|
3189 sata_device_t sata_device;
|
|
|
3190
|
|
|
3191 /* Validate address */
|
|
|
3192 switch (sata_validate_scsi_address(spx->txlt_sata_hba_inst,
|
|
|
3193 &spx->txlt_scsi_pkt->pkt_address, &sata_device)) {
|
|
|
3194
|
|
|
3195 case -1:
|
|
|
3196 /* Invalid address or invalid device type */
|
|
|
3197 return (TRAN_BADPKT);
|
|
|
3198 case 1:
|
|
|
3199 /* valid address but no device - it has disappeared ? */
|
|
|
3200 spx->txlt_scsi_pkt->pkt_reason = CMD_DEV_GONE;
|
|
|
3201 return (TRAN_FATAL_ERROR);
|
|
|
3202 default:
|
|
|
3203 /* all OK */
|
|
|
3204 break;
|
|
|
3205 }
|
|
|
3206 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
|
|
|
3207 &spx->txlt_sata_pkt->satapkt_device);
|
|
|
3208
|
|
|
3209 /*
|
|
|
3210 * If device is in reset condition, reject the packet with
|
|
|
3211 * TRAN_BUSY
|
|
|
3212 */
|
|
|
3213 if (sdinfo->satadrv_event_flags &
|
|
|
3214 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
|
|
|
3215 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
|
|
|
3216 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
3217 "sata_scsi_start: rejecting command because "
|
|
|
3218 "of device reset state\n", NULL);
|
|
|
3219 return (TRAN_BUSY);
|
|
|
3220 }
|
|
|
3221
|
|
|
3222 /*
|
|
|
3223 * Fix the dev_type in the sata_pkt->satapkt_device. It was not set by
|
|
|
3224 * sata_scsi_pkt_init() because pkt init had to work also with
|
|
|
3225 * non-existing devices.
|
|
|
3226 * Now we know that the packet was set-up for a real device, so its
|
|
|
3227 * type is known.
|
|
|
3228 */
|
|
|
3229 spx->txlt_sata_pkt->satapkt_device.satadev_type = sdinfo->satadrv_type;
|
|
|
3230
|
|
|
3231 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags = SATA_DIR_NODATA_XFER;
|
|
|
3232
|
|
|
3233 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT;
|
|
|
3234
|
|
|
3235 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0) {
|
|
|
3236 /* Synchronous execution */
|
|
|
3237 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH |
|
|
|
3238 SATA_OPMODE_POLLING;
|
|
|
3239 } else {
|
|
|
3240 /* Asynchronous execution */
|
|
|
3241 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_ASYNCH |
|
|
|
3242 SATA_OPMODE_INTERRUPTS;
|
|
|
3243 }
|
|
|
3244 /* Convert queuing information */
|
|
|
3245 if (spx->txlt_scsi_pkt->pkt_flags & FLAG_STAG)
|
|
|
3246 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags |=
|
|
|
3247 SATA_QUEUE_STAG_CMD;
|
|
|
3248 else if (spx->txlt_scsi_pkt->pkt_flags &
|
|
|
3249 (FLAG_OTAG | FLAG_HTAG | FLAG_HEAD))
|
|
|
3250 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags |=
|
|
|
3251 SATA_QUEUE_OTAG_CMD;
|
|
|
3252
|
|
|
3253 /* Always limit pkt time */
|
|
|
3254 if (spx->txlt_scsi_pkt->pkt_time == 0)
|
|
|
3255 spx->txlt_sata_pkt->satapkt_time = sata_default_pkt_time;
|
|
|
3256 else
|
|
|
3257 /* Pass on scsi_pkt time */
|
|
|
3258 spx->txlt_sata_pkt->satapkt_time =
|
|
|
3259 spx->txlt_scsi_pkt->pkt_time;
|
|
|
3260
|
|
|
3261 return (TRAN_ACCEPT);
|
|
|
3262 }
|
|
|
3263
|
|
|
3264
|
|
|
3265 /*
|
|
|
3266 * Translate ATA(ATAPI) Identify (Packet) Device data to SCSI Inquiry data.
|
|
|
3267 * SATA Identify Device data has to be valid in sata_rive_info.
|
|
|
3268 * Buffer has to accomodate the inquiry length (36 bytes).
|
|
|
3269 *
|
|
|
3270 * This function should be called with a port mutex held.
|
|
|
3271 */
|
|
|
3272 static void
|
|
|
3273 sata_identdev_to_inquiry(sata_hba_inst_t *sata_hba_inst,
|
|
|
3274 sata_drive_info_t *sdinfo, uint8_t *buf)
|
|
|
3275 {
|
|
|
3276
|
|
|
3277 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf;
|
|
|
3278 struct sata_id *sid = &sdinfo->satadrv_id;
|
|
|
3279
|
|
|
3280 /* Rely on the dev_type for setting paripheral qualifier */
|
|
|
3281 /* Does DTYPE_RODIRECT apply to CD/DVD R/W devices ? */
|
|
|
3282 inq->inq_dtype = sdinfo->satadrv_type == SATA_DTYPE_ATADISK ?
|
|
|
3283 DTYPE_DIRECT : DTYPE_RODIRECT;
|
|
|
3284
|
|
|
3285 inq->inq_rmb = sid->ai_config & SATA_REM_MEDIA ? 1 : 0;
|
|
|
3286 inq->inq_qual = 0; /* Device type qualifier (obsolete in SCSI3? */
|
|
|
3287 inq->inq_iso = 0; /* ISO version */
|
|
|
3288 inq->inq_ecma = 0; /* ECMA version */
|
|
|
3289 inq->inq_ansi = 3; /* ANSI version - SCSI 3 */
|
|
|
3290 inq->inq_aenc = 0; /* Async event notification cap. */
|
|
|
3291 inq->inq_trmiop = 0; /* Supports TERMINATE I/O PROC msg ??? */
|
|
|
3292 inq->inq_normaca = 0; /* setting NACA bit supported - NO */
|
|
|
3293 inq->inq_rdf = RDF_SCSI2; /* Response data format- SPC-3 */
|
|
|
3294 inq->inq_len = 31; /* Additional length */
|
|
|
3295 inq->inq_dualp = 0; /* dual port device - NO */
|
|
|
3296 inq->inq_reladdr = 0; /* Supports relative addressing - NO */
|
|
|
3297 inq->inq_sync = 0; /* Supports synchronous data xfers - NO */
|
|
|
3298 inq->inq_linked = 0; /* Supports linked commands - NO */
|
|
|
3299 /*
|
|
|
3300 * Queuing support - controller has to
|
|
|
3301 * support some sort of command queuing.
|
|
|
3302 */
|
|
|
3303 if (SATA_QDEPTH(sata_hba_inst) > 1)
|
|
|
3304 inq->inq_cmdque = 1; /* Supports command queueing - YES */
|
|
|
3305 else
|
|
|
3306 inq->inq_cmdque = 0; /* Supports command queueing - NO */
|
|
|
3307 inq->inq_sftre = 0; /* Supports Soft Reset option - NO ??? */
|
|
|
3308 inq->inq_wbus32 = 0; /* Supports 32 bit wide data xfers - NO */
|
|
|
3309 inq->inq_wbus16 = 0; /* Supports 16 bit wide data xfers - NO */
|
|
|
3310
|
|
|
3311 #ifdef _LITTLE_ENDIAN
|
|
|
3312 /* Swap text fields to match SCSI format */
|
|
|
3313 swab(sid->ai_model, inq->inq_vid, 8); /* Vendor ID */
|
|
|
3314 swab(&sid->ai_model[8], inq->inq_pid, 16); /* Product ID */
|
|
|
3315 swab(sid->ai_fw, inq->inq_revision, 8); /* Revision level */
|
|
|
3316 #else
|
|
|
3317 bcopy(sid->ai_model, inq->inq_vid, 8); /* Vendor ID */
|
|
|
3318 bcopy(&sid->ai_model[8], inq->inq_pid, 16); /* Product ID */
|
|
|
3319 bcopy(sid->ai_fw, inq->inq_revision, 8); /* Revision level */
|
|
|
3320 #endif
|
|
|
3321 }
|
|
|
3322
|
|
|
3323
|
|
|
3324 /*
|
|
|
3325 * Scsi response set up for invalid command (command not supported)
|
|
|
3326 *
|
|
|
3327 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
|
|
|
3328 */
|
|
|
3329 static int
|
|
|
3330 sata_txlt_invalid_command(sata_pkt_txlate_t *spx)
|
|
|
3331 {
|
|
|
3332 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
|
|
|
3333 struct scsi_extended_sense *sense;
|
|
|
3334
|
|
|
3335 scsipkt->pkt_reason = CMD_CMPLT;
|
|
|
3336 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
|
|
|
3337 STATE_SENT_CMD | STATE_GOT_STATUS;
|
|
|
3338
|
|
|
3339 *scsipkt->pkt_scbp = STATUS_CHECK;
|
|
|
3340
|
|
|
3341 sense = sata_arq_sense(spx);
|
|
|
3342 sense->es_key = KEY_ILLEGAL_REQUEST;
|
|
|
3343 sense->es_add_code = SD_SCSI_INVALID_COMMAND_CODE;
|
|
|
3344
|
|
|
3345 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
3346 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
|
|
|
3347
|
|
|
3348 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
|
|
|
3349 scsipkt->pkt_comp != NULL)
|
|
|
3350 /* scsi callback required */
|
|
|
3351 (*scsipkt->pkt_comp)(scsipkt);
|
|
|
3352 return (TRAN_ACCEPT);
|
|
|
3353 }
|
|
|
3354
|
|
|
3355 /*
|
|
|
3356 * Scsi response setup for
|
|
|
3357 * emulated non-data command that requires no action/return data
|
|
|
3358 *
|
|
|
3359 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
|
|
|
3360 */
|
|
|
3361 static int
|
|
|
3362 sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *spx)
|
|
|
3363 {
|
|
|
3364 int rval;
|
|
|
3365
|
|
|
3366 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
3367
|
|
|
3368 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) {
|
|
|
3369 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
3370 return (rval);
|
|
|
3371 }
|
|
|
3372 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
3373
|
|
|
3374 spx->txlt_scsi_pkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
|
|
|
3375 STATE_SENT_CMD | STATE_GOT_STATUS;
|
|
|
3376 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT;
|
|
|
3377 *(spx->txlt_scsi_pkt->pkt_scbp) = STATUS_GOOD;
|
|
|
3378
|
|
|
3379 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
3380 "Scsi_pkt completion reason %x\n",
|
|
|
3381 spx->txlt_scsi_pkt->pkt_reason);
|
|
|
3382
|
|
|
3383 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) == 0 &&
|
|
|
3384 spx->txlt_scsi_pkt->pkt_comp != NULL)
|
|
|
3385 /* scsi callback required */
|
|
|
3386 (*spx->txlt_scsi_pkt->pkt_comp)(spx->txlt_scsi_pkt);
|
|
|
3387 return (TRAN_ACCEPT);
|
|
|
3388 }
|
|
|
3389
|
|
|
3390
|
|
|
3391 /*
|
|
|
3392 * SATA translate command: Inquiry / Identify Device
|
|
|
3393 * Use cached Identify Device data for now, rather then issuing actual
|
|
|
3394 * Device Identify cmd request. If device is detached and re-attached,
|
|
|
3395 * asynchromous event processing should fetch and refresh Identify Device
|
|
|
3396 * data.
|
|
|
3397 * Two VPD pages are supported now:
|
|
|
3398 * Vital Product Data page
|
|
|
3399 * Unit Serial Number page
|
|
|
3400 *
|
|
|
3401 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
|
|
|
3402 */
|
|
|
3403
|
|
|
3404 #define EVPD 1 /* Extended Vital Product Data flag */
|
|
|
3405 #define CMDDT 2 /* Command Support Data - Obsolete */
|
|
|
3406 #define INQUIRY_SUP_VPD_PAGE 0 /* Supported VDP Pages Page COde */
|
|
|
3407 #define INQUIRY_USN_PAGE 0x80 /* Unit Serial Number Page Code */
|
|
|
3408 #define INQUIRY_DEV_IDENTIFICATION_PAGE 0x83 /* Not needed yet */
|
|
|
3409
|
|
|
3410 static int
|
|
|
3411 sata_txlt_inquiry(sata_pkt_txlate_t *spx)
|
|
|
3412 {
|
|
|
3413 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
|
|
|
3414 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
|
|
|
3415 sata_drive_info_t *sdinfo;
|
|
|
3416 struct scsi_extended_sense *sense;
|
|
|
3417 int count;
|
|
|
3418 uint8_t *p;
|
|
|
3419 int i, j;
|
|
|
3420 uint8_t page_buf[0xff]; /* Max length */
|
|
|
3421 int rval;
|
|
|
3422
|
|
|
3423 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
3424
|
|
|
3425 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) {
|
|
|
3426 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
3427 return (rval);
|
|
|
3428 }
|
|
|
3429
|
|
|
3430 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
|
|
|
3431 &spx->txlt_sata_pkt->satapkt_device);
|
|
|
3432
|
|
|
3433 ASSERT(sdinfo != NULL);
|
|
|
3434
|
|
|
3435 scsipkt->pkt_reason = CMD_CMPLT;
|
|
|
3436 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
|
|
|
3437 STATE_SENT_CMD | STATE_GOT_STATUS;
|
|
|
3438
|
|
|
3439 /* Reject not supported request */
|
|
|
3440 if (scsipkt->pkt_cdbp[1] & CMDDT) { /* No support for this bit */
|
|
|
3441 *scsipkt->pkt_scbp = STATUS_CHECK;
|
|
|
3442 sense = sata_arq_sense(spx);
|
|
|
3443 sense->es_key = KEY_ILLEGAL_REQUEST;
|
|
|
3444 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB;
|
|
|
3445 goto done;
|
|
|
3446 }
|
|
|
3447
|
|
|
3448 /* Valid Inquiry request */
|
|
|
3449 *scsipkt->pkt_scbp = STATUS_GOOD;
|
|
|
3450
|
|
|
3451 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
|
|
|
3452
|
|
|
3453 if (!(scsipkt->pkt_cdbp[1] & EVPD)) {
|
|
|
3454 /* Standard Inquiry Data request */
|
|
|
3455 struct scsi_inquiry inq;
|
|
|
3456
|
|
|
3457 bzero(&inq, sizeof (struct scsi_inquiry));
|
|
|
3458 sata_identdev_to_inquiry(spx->txlt_sata_hba_inst,
|
|
|
3459 sdinfo, (uint8_t *)&inq);
|
|
|
3460 /* Copy no more than requested */
|
|
|
3461 count = MIN(bp->b_bcount,
|
|
|
3462 sizeof (struct scsi_inquiry));
|
|
|
3463 count = MIN(count, scsipkt->pkt_cdbp[4]);
|
|
|
3464 bcopy(&inq, bp->b_un.b_addr, count);
|
|
|
3465
|
|
|
3466 scsipkt->pkt_state |= STATE_XFERRED_DATA;
|
|
|
3467 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ?
|
|
|
3468 scsipkt->pkt_cdbp[4] - count : 0;
|
|
|
3469 } else {
|
|
|
3470 /*
|
|
|
3471 * peripheral_qualifier = 0;
|
|
|
3472 *
|
|
|
3473 * We are dealing only with HD and will be
|
|
|
3474 * dealing with CD/DVD devices soon
|
|
|
3475 */
|
|
|
3476 uint8_t peripheral_device_type =
|
|
|
3477 sdinfo->satadrv_type == SATA_DTYPE_ATADISK ?
|
|
|
3478 DTYPE_DIRECT : DTYPE_RODIRECT;
|
|
|
3479
|
|
|
3480 switch ((uint_t)scsipkt->pkt_cdbp[2]) {
|
|
|
3481 case INQUIRY_SUP_VPD_PAGE:
|
|
|
3482 /*
|
|
|
3483 * Request for suported Vital Product Data
|
|
|
3484 * pages - assuming only 2 page codes
|
|
|
3485 * supported
|
|
|
3486 */
|
|
|
3487 page_buf[0] = peripheral_device_type;
|
|
|
3488 page_buf[1] = INQUIRY_SUP_VPD_PAGE;
|
|
|
3489 page_buf[2] = 0;
|
|
|
3490 page_buf[3] = 2; /* page length */
|
|
|
3491 page_buf[4] = INQUIRY_SUP_VPD_PAGE;
|
|
|
3492 page_buf[5] = INQUIRY_USN_PAGE;
|
|
|
3493 /* Copy no more than requested */
|
|
|
3494 count = MIN(bp->b_bcount, 6);
|
|
|
3495 bcopy(page_buf, bp->b_un.b_addr, count);
|
|
|
3496 break;
|
|
|
3497 case INQUIRY_USN_PAGE:
|
|
|
3498 /*
|
|
|
3499 * Request for Unit Serial Number page
|
|
|
3500 */
|
|
|
3501 page_buf[0] = peripheral_device_type;
|
|
|
3502 page_buf[1] = INQUIRY_USN_PAGE;
|
|
|
3503 page_buf[2] = 0;
|
|
|
3504 page_buf[3] = 20; /* remaining page length */
|
|
|
3505 p = (uint8_t *)(sdinfo->satadrv_id.ai_drvser);
|
|
|
3506 #ifdef _LITTLE_ENDIAN
|
|
|
3507 swab(p, &page_buf[4], 20);
|
|
|
3508 #else
|
|
|
3509 bcopy(p, &page_buf[4], 20);
|
|
|
3510 #endif
|
|
|
3511 for (i = 0; i < 20; i++) {
|
|
|
3512 if (page_buf[4 + i] == '\0' ||
|
|
|
3513 page_buf[4 + i] == '\040') {
|
|
|
3514 break;
|
|
|
3515 }
|
|
|
3516 }
|
|
|
3517 /*
|
|
|
3518 * 'i' contains string length.
|
|
|
3519 *
|
|
|
3520 * Least significant character of the serial
|
|
|
3521 * number shall appear as the last byte,
|
|
|
3522 * according to SBC-3 spec.
|
|
|
3523 */
|
|
|
3524 p = &page_buf[20 + 4 - 1];
|
|
|
3525 for (j = i; j > 0; j--, p--) {
|
|
|
3526 *p = *(p - 20 + i);
|
|
|
3527 }
|
|
|
3528 p = &page_buf[4];
|
|
|
3529 for (j = 20 - i; j > 0; j--) {
|
|
|
3530 *p++ = '\040';
|
|
|
3531 }
|
|
|
3532 count = MIN(bp->b_bcount, 24);
|
|
|
3533 bcopy(page_buf, bp->b_un.b_addr, count);
|
|
|
3534 break;
|
|
|
3535
|
|
|
3536 case INQUIRY_DEV_IDENTIFICATION_PAGE:
|
|
|
3537 /*
|
|
|
3538 * We may want to implement this page, when
|
|
|
3539 * identifiers are common for SATA devices
|
|
|
3540 * But not now.
|
|
|
3541 */
|
|
|
3542 /*FALLTHRU*/
|
|
|
3543
|
|
|
3544 default:
|
|
|
3545 /* Request for unsupported VPD page */
|
|
|
3546 *scsipkt->pkt_scbp = STATUS_CHECK;
|
|
|
3547 sense = sata_arq_sense(spx);
|
|
|
3548 sense->es_key = KEY_ILLEGAL_REQUEST;
|
|
|
3549 sense->es_add_code =
|
|
|
3550 SD_SCSI_INVALID_FIELD_IN_CDB;
|
|
|
3551 goto done;
|
|
|
3552 }
|
|
|
3553 }
|
|
|
3554 scsipkt->pkt_state |= STATE_XFERRED_DATA;
|
|
|
3555 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ?
|
|
|
3556 scsipkt->pkt_cdbp[4] - count : 0;
|
|
|
3557 }
|
|
|
3558 done:
|
|
|
3559 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
3560
|
|
|
3561 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
3562 "Scsi_pkt completion reason %x\n",
|
|
|
3563 scsipkt->pkt_reason);
|
|
|
3564
|
|
|
3565 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
|
|
|
3566 scsipkt->pkt_comp != NULL)
|
|
|
3567 /* scsi callback required */
|
|
|
3568 (*scsipkt->pkt_comp)(scsipkt);
|
|
|
3569
|
|
|
3570 return (TRAN_ACCEPT);
|
|
|
3571 }
|
|
|
3572
|
|
|
3573 /*
|
|
|
3574 * SATA translate command: Request Sense
|
|
|
3575 * emulated command (ATA version so far, no ATAPI)
|
|
|
3576 * Always NO SENSE, because any sense data should be reported by ARQ sense.
|
|
|
3577 *
|
|
|
3578 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
|
|
|
3579 */
|
|
|
3580 static int
|
|
|
3581 sata_txlt_request_sense(sata_pkt_txlate_t *spx)
|
|
|
3582 {
|
|
|
3583 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
|
|
|
3584 struct scsi_extended_sense sense;
|
|
|
3585 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
|
|
|
3586 int rval;
|
|
|
3587
|
|
|
3588 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
3589
|
|
|
3590 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) {
|
|
|
3591 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
3592 return (rval);
|
|
|
3593 }
|
|
|
3594 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
3595
|
|
|
3596
|
|
|
3597 scsipkt->pkt_reason = CMD_CMPLT;
|
|
|
3598 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
|
|
|
3599 STATE_SENT_CMD | STATE_GOT_STATUS;
|
|
|
3600 *scsipkt->pkt_scbp = STATUS_GOOD;
|
|
|
3601
|
|
|
3602 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
|
|
|
3603 int count = MIN(bp->b_bcount,
|
|
|
3604 sizeof (struct scsi_extended_sense));
|
|
|
3605 bzero(&sense, sizeof (struct scsi_extended_sense));
|
|
|
3606 sense.es_valid = 0; /* Valid LBA */
|
|
|
3607 sense.es_class = 7; /* Response code 0x70 - current err */
|
|
|
3608 sense.es_key = KEY_NO_SENSE;
|
|
|
3609 sense.es_add_len = 6; /* Additional length */
|
|
|
3610 /* Copy no more than requested */
|
|
|
3611 bcopy(&sense, bp->b_un.b_addr, count);
|
|
|
3612 scsipkt->pkt_state |= STATE_XFERRED_DATA;
|
|
|
3613 scsipkt->pkt_resid = 0;
|
|
|
3614 }
|
|
|
3615
|
|
|
3616 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
3617 "Scsi_pkt completion reason %x\n",
|
|
|
3618 scsipkt->pkt_reason);
|
|
|
3619
|
|
|
3620 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
|
|
|
3621 scsipkt->pkt_comp != NULL)
|
|
|
3622 /* scsi callback required */
|
|
|
3623 (*scsipkt->pkt_comp)(scsipkt);
|
|
|
3624 return (TRAN_ACCEPT);
|
|
|
3625 }
|
|
|
3626
|
|
|
3627 /*
|
|
|
3628 * SATA translate command: Test Unit Ready
|
|
|
3629 * At the moment this is an emulated command (ATA version so far, no ATAPI).
|
|
|
3630 * May be translated into Check Power Mode command in the future
|
|
|
3631 *
|
|
|
3632 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
|
|
|
3633 */
|
|
|
3634 static int
|
|
|
3635 sata_txlt_test_unit_ready(sata_pkt_txlate_t *spx)
|
|
|
3636 {
|
|
|
3637 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
|
|
|
3638 struct scsi_extended_sense *sense;
|
|
|
3639 int power_state;
|
|
|
3640 int rval;
|
|
|
3641
|
|
|
3642 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
3643
|
|
|
3644 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) {
|
|
|
3645 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
3646 return (rval);
|
|
|
3647 }
|
|
|
3648 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
3649
|
|
|
3650 /* At this moment, emulate it rather than execute anything */
|
|
|
3651 power_state = SATA_PWRMODE_ACTIVE;
|
|
|
3652
|
|
|
3653 scsipkt->pkt_reason = CMD_CMPLT;
|
|
|
3654 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
|
|
|
3655 STATE_SENT_CMD | STATE_GOT_STATUS;
|
|
|
3656
|
|
|
3657 switch (power_state) {
|
|
|
3658 case SATA_PWRMODE_ACTIVE:
|
|
|
3659 case SATA_PWRMODE_IDLE:
|
|
|
3660 *scsipkt->pkt_scbp = STATUS_GOOD;
|
|
|
3661 break;
|
|
|
3662 default:
|
|
|
3663 /* PWR mode standby */
|
|
|
3664 *scsipkt->pkt_scbp = STATUS_CHECK;
|
|
|
3665 sense = sata_arq_sense(spx);
|
|
|
3666 sense->es_key = KEY_NOT_READY;
|
|
|
3667 sense->es_add_code = SD_SCSI_LU_NOT_READY;
|
|
|
3668 break;
|
|
|
3669 }
|
|
|
3670
|
|
|
3671 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
3672 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
|
|
|
3673
|
|
|
3674 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
|
|
|
3675 scsipkt->pkt_comp != NULL)
|
|
|
3676 /* scsi callback required */
|
|
|
3677 (*scsipkt->pkt_comp)(scsipkt);
|
|
|
3678
|
|
|
3679 return (TRAN_ACCEPT);
|
|
|
3680 }
|
|
|
3681
|
|
|
3682
|
|
|
3683 /*
|
|
|
3684 * SATA translate command: Start Stop Unit
|
|
|
3685 * Translation depends on a command:
|
|
|
3686 * Start Unit translated into Idle Immediate
|
|
|
3687 * Stop Unit translated into Standby Immediate
|
|
|
3688 * Unload Media / NOT SUPPORTED YET
|
|
|
3689 * Load Media / NOT SUPPROTED YET
|
|
|
3690 * Power condition bits are ignored, so is Immediate bit
|
|
|
3691 * Requesting synchronous execution.
|
|
|
3692 *
|
|
|
3693 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
|
|
|
3694 * appropriate values in scsi_pkt fields.
|
|
|
3695 */
|
|
|
3696 static int
|
|
|
3697 sata_txlt_start_stop_unit(sata_pkt_txlate_t *spx)
|
|
|
3698 {
|
|
|
3699 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
|
|
|
3700 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
|
|
|
3701 struct scsi_extended_sense *sense;
|
|
|
3702 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
|
|
|
3703 int cport = SATA_TXLT_CPORT(spx);
|
|
|
3704 int rval;
|
|
|
3705 int synch;
|
|
|
3706
|
|
|
3707 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
3708 "sata_txlt_start_stop_unit: %d\n", scsipkt->pkt_scbp[4] & 1);
|
|
|
3709
|
|
|
3710 mutex_enter(&SATA_CPORT_MUTEX(shi, cport));
|
|
|
3711
|
|
|
3712 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) {
|
|
|
3713 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
3714 return (rval);
|
|
|
3715 }
|
|
|
3716
|
|
|
3717 if (scsipkt->pkt_cdbp[4] & 2) {
|
|
|
3718 /* Load/Unload Media - invalid request */
|
|
|
3719 *scsipkt->pkt_scbp = STATUS_CHECK;
|
|
|
3720 sense = sata_arq_sense(spx);
|
|
|
3721 sense->es_key = KEY_ILLEGAL_REQUEST;
|
|
|
3722 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB;
|
|
|
3723 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
3724
|
|
|
3725 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
3726 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
|
|
|
3727
|
|
|
3728 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
|
|
|
3729 scsipkt->pkt_comp != NULL)
|
|
|
3730 /* scsi callback required */
|
|
|
3731 (*scsipkt->pkt_comp)(scsipkt);
|
|
|
3732
|
|
|
3733 return (TRAN_ACCEPT);
|
|
|
3734 }
|
|
|
3735 scmd->satacmd_addr_type = 0;
|
|
|
3736 scmd->satacmd_sec_count_lsb = 0;
|
|
|
3737 scmd->satacmd_lba_low_lsb = 0;
|
|
|
3738 scmd->satacmd_lba_mid_lsb = 0;
|
|
|
3739 scmd->satacmd_lba_high_lsb = 0;
|
|
|
3740 scmd->satacmd_features_reg = 0;
|
|
|
3741 scmd->satacmd_device_reg = 0;
|
|
|
3742 scmd->satacmd_status_reg = 0;
|
|
|
3743 if (scsipkt->pkt_cdbp[4] & 1) {
|
|
|
3744 /* Start Unit */
|
|
|
3745 scmd->satacmd_cmd_reg = SATAC_IDLE_IM;
|
|
|
3746 } else {
|
|
|
3747 /* Stop Unit */
|
|
|
3748 scmd->satacmd_cmd_reg = SATAC_STANDBY_IM;
|
|
|
3749 }
|
|
|
3750
|
|
|
3751 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
|
|
|
3752 /* Need to set-up a callback function */
|
|
|
3753 spx->txlt_sata_pkt->satapkt_comp =
|
|
|
3754 sata_txlt_nodata_cmd_completion;
|
|
|
3755 synch = FALSE;
|
|
|
3756 } else {
|
|
|
3757 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH;
|
|
|
3758 synch = TRUE;
|
|
|
3759 }
|
|
|
3760
|
|
|
3761 /* Transfer command to HBA */
|
|
|
3762 if (sata_hba_start(spx, &rval) != 0) {
|
|
|
3763 /* Pkt not accepted for execution */
|
|
|
3764 mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
|
|
|
3765 return (rval);
|
|
|
3766 }
|
|
|
3767
|
|
|
3768 /*
|
|
|
3769 * If execution is non-synchronous,
|
|
|
3770 * a callback function will handle potential errors, translate
|
|
|
3771 * the response and will do a callback to a target driver.
|
|
|
3772 * If it was synchronous, check execution status using the same
|
|
|
3773 * framework callback.
|
|
|
3774 */
|
|
|
3775 mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
|
|
|
3776 if (synch) {
|
|
|
3777 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
3778 "synchronous execution status %x\n",
|
|
|
3779 spx->txlt_sata_pkt->satapkt_reason);
|
|
|
3780
|
|
|
3781 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt);
|
|
|
3782 }
|
|
|
3783 return (TRAN_ACCEPT);
|
|
|
3784
|
|
|
3785 }
|
|
|
3786
|
|
|
3787
|
|
|
3788 /*
|
|
|
3789 * SATA translate command: Read Capacity.
|
|
|
3790 * Emulated command for SATA disks.
|
|
|
3791 * Capacity is retrieved from cached Idenifty Device data.
|
|
|
3792 * Identify Device data shows effective disk capacity, not the native
|
|
|
3793 * capacity, which may be limitted by Set Max Address command.
|
|
|
3794 * This is ATA version (non-ATAPI).
|
|
|
3795 *
|
|
|
3796 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
|
|
|
3797 */
|
|
|
3798 static int
|
|
|
3799 sata_txlt_read_capacity(sata_pkt_txlate_t *spx)
|
|
|
3800 {
|
|
|
3801 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
|
|
|
3802 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
|
|
|
3803 sata_drive_info_t *sdinfo;
|
|
|
3804 uint64_t val;
|
|
|
3805 uchar_t *rbuf;
|
|
|
3806 int rval;
|
|
|
3807
|
|
|
3808 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
3809 "sata_txlt_read_capacity: ", NULL);
|
|
|
3810
|
|
|
3811 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
3812
|
|
|
3813 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) {
|
|
|
3814 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
3815 return (rval);
|
|
|
3816 }
|
|
|
3817
|
|
|
3818 scsipkt->pkt_reason = CMD_CMPLT;
|
|
|
3819 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
|
|
|
3820 STATE_SENT_CMD | STATE_GOT_STATUS;
|
|
|
3821 *scsipkt->pkt_scbp = STATUS_GOOD;
|
|
|
3822 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
|
|
|
3823 sdinfo = sata_get_device_info(
|
|
|
3824 spx->txlt_sata_hba_inst,
|
|
|
3825 &spx->txlt_sata_pkt->satapkt_device);
|
|
|
3826 /* Last logical block address */
|
|
|
3827 val = sdinfo->satadrv_capacity - 1;
|
|
|
3828 rbuf = (uchar_t *)bp->b_un.b_addr;
|
|
|
3829 /* Need to swap endians to match scsi format */
|
|
|
3830 rbuf[0] = (val >> 24) & 0xff;
|
|
|
3831 rbuf[1] = (val >> 16) & 0xff;
|
|
|
3832 rbuf[2] = (val >> 8) & 0xff;
|
|
|
3833 rbuf[3] = val & 0xff;
|
|
|
3834 /* block size - always 512 bytes, for now */
|
|
|
3835 rbuf[4] = 0;
|
|
|
3836 rbuf[5] = 0;
|
|
|
3837 rbuf[6] = 0x02;
|
|
|
3838 rbuf[7] = 0;
|
|
|
3839 scsipkt->pkt_state |= STATE_XFERRED_DATA;
|
|
|
3840 scsipkt->pkt_resid = 0;
|
|
|
3841
|
|
|
3842 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%d\n",
|
|
|
3843 sdinfo->satadrv_capacity -1);
|
|
|
3844 }
|
|
|
3845 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
3846 /*
|
|
|
3847 * If a callback was requested, do it now.
|
|
|
3848 */
|
|
|
3849 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
3850 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
|
|
|
3851
|
|
|
3852 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
|
|
|
3853 scsipkt->pkt_comp != NULL)
|
|
|
3854 /* scsi callback required */
|
|
|
3855 (*scsipkt->pkt_comp)(scsipkt);
|
|
|
3856
|
|
|
3857 return (TRAN_ACCEPT);
|
|
|
3858 }
|
|
|
3859
|
|
|
3860 /*
|
|
|
3861 * SATA translate command: Mode Sense.
|
|
|
3862 * Translated into appropriate SATA command or emulated.
|
|
|
3863 * Saved Values Page Control (03) are not supported.
|
|
|
3864 *
|
|
|
3865 * NOTE: only caching mode sense page is currently implemented.
|
|
|
3866 *
|
|
|
3867 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
|
|
|
3868 */
|
|
|
3869
|
|
|
3870 static int
|
|
|
3871 sata_txlt_mode_sense(sata_pkt_txlate_t *spx)
|
|
|
3872 {
|
|
|
3873 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
|
|
|
3874 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
|
|
|
3875 sata_drive_info_t *sdinfo;
|
|
|
3876 struct scsi_extended_sense *sense;
|
|
|
3877 int len, bdlen, count, alc_len;
|
|
|
3878 int pc; /* Page Control code */
|
|
|
3879 uint8_t *buf; /* mode sense buffer */
|
|
|
3880 int rval;
|
|
|
3881
|
|
|
3882 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
3883 "sata_txlt_mode_sense, pc %x page code 0x%02x\n",
|
|
|
3884 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
|
|
|
3885 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
|
|
|
3886
|
|
|
3887 buf = kmem_zalloc(1024, KM_SLEEP);
|
|
|
3888
|
|
|
3889 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
3890
|
|
|
3891 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) {
|
|
|
3892 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
3893 kmem_free(buf, 1024);
|
|
|
3894 return (rval);
|
|
|
3895 }
|
|
|
3896
|
|
|
3897 scsipkt->pkt_reason = CMD_CMPLT;
|
|
|
3898 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
|
|
|
3899 STATE_SENT_CMD | STATE_GOT_STATUS;
|
|
|
3900
|
|
|
3901 pc = scsipkt->pkt_cdbp[2] >> 6;
|
|
|
3902
|
|
|
3903 /* Reject not supported request for saved parameters */
|
|
|
3904 if (pc == 3) {
|
|
|
3905 *scsipkt->pkt_scbp = STATUS_CHECK;
|
|
|
3906 sense = sata_arq_sense(spx);
|
|
|
3907 sense->es_key = KEY_ILLEGAL_REQUEST;
|
|
|
3908 sense->es_add_code = SD_SCSI_SAVING_PARAMS_NOT_SUP;
|
|
|
3909 goto done;
|
|
|
3910 }
|
|
|
3911
|
|
|
3912 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
|
|
|
3913 len = 0;
|
|
|
3914 bdlen = 0;
|
|
|
3915 if (!(scsipkt->pkt_cdbp[1] & 8)) {
|
|
|
3916 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE_G1 &&
|
|
|
3917 (scsipkt->pkt_cdbp[0] & 0x10))
|
|
|
3918 bdlen = 16;
|
|
|
3919 else
|
|
|
3920 bdlen = 8;
|
|
|
3921 }
|
|
|
3922 /* Build mode parameter header */
|
|
|
3923 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
|
|
|
3924 /* 4-byte mode parameter header */
|
|
|
3925 buf[len++] = 0; /* mode data length */
|
|
|
3926 buf[len++] = 0; /* medium type */
|
|
|
3927 buf[len++] = 0; /* dev-specific param */
|
|
|
3928 buf[len++] = bdlen; /* Block Descriptor length */
|
|
|
3929 } else {
|
|
|
3930 /* 8-byte mode parameter header */
|
|
|
3931 buf[len++] = 0; /* mode data length */
|
|
|
3932 buf[len++] = 0;
|
|
|
3933 buf[len++] = 0; /* medium type */
|
|
|
3934 buf[len++] = 0; /* dev-specific param */
|
|
|
3935 if (bdlen == 16)
|
|
|
3936 buf[len++] = 1; /* long lba descriptor */
|
|
|
3937 else
|
|
|
3938 buf[len++] = 0;
|
|
|
3939 buf[len++] = 0;
|
|
|
3940 buf[len++] = 0; /* Block Descriptor length */
|
|
|
3941 buf[len++] = bdlen;
|
|
|
3942 }
|
|
|
3943
|
|
|
3944 sdinfo = sata_get_device_info(
|
|
|
3945 spx->txlt_sata_hba_inst,
|
|
|
3946 &spx->txlt_sata_pkt->satapkt_device);
|
|
|
3947
|
|
|
3948 /* Build block descriptor only if not disabled (DBD) */
|
|
|
3949 if ((scsipkt->pkt_cdbp[1] & 0x08) == 0) {
|
|
|
3950 /* Block descriptor - direct-access device format */
|
|
|
3951 if (bdlen == 8) {
|
|
|
3952 /* build regular block descriptor */
|
|
|
3953 buf[len++] =
|
|
|
3954 (sdinfo->satadrv_capacity >> 24) & 0xff;
|
|
|
3955 buf[len++] =
|
|
|
3956 (sdinfo->satadrv_capacity >> 16) & 0xff;
|
|
|
3957 buf[len++] =
|
|
|
3958 (sdinfo->satadrv_capacity >> 8) & 0xff;
|
|
|
3959 buf[len++] = sdinfo->satadrv_capacity & 0xff;
|
|
|
3960 buf[len++] = 0; /* density code */
|
|
|
3961 buf[len++] = 0;
|
|
|
3962 if (sdinfo->satadrv_type ==
|
|
|
3963 SATA_DTYPE_ATADISK)
|
|
|
3964 buf[len++] = 2;
|
|
|
3965 else
|
|
|
3966 /* ATAPI */
|
|
|
3967 buf[len++] = 8;
|
|
|
3968 buf[len++] = 0;
|
|
|
3969 } else if (bdlen == 16) {
|
|
|
3970 /* Long LBA Accepted */
|
|
|
3971 /* build long lba block descriptor */
|
|
|
3972 #ifndef __lock_lint
|
|
|
3973 buf[len++] =
|
|
|
3974 (sdinfo->satadrv_capacity >> 56) & 0xff;
|
|
|
3975 buf[len++] =
|
|
|
3976 (sdinfo->satadrv_capacity >> 48) & 0xff;
|
|
|
3977 buf[len++] =
|
|
|
3978 (sdinfo->satadrv_capacity >> 40) & 0xff;
|
|
|
3979 buf[len++] =
|
|
|
3980 (sdinfo->satadrv_capacity >> 32) & 0xff;
|
|
|
3981 #endif
|
|
|
3982 buf[len++] =
|
|
|
3983 (sdinfo->satadrv_capacity >> 24) & 0xff;
|
|
|
3984 buf[len++] =
|
|
|
3985 (sdinfo->satadrv_capacity >> 16) & 0xff;
|
|
|
3986 buf[len++] =
|
|
|
3987 (sdinfo->satadrv_capacity >> 8) & 0xff;
|
|
|
3988 buf[len++] = sdinfo->satadrv_capacity & 0xff;
|
|
|
3989 buf[len++] = 0;
|
|
|
3990 buf[len++] = 0; /* density code */
|
|
|
3991 buf[len++] = 0;
|
|
|
3992 buf[len++] = 0;
|
|
|
3993 if (sdinfo->satadrv_type ==
|
|
|
3994 SATA_DTYPE_ATADISK)
|
|
|
3995 buf[len++] = 2;
|
|
|
3996 else
|
|
|
3997 /* ATAPI */
|
|
|
3998 buf[len++] = 8;
|
|
|
3999 buf[len++] = 0;
|
|
|
4000 }
|
|
|
4001 }
|
|
|
4002 /*
|
|
|
4003 * Add requested pages.
|
|
|
4004 * Page 3 and 4 are obsolete and we are not supporting them.
|
|
|
4005 * We deal now with:
|
|
|
4006 * caching (read/write cache control).
|
|
|
4007 * We should eventually deal with following mode pages:
|
|
|
4008 * error recovery (0x01),
|
|
|
4009 * power condition (0x1a),
|
|
|
4010 * exception control page (enables SMART) (0x1c),
|
|
|
4011 * enclosure management (ses),
|
|
|
4012 * protocol-specific port mode (port control).
|
|
|
4013 */
|
|
|
4014 switch (scsipkt->pkt_cdbp[2] & 0x3f) {
|
|
|
4015 case MODEPAGE_RW_ERRRECOV:
|
|
|
4016 /* DAD_MODE_ERR_RECOV */
|
|
|
4017 /* R/W recovery */
|
|
|
4018 len += sata_build_msense_page_1(sdinfo, pc, buf+len);
|
|
|
4019 break;
|
|
|
4020 case MODEPAGE_CACHING:
|
|
|
4021 /* DAD_MODE_CACHE */
|
|
|
4022 /* caching */
|
|
|
4023 len += sata_build_msense_page_8(sdinfo, pc, buf+len);
|
|
|
4024 break;
|
|
|
4025 case MODEPAGE_INFO_EXCPT:
|
|
|
4026 /* exception cntrl */
|
|
|
4027 len += sata_build_msense_page_1c(sdinfo, pc, buf+len);
|
|
|
4028 break;
|
|
|
4029 case MODEPAGE_POWER_COND:
|
|
|
4030 /* DAD_MODE_POWER_COND */
|
|
|
4031 /* power condition */
|
|
|
4032 len += sata_build_msense_page_1a(sdinfo, pc, buf+len);
|
|
|
4033 break;
|
|
|
4034 case MODEPAGE_ALLPAGES:
|
|
|
4035 /* all pages */
|
|
|
4036 len += sata_build_msense_page_1(sdinfo, pc, buf+len);
|
|
|
4037 len += sata_build_msense_page_8(sdinfo, pc, buf+len);
|
|
|
4038 len += sata_build_msense_page_1a(sdinfo, pc, buf+len);
|
|
|
4039 len += sata_build_msense_page_1c(sdinfo, pc, buf+len);
|
|
|
4040 break;
|
|
|
4041 default:
|
|
|
4042 /* Invalid request */
|
|
|
4043 *scsipkt->pkt_scbp = STATUS_CHECK;
|
|
|
4044 sense = sata_arq_sense(spx);
|
|
|
4045 sense->es_key = KEY_ILLEGAL_REQUEST;
|
|
|
4046 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB;
|
|
|
4047 goto done;
|
|
|
4048 }
|
|
|
4049
|
|
|
4050 /* fix total mode data length */
|
|
|
4051 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
|
|
|
4052 /* 4-byte mode parameter header */
|
|
|
4053 buf[0] = len - 1; /* mode data length */
|
|
|
4054 } else {
|
|
|
4055 buf[0] = (len -2) >> 8;
|
|
|
4056 buf[1] = (len -2) & 0xff;
|
|
|
4057 }
|
|
|
4058
|
|
|
4059
|
|
|
4060 /* Check allocation length */
|
|
|
4061 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
|
|
|
4062 alc_len = scsipkt->pkt_cdbp[4];
|
|
|
4063 } else {
|
|
|
4064 alc_len = scsipkt->pkt_cdbp[7];
|
|
|
4065 alc_len = (len << 8) | scsipkt->pkt_cdbp[8];
|
|
|
4066 }
|
|
|
4067 /*
|
|
|
4068 * We do not check for possible parameters truncation
|
|
|
4069 * (alc_len < len) assuming that the target driver works
|
|
|
4070 * correctly. Just avoiding overrun.
|
|
|
4071 * Copy no more than requested and possible, buffer-wise.
|
|
|
4072 */
|
|
|
4073 count = MIN(alc_len, len);
|
|
|
4074 count = MIN(bp->b_bcount, count);
|
|
|
4075 bcopy(buf, bp->b_un.b_addr, count);
|
|
|
4076
|
|
|
4077 scsipkt->pkt_state |= STATE_XFERRED_DATA;
|
|
|
4078 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0;
|
|
|
4079 }
|
|
|
4080 *scsipkt->pkt_scbp = STATUS_GOOD;
|
|
|
4081 done:
|
|
|
4082 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
4083 (void) kmem_free(buf, 1024);
|
|
|
4084
|
|
|
4085 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
4086 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
|
|
|
4087
|
|
|
4088 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
|
|
|
4089 scsipkt->pkt_comp != NULL)
|
|
|
4090 /* scsi callback required */
|
|
|
4091 (*scsipkt->pkt_comp)(scsipkt);
|
|
|
4092
|
|
|
4093 return (TRAN_ACCEPT);
|
|
|
4094 }
|
|
|
4095
|
|
|
4096
|
|
|
4097 /*
|
|
|
4098 * SATA translate command: Mode Select.
|
|
|
4099 * Translated into appropriate SATA command or emulated.
|
|
|
4100 * Saving parameters is not supported.
|
|
|
4101 * Changing device capacity is not supported (although theoretically
|
|
|
4102 * possible by executing SET FEATURES/SET MAX ADDRESS)
|
|
|
4103 *
|
|
|
4104 * Assumption is that the target driver is working correctly.
|
|
|
4105 *
|
|
|
4106 * More than one SATA command may be executed to perform operations specified
|
|
|
4107 * by mode select pages. The first error terminates further execution.
|
|
|
4108 * Operations performed successully are not backed-up in such case.
|
|
|
4109 *
|
|
|
4110 * NOTE: only caching mode select page is implemented.
|
|
|
4111 * Caching setup is remembered so it could be re-stored in case of
|
|
|
4112 * an unexpected device reset.
|
|
|
4113 *
|
|
|
4114 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
|
|
|
4115 */
|
|
|
4116
|
|
|
4117 static int
|
|
|
4118 sata_txlt_mode_select(sata_pkt_txlate_t *spx)
|
|
|
4119 {
|
|
|
4120 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
|
|
|
4121 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
|
|
|
4122 struct scsi_extended_sense *sense;
|
|
|
4123 int len, pagelen, count, pllen;
|
|
|
4124 uint8_t *buf; /* mode select buffer */
|
|
|
4125 int rval, stat;
|
|
|
4126 uint_t nointr_flag;
|
|
|
4127 int dmod = 0;
|
|
|
4128
|
|
|
4129 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
4130 "sata_txlt_mode_select, pc %x page code 0x%02x\n",
|
|
|
4131 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
|
|
|
4132 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
|
|
|
4133
|
|
|
4134 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
4135
|
|
|
4136 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) {
|
|
|
4137 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
4138 return (rval);
|
|
|
4139 }
|
|
|
4140
|
|
|
4141 rval = TRAN_ACCEPT;
|
|
|
4142
|
|
|
4143 scsipkt->pkt_reason = CMD_CMPLT;
|
|
|
4144 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
|
|
|
4145 STATE_SENT_CMD | STATE_GOT_STATUS;
|
|
|
4146
|
|
|
4147 /* Reject not supported request */
|
|
|
4148 if (! (scsipkt->pkt_cdbp[1] & 0x10) || /* No support for PF bit = 0 */
|
|
|
4149 (scsipkt->pkt_cdbp[1] & 0x01)) { /* No support for SP (saving) */
|
|
|
4150 *scsipkt->pkt_scbp = STATUS_CHECK;
|
|
|
4151 sense = sata_arq_sense(spx);
|
|
|
4152 sense->es_key = KEY_ILLEGAL_REQUEST;
|
|
|
4153 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB;
|
|
|
4154 goto done;
|
|
|
4155 }
|
|
|
4156
|
|
|
4157 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) {
|
|
|
4158 pllen = scsipkt->pkt_cdbp[4];
|
|
|
4159 } else {
|
|
|
4160 pllen = scsipkt->pkt_cdbp[7];
|
|
|
4161 pllen = (pllen << 8) | scsipkt->pkt_cdbp[7];
|
|
|
4162 }
|
|
|
4163
|
|
|
4164 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */
|
|
|
4165
|
|
|
4166 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount && pllen != 0) {
|
|
|
4167 buf = (uint8_t *)bp->b_un.b_addr;
|
|
|
4168 count = MIN(bp->b_bcount, pllen);
|
|
|
4169 scsipkt->pkt_state |= STATE_XFERRED_DATA;
|
|
|
4170 scsipkt->pkt_resid = 0;
|
|
|
4171 pllen = count;
|
|
|
4172
|
|
|
4173 /*
|
|
|
4174 * Check the header to skip the block descriptor(s) - we
|
|
|
4175 * do not support setting device capacity.
|
|
|
4176 * Existing macros do not recognize long LBA dscriptor,
|
|
|
4177 * hence manual calculation.
|
|
|
4178 */
|
|
|
4179 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) {
|
|
|
4180 /* 6-bytes CMD, 4 bytes header */
|
|
|
4181 if (count <= 4)
|
|
|
4182 goto done; /* header only */
|
|
|
4183 len = buf[3] + 4;
|
|
|
4184 } else {
|
|
|
4185 /* 10-bytes CMD, 8 bytes header */
|
|
|
4186 if (count <= 8)
|
|
|
4187 goto done; /* header only */
|
|
|
4188 len = buf[6];
|
|
|
4189 len = (len << 8) + buf[7] + 8;
|
|
|
4190 }
|
|
|
4191 if (len >= count)
|
|
|
4192 goto done; /* header + descriptor(s) only */
|
|
|
4193
|
|
|
4194 pllen -= len; /* remaining data length */
|
|
|
4195
|
|
|
4196 /*
|
|
|
4197 * We may be executing SATA command and want to execute it
|
|
|
4198 * in SYNCH mode, regardless of scsi_pkt setting.
|
|
|
4199 * Save scsi_pkt setting and indicate SYNCH mode
|
|
|
4200 */
|
|
|
4201 nointr_flag = scsipkt->pkt_flags & FLAG_NOINTR;
|
|
|
4202 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
|
|
|
4203 scsipkt->pkt_comp != NULL) {
|
|
|
4204 scsipkt->pkt_flags |= FLAG_NOINTR;
|
|
|
4205 }
|
|
|
4206 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH;
|
|
|
4207
|
|
|
4208 /*
|
|
|
4209 * len is now the offset to a first mode select page
|
|
|
4210 * Process all pages
|
|
|
4211 */
|
|
|
4212 while (pllen > 0) {
|
|
|
4213 switch ((int)buf[len]) {
|
|
|
4214 case MODEPAGE_CACHING:
|
|
|
4215 stat = sata_mode_select_page_8(spx,
|
|
|
4216 (struct mode_cache_scsi3 *)&buf[len],
|
|
|
4217 pllen, &pagelen, &rval, &dmod);
|
|
|
4218 /*
|
|
|
4219 * The pagelen value indicates number of
|
|
|
4220 * parameter bytes already processed.
|
|
|
4221 * The rval is return value from
|
|
|
4222 * sata_tran_start().
|
|
|
4223 * The stat indicates the overall status of
|
|
|
4224 * the operation(s).
|
|
|
4225 */
|
|
|
4226 if (stat != SATA_SUCCESS)
|
|
|
4227 /*
|
|
|
4228 * Page processing did not succeed -
|
|
|
4229 * all error info is already set-up,
|
|
|
4230 * just return
|
|
|
4231 */
|
|
|
4232 pllen = 0; /* this breaks the loop */
|
|
|
4233 else {
|
|
|
4234 len += pagelen;
|
|
|
4235 pllen -= pagelen;
|
|
|
4236 }
|
|
|
4237 break;
|
|
|
4238
|
|
|
4239 default:
|
|
|
4240 *scsipkt->pkt_scbp = STATUS_CHECK;
|
|
|
4241 sense = sata_arq_sense(spx);
|
|
|
4242 sense->es_key = KEY_ILLEGAL_REQUEST;
|
|
|
4243 sense->es_add_code =
|
|
|
4244 SD_SCSI_INVALID_FIELD_IN_PARAMETER_LIST;
|
|
|
4245 goto done;
|
|
|
4246 }
|
|
|
4247 }
|
|
|
4248 }
|
|
|
4249 done:
|
|
|
4250 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
4251 /*
|
|
|
4252 * If device parameters were modified, fetch and store the new
|
|
|
4253 * Identify Device data. Since port mutex could have been released
|
|
|
4254 * for accessing HBA driver, we need to re-check device existence.
|
|
|
4255 */
|
|
|
4256 if (dmod != 0) {
|
|
|
4257 sata_drive_info_t new_sdinfo, *sdinfo;
|
|
|
4258 int rv;
|
|
|
4259
|
|
|
4260 new_sdinfo.satadrv_addr =
|
|
|
4261 spx->txlt_sata_pkt->satapkt_device.satadev_addr;
|
|
|
4262 rv = sata_fetch_device_identify_data(spx->txlt_sata_hba_inst,
|
|
|
4263 &new_sdinfo);
|
|
|
4264
|
|
|
4265 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
4266 /*
|
|
|
4267 * Since port mutex could have been released when
|
|
|
4268 * accessing HBA driver, we need to re-check that the
|
|
|
4269 * framework still holds the device info structure.
|
|
|
4270 */
|
|
|
4271 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
|
|
|
4272 &spx->txlt_sata_pkt->satapkt_device);
|
|
|
4273 if (sdinfo != NULL) {
|
|
|
4274 /*
|
|
|
4275 * Device still has info structure in the
|
|
|
4276 * sata framework. Copy newly fetched info
|
|
|
4277 */
|
|
|
4278 if (rv == 0) {
|
|
|
4279 sdinfo->satadrv_id = new_sdinfo.satadrv_id;
|
|
|
4280 sata_save_drive_settings(sdinfo);
|
|
|
4281 } else {
|
|
|
4282 /*
|
|
|
4283 * Could not fetch new data - invalidate
|
|
|
4284 * sata_drive_info. That makes device
|
|
|
4285 * unusable.
|
|
|
4286 */
|
|
|
4287 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
|
|
|
4288 sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
|
|
|
4289 }
|
|
|
4290 }
|
|
|
4291 if (rv != 0 || sdinfo == NULL) {
|
|
|
4292 /*
|
|
|
4293 * This changes the overall mode select completion
|
|
|
4294 * reason to a failed one !!!!!
|
|
|
4295 */
|
|
|
4296 *scsipkt->pkt_scbp = STATUS_CHECK;
|
|
|
4297 sense = sata_arq_sense(spx);
|
|
|
4298 scsipkt->pkt_reason = CMD_INCOMPLETE;
|
|
|
4299 rval = TRAN_ACCEPT;
|
|
|
4300 }
|
|
|
4301 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
4302 }
|
|
|
4303 /* Restore the scsi pkt flags */
|
|
|
4304 scsipkt->pkt_flags &= ~FLAG_NOINTR;
|
|
|
4305 scsipkt->pkt_flags |= nointr_flag;
|
|
|
4306
|
|
|
4307 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
4308 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
|
|
|
4309
|
|
|
4310 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
|
|
|
4311 scsipkt->pkt_comp != NULL)
|
|
|
4312 /* scsi callback required */
|
|
|
4313 (*scsipkt->pkt_comp)(scsipkt);
|
|
|
4314
|
|
|
4315 return (rval);
|
|
|
4316 }
|
|
|
4317
|
|
|
4318
|
|
|
4319
|
|
|
4320 /*
|
|
|
4321 * Translate command: Log Sense
|
|
|
4322 * Not implemented at this time - returns invalid command response.
|
|
|
4323 */
|
|
|
4324 static int
|
|
|
4325 sata_txlt_log_sense(sata_pkt_txlate_t *spx)
|
|
|
4326 {
|
|
|
4327 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
4328 "sata_txlt_log_sense, pc %x, page code %x\n",
|
|
|
4329 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
|
|
|
4330 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
|
|
|
4331
|
|
|
4332 return (sata_txlt_invalid_command(spx));
|
|
|
4333 }
|
|
|
4334
|
|
|
4335 /*
|
|
|
4336 * Translate command: Log Select
|
|
|
4337 * Not implemented at this time - returns invalid command response.
|
|
|
4338 */
|
|
|
4339 static int
|
|
|
4340 sata_txlt_log_select(sata_pkt_txlate_t *spx)
|
|
|
4341 {
|
|
|
4342 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
4343 "sata_txlt_log_select\n", NULL);
|
|
|
4344
|
|
|
4345 return (sata_txlt_invalid_command(spx));
|
|
|
4346 }
|
|
|
4347
|
|
|
4348
|
|
|
4349 /*
|
|
|
4350 * Translate command: Read (various types).
|
|
|
4351 * Translated into appropriate type of ATA READ command
|
|
|
4352 * (NO ATAPI implementation yet).
|
|
|
4353 * Both the device capabilities and requested operation mode are
|
|
|
4354 * considered.
|
|
|
4355 *
|
|
|
4356 * Following scsi cdb fields are ignored:
|
|
|
4357 * rdprotect, dpo, fua, fua_nv, group_number.
|
|
|
4358 *
|
|
|
4359 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework
|
|
|
4360 * enable variable sata_func_enable), the capability of the controller and
|
|
|
4361 * capability of a device are checked and if both support queueing, read
|
|
|
4362 * request will be translated to READ_DMA_QUEUEING or READ_DMA_QUEUEING_EXT
|
|
|
4363 * command rather than plain READ_XXX command.
|
|
|
4364 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and
|
|
|
4365 * both the controller and device suport such functionality, the read
|
|
|
4366 * request will be translated to READ_FPDMA_QUEUED command.
|
|
|
4367 *
|
|
|
4368 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
|
|
|
4369 * appropriate values in scsi_pkt fields.
|
|
|
4370 */
|
|
|
4371 static int
|
|
|
4372 sata_txlt_read(sata_pkt_txlate_t *spx)
|
|
|
4373 {
|
|
|
4374 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
|
|
|
4375 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
|
|
|
4376 sata_drive_info_t *sdinfo;
|
|
|
4377 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
|
|
|
4378 int cport = SATA_TXLT_CPORT(spx);
|
|
|
4379 uint16_t sec_count;
|
|
|
4380 uint64_t lba;
|
|
|
4381 int rval;
|
|
|
4382 int synch;
|
|
|
4383
|
|
|
4384 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
4385
|
|
|
4386 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) {
|
|
|
4387 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
4388 return (rval);
|
|
|
4389 }
|
|
|
4390
|
|
|
4391 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
|
|
|
4392 &spx->txlt_sata_pkt->satapkt_device);
|
|
|
4393
|
|
|
4394 scmd->satacmd_flags &= ~SATA_XFER_DIR_MASK;
|
|
|
4395 scmd->satacmd_flags |= SATA_DIR_READ;
|
|
|
4396 /*
|
|
|
4397 * Build cmd block depending on the device capability and
|
|
|
4398 * requested operation mode.
|
|
|
4399 * Do not bother with non-dma mode.
|
|
|
4400 */
|
|
|
4401 switch ((uint_t)scsipkt->pkt_cdbp[0]) {
|
|
|
4402 case SCMD_READ:
|
|
|
4403 /* 6-byte scsi read cmd : 0x08 */
|
|
|
4404 lba = (scsipkt->pkt_cdbp[1] & 0x1f);
|
|
|
4405 lba = (lba << 8) | scsipkt->pkt_cdbp[2];
|
|
|
4406 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
|
|
|
4407 sec_count = scsipkt->pkt_cdbp[4];
|
|
|
4408 /* sec_count 0 will be interpreted as 256 by a device */
|
|
|
4409 break;
|
|
|
4410 case SCMD_READ_G1:
|
|
|
4411 /* 10-bytes scsi read command : 0x28 */
|
|
|
4412 lba = scsipkt->pkt_cdbp[2];
|
|
|
4413 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
|
|
|
4414 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
|
|
|
4415 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
|
|
|
4416 sec_count = scsipkt->pkt_cdbp[7];
|
|
|
4417 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
|
|
|
4418 break;
|
|
|
4419 case SCMD_READ_G5:
|
|
|
4420 /* 12-bytes scsi read command : 0xA8 */
|
|
|
4421 lba = scsipkt->pkt_cdbp[2];
|
|
|
4422 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
|
|
|
4423 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
|
|
|
4424 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
|
|
|
4425 sec_count = scsipkt->pkt_cdbp[6];
|
|
|
4426 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7];
|
|
|
4427 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
|
|
|
4428 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9];
|
|
|
4429 break;
|
|
|
4430 case SCMD_READ_G4:
|
|
|
4431 /* 16-bytes scsi read command : 0x88 */
|
|
|
4432 lba = scsipkt->pkt_cdbp[2];
|
|
|
4433 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
|
|
|
4434 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
|
|
|
4435 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
|
|
|
4436 lba = (lba << 8) | scsipkt->pkt_cdbp[6];
|
|
|
4437 lba = (lba << 8) | scsipkt->pkt_cdbp[7];
|
|
|
4438 lba = (lba << 8) | scsipkt->pkt_cdbp[8];
|
|
|
4439 lba = (lba << 8) | scsipkt->pkt_cdbp[9];
|
|
|
4440 sec_count = scsipkt->pkt_cdbp[10];
|
|
|
4441 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11];
|
|
|
4442 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12];
|
|
|
4443 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13];
|
|
|
4444 break;
|
|
|
4445 default:
|
|
|
4446 /* Unsupported command */
|
|
|
4447 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
4448 return (sata_txlt_invalid_command(spx));
|
|
|
4449 }
|
|
|
4450
|
|
|
4451 /*
|
|
|
4452 * Check if specified address exceeds device capacity
|
|
|
4453 */
|
|
|
4454 if ((lba >= sdinfo->satadrv_capacity) ||
|
|
|
4455 ((lba + sec_count) >= sdinfo->satadrv_capacity)) {
|
|
|
4456 /* LBA out of range */
|
|
|
4457 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
4458 return (sata_txlt_lba_out_of_range(spx));
|
|
|
4459 }
|
|
|
4460
|
|
|
4461 scmd->satacmd_addr_type = ATA_ADDR_LBA;
|
|
|
4462 scmd->satacmd_device_reg = SATA_ADH_LBA;
|
|
|
4463 scmd->satacmd_cmd_reg = SATAC_READ_DMA;
|
|
|
4464 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
|
|
|
4465 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
|
|
|
4466 scmd->satacmd_cmd_reg = SATAC_READ_DMA_EXT;
|
|
|
4467 scmd->satacmd_sec_count_msb = sec_count >> 8;
|
|
|
4468 #ifndef __lock_lint
|
|
|
4469 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff;
|
|
|
4470 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff;
|
|
|
4471 scmd->satacmd_lba_high_msb = lba >> 40;
|
|
|
4472 #endif
|
|
|
4473 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) {
|
|
|
4474 scmd->satacmd_addr_type = ATA_ADDR_LBA28;
|
|
|
4475 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf);
|
|
|
4476 }
|
|
|
4477 scmd->satacmd_sec_count_lsb = sec_count & 0xff;
|
|
|
4478 scmd->satacmd_lba_low_lsb = lba & 0xff;
|
|
|
4479 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
|
|
|
4480 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
|
|
|
4481 scmd->satacmd_features_reg = 0;
|
|
|
4482 scmd->satacmd_status_reg = 0;
|
|
|
4483 scmd->satacmd_error_reg = 0;
|
|
|
4484
|
|
|
4485 /*
|
|
|
4486 * Check if queueing commands should be used and switch
|
|
|
4487 * to appropriate command if possible
|
|
|
4488 */
|
|
|
4489 if (sata_func_enable & SATA_ENABLE_QUEUING) {
|
|
|
4490 if (sdinfo->satadrv_queue_depth > 1 &&
|
|
|
4491 SATA_QDEPTH(spx->txlt_sata_hba_inst) > 1) {
|
|
|
4492 /* Queuing supported by controller and device */
|
|
|
4493 if ((sata_func_enable & SATA_ENABLE_NCQ) &&
|
|
|
4494 (sdinfo->satadrv_features_support &
|
|
|
4495 SATA_DEV_F_NCQ) &&
|
|
|
4496 (SATA_FEATURES(spx->txlt_sata_hba_inst) &
|
|
|
4497 SATA_CTLF_NCQ)) {
|
|
|
4498 /* NCQ supported - use FPDMA READ */
|
|
|
4499 scmd->satacmd_cmd_reg =
|
|
|
4500 SATAC_READ_FPDMA_QUEUED;
|
|
|
4501 scmd->satacmd_features_reg_ext =
|
|
|
4502 scmd->satacmd_sec_count_msb;
|
|
|
4503 scmd->satacmd_sec_count_msb = 0;
|
|
|
4504 } else {
|
|
|
4505 /* Legacy queueing */
|
|
|
4506 if (sdinfo->satadrv_features_support &
|
|
|
4507 SATA_DEV_F_LBA48) {
|
|
|
4508 scmd->satacmd_cmd_reg =
|
|
|
4509 SATAC_READ_DMA_QUEUED_EXT;
|
|
|
4510 scmd->satacmd_features_reg_ext =
|
|
|
4511 scmd->satacmd_sec_count_msb;
|
|
|
4512 scmd->satacmd_sec_count_msb = 0;
|
|
|
4513 } else {
|
|
|
4514 scmd->satacmd_cmd_reg =
|
|
|
4515 SATAC_READ_DMA_QUEUED;
|
|
|
4516 }
|
|
|
4517 }
|
|
|
4518 scmd->satacmd_features_reg =
|
|
|
4519 scmd->satacmd_sec_count_lsb;
|
|
|
4520 scmd->satacmd_sec_count_lsb = 0;
|
|
|
4521 scmd->satacmd_flags |= SATA_QUEUED_CMD;
|
|
|
4522 }
|
|
|
4523 }
|
|
|
4524
|
|
|
4525 SATADBG3(SATA_DBG_HBA_IF, spx->txlt_sata_hba_inst,
|
|
|
4526 "sata_txlt_read cmd 0x%2x, lba %llx, sec count %x\n",
|
|
|
4527 scmd->satacmd_cmd_reg, lba, sec_count);
|
|
|
4528
|
|
|
4529 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
|
|
|
4530 /* Need callback function */
|
|
|
4531 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion;
|
|
|
4532 synch = FALSE;
|
|
|
4533 } else
|
|
|
4534 synch = TRUE;
|
|
|
4535
|
|
|
4536 /* Transfer command to HBA */
|
|
|
4537 if (sata_hba_start(spx, &rval) != 0) {
|
|
|
4538 /* Pkt not accepted for execution */
|
|
|
4539 mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
|
|
|
4540 return (rval);
|
|
|
4541 }
|
|
|
4542 mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
|
|
|
4543 /*
|
|
|
4544 * If execution is non-synchronous,
|
|
|
4545 * a callback function will handle potential errors, translate
|
|
|
4546 * the response and will do a callback to a target driver.
|
|
|
4547 * If it was synchronous, check execution status using the same
|
|
|
4548 * framework callback.
|
|
|
4549 */
|
|
|
4550 if (synch) {
|
|
|
4551 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
4552 "synchronous execution status %x\n",
|
|
|
4553 spx->txlt_sata_pkt->satapkt_reason);
|
|
|
4554 sata_txlt_rw_completion(spx->txlt_sata_pkt);
|
|
|
4555 }
|
|
|
4556 return (TRAN_ACCEPT);
|
|
|
4557 }
|
|
|
4558
|
|
|
4559
|
|
|
4560 /*
|
|
|
4561 * SATA translate command: Write (various types)
|
|
|
4562 * Translated into appropriate type of ATA WRITE command
|
|
|
4563 * (NO ATAPI implementation yet).
|
|
|
4564 * Both the device capabilities and requested operation mode are
|
|
|
4565 * considered.
|
|
|
4566 *
|
|
|
4567 * Following scsi cdb fields are ignored:
|
|
|
4568 * rwprotect, dpo, fua, fua_nv, group_number.
|
|
|
4569 *
|
|
|
4570 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
|
|
|
4571 * appropriate values in scsi_pkt fields.
|
|
|
4572 */
|
|
|
4573 static int
|
|
|
4574 sata_txlt_write(sata_pkt_txlate_t *spx)
|
|
|
4575 {
|
|
|
4576 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
|
|
|
4577 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
|
|
|
4578 sata_drive_info_t *sdinfo;
|
|
|
4579 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
|
|
|
4580 int cport = SATA_TXLT_CPORT(spx);
|
|
|
4581 uint16_t sec_count;
|
|
|
4582 uint64_t lba;
|
|
|
4583 int rval;
|
|
|
4584 int synch;
|
|
|
4585
|
|
|
4586 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
4587
|
|
|
4588 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) {
|
|
|
4589 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
4590 return (rval);
|
|
|
4591 }
|
|
|
4592
|
|
|
4593 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
|
|
|
4594 &spx->txlt_sata_pkt->satapkt_device);
|
|
|
4595
|
|
|
4596 scmd->satacmd_flags &= ~SATA_XFER_DIR_MASK;
|
|
|
4597 scmd->satacmd_flags |= SATA_DIR_WRITE;
|
|
|
4598 /*
|
|
|
4599 * Build cmd block depending on the device capability and
|
|
|
4600 * requested operation mode.
|
|
|
4601 * Do not bother with non-dma mode.
|
|
|
4602 */
|
|
|
4603 switch ((uint_t)scsipkt->pkt_cdbp[0]) {
|
|
|
4604 case SCMD_WRITE:
|
|
|
4605 /* 6-byte scsi read cmd : 0x0A */
|
|
|
4606 lba = (scsipkt->pkt_cdbp[1] & 0x1f);
|
|
|
4607 lba = (lba << 8) | scsipkt->pkt_cdbp[2];
|
|
|
4608 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
|
|
|
4609 sec_count = scsipkt->pkt_cdbp[4];
|
|
|
4610 /* sec_count 0 will be interpreted as 256 by a device */
|
|
|
4611 break;
|
|
|
4612 case SCMD_WRITE_G1:
|
|
|
4613 /* 10-bytes scsi write command : 0x2A */
|
|
|
4614 lba = scsipkt->pkt_cdbp[2];
|
|
|
4615 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
|
|
|
4616 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
|
|
|
4617 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
|
|
|
4618 sec_count = scsipkt->pkt_cdbp[7];
|
|
|
4619 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
|
|
|
4620 break;
|
|
|
4621 case SCMD_WRITE_G5:
|
|
|
4622 /* 12-bytes scsi read command : 0xAA */
|
|
|
4623 lba = scsipkt->pkt_cdbp[2];
|
|
|
4624 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
|
|
|
4625 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
|
|
|
4626 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
|
|
|
4627 sec_count = scsipkt->pkt_cdbp[6];
|
|
|
4628 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7];
|
|
|
4629 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
|
|
|
4630 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9];
|
|
|
4631 break;
|
|
|
4632 case SCMD_WRITE_G4:
|
|
|
4633 /* 16-bytes scsi write command : 0x8A */
|
|
|
4634 lba = scsipkt->pkt_cdbp[2];
|
|
|
4635 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
|
|
|
4636 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
|
|
|
4637 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
|
|
|
4638 lba = (lba << 8) | scsipkt->pkt_cdbp[6];
|
|
|
4639 lba = (lba << 8) | scsipkt->pkt_cdbp[7];
|
|
|
4640 lba = (lba << 8) | scsipkt->pkt_cdbp[8];
|
|
|
4641 lba = (lba << 8) | scsipkt->pkt_cdbp[9];
|
|
|
4642 sec_count = scsipkt->pkt_cdbp[10];
|
|
|
4643 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11];
|
|
|
4644 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12];
|
|
|
4645 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13];
|
|
|
4646 break;
|
|
|
4647 default:
|
|
|
4648 /* Unsupported command */
|
|
|
4649 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
4650 return (sata_txlt_invalid_command(spx));
|
|
|
4651 }
|
|
|
4652
|
|
|
4653 /*
|
|
|
4654 * Check if specified address and length exceeds device capacity
|
|
|
4655 */
|
|
|
4656 if ((lba >= sdinfo->satadrv_capacity) ||
|
|
|
4657 ((lba + sec_count) >= sdinfo->satadrv_capacity)) {
|
|
|
4658 /* LBA out of range */
|
|
|
4659 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
4660 return (sata_txlt_lba_out_of_range(spx));
|
|
|
4661 }
|
|
|
4662
|
|
|
4663 scmd->satacmd_addr_type = ATA_ADDR_LBA;
|
|
|
4664 scmd->satacmd_device_reg = SATA_ADH_LBA;
|
|
|
4665 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA;
|
|
|
4666 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
|
|
|
4667 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
|
|
|
4668 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA_EXT;
|
|
|
4669 scmd->satacmd_sec_count_msb = sec_count >> 8;
|
|
|
4670 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff;
|
|
|
4671 #ifndef __lock_lint
|
|
|
4672 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff;
|
|
|
4673 scmd->satacmd_lba_high_msb = lba >> 40;
|
|
|
4674 #endif
|
|
|
4675 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) {
|
|
|
4676 scmd->satacmd_addr_type = ATA_ADDR_LBA28;
|
|
|
4677 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf);
|
|
|
4678 }
|
|
|
4679 scmd->satacmd_sec_count_lsb = sec_count & 0xff;
|
|
|
4680 scmd->satacmd_lba_low_lsb = lba & 0xff;
|
|
|
4681 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
|
|
|
4682 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
|
|
|
4683 scmd->satacmd_features_reg = 0;
|
|
|
4684 scmd->satacmd_status_reg = 0;
|
|
|
4685 scmd->satacmd_error_reg = 0;
|
|
|
4686
|
|
|
4687 /*
|
|
|
4688 * Check if queueing commands should be used and switch
|
|
|
4689 * to appropriate command if possible
|
|
|
4690 */
|
|
|
4691 if (sata_func_enable & SATA_ENABLE_QUEUING) {
|
|
|
4692 if (sdinfo->satadrv_queue_depth > 1 &&
|
|
|
4693 SATA_QDEPTH(spx->txlt_sata_hba_inst) > 1) {
|
|
|
4694 /* Queuing supported by controller and device */
|
|
|
4695 if ((sata_func_enable & SATA_ENABLE_NCQ) &&
|
|
|
4696 (sdinfo->satadrv_features_support &
|
|
|
4697 SATA_DEV_F_NCQ) &&
|
|
|
4698 (SATA_FEATURES(spx->txlt_sata_hba_inst) &
|
|
|
4699 SATA_CTLF_NCQ)) {
|
|
|
4700 /* NCQ supported - use FPDMA WRITE */
|
|
|
4701 scmd->satacmd_cmd_reg =
|
|
|
4702 SATAC_WRITE_FPDMA_QUEUED;
|
|
|
4703 scmd->satacmd_features_reg_ext =
|
|
|
4704 scmd->satacmd_sec_count_msb;
|
|
|
4705 scmd->satacmd_sec_count_msb = 0;
|
|
|
4706 scmd->satacmd_rle_sata_cmd = NULL;
|
|
|
4707 } else {
|
|
|
4708 /* Legacy queueing */
|
|
|
4709 if (sdinfo->satadrv_features_support &
|
|
|
4710 SATA_DEV_F_LBA48) {
|
|
|
4711 scmd->satacmd_cmd_reg =
|
|
|
4712 SATAC_WRITE_DMA_QUEUED_EXT;
|
|
|
4713 scmd->satacmd_features_reg_ext =
|
|
|
4714 scmd->satacmd_sec_count_msb;
|
|
|
4715 scmd->satacmd_sec_count_msb = 0;
|
|
|
4716 } else {
|
|
|
4717 scmd->satacmd_cmd_reg =
|
|
|
4718 SATAC_WRITE_DMA_QUEUED;
|
|
|
4719 }
|
|
|
4720 }
|
|
|
4721 scmd->satacmd_features_reg =
|
|
|
4722 scmd->satacmd_sec_count_lsb;
|
|
|
4723 scmd->satacmd_sec_count_lsb = 0;
|
|
|
4724 scmd->satacmd_flags |= SATA_QUEUED_CMD;
|
|
|
4725 }
|
|
|
4726 }
|
|
|
4727
|
|
|
4728 SATADBG3(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
4729 "sata_txlt_write cmd 0x%2x, lba %llx, sec count %x\n",
|
|
|
4730 scmd->satacmd_cmd_reg, lba, sec_count);
|
|
|
4731
|
|
|
4732 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
|
|
|
4733 /* Need callback function */
|
|
|
4734 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion;
|
|
|
4735 synch = FALSE;
|
|
|
4736 } else
|
|
|
4737 synch = TRUE;
|
|
|
4738
|
|
|
4739 /* Transfer command to HBA */
|
|
|
4740 if (sata_hba_start(spx, &rval) != 0) {
|
|
|
4741 /* Pkt not accepted for execution */
|
|
|
4742 mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
|
|
|
4743 return (rval);
|
|
|
4744 }
|
|
|
4745 mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
|
|
|
4746
|
|
|
4747 /*
|
|
|
4748 * If execution is non-synchronous,
|
|
|
4749 * a callback function will handle potential errors, translate
|
|
|
4750 * the response and will do a callback to a target driver.
|
|
|
4751 * If it was synchronous, check execution status using the same
|
|
|
4752 * framework callback.
|
|
|
4753 */
|
|
|
4754 if (synch) {
|
|
|
4755 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
4756 "synchronous execution status %x\n",
|
|
|
4757 spx->txlt_sata_pkt->satapkt_reason);
|
|
|
4758 sata_txlt_rw_completion(spx->txlt_sata_pkt);
|
|
|
4759 }
|
|
|
4760 return (TRAN_ACCEPT);
|
|
|
4761 }
|
|
|
4762
|
|
|
4763
|
|
|
4764 /*
|
|
|
4765 * NOTE: NOT FUNCTIONAL IMPLEMENTATION. THIS IS A PLACEHOLDER for the function
|
|
|
4766 * that will be fixed in phase 2 of the development.
|
|
|
4767 * Currently ATAPI is not supported. ATAPI devices are threated as not-valid
|
|
|
4768 * devices.
|
|
|
4769 * This function is not called, since scsi_sata_start() will bail-out prior
|
|
|
4770 * to calling it.
|
|
|
4771 */
|
|
|
4772 static int
|
|
|
4773 sata_txlt_atapi(sata_pkt_txlate_t *spx)
|
|
|
4774 {
|
|
|
4775 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
|
|
|
4776 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
|
|
|
4777 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
|
|
|
4778 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
|
|
|
4779 int cport = SATA_TXLT_CPORT(spx);
|
|
|
4780 int rval;
|
|
|
4781 int synch;
|
|
|
4782 union scsi_cdb *cdbp = (union scsi_cdb *)scsipkt->pkt_cdbp;
|
|
|
4783
|
|
|
4784 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
4785
|
|
|
4786 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) {
|
|
|
4787 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
4788 return (rval);
|
|
|
4789 }
|
|
|
4790
|
|
|
4791 /*
|
|
|
4792 * scmd->satacmd_flags default - SATA_DIR_NODATA_XFER - is set by
|
|
|
4793 * sata_txlt_generic_pkt_info().
|
|
|
4794 */
|
|
|
4795 if (scmd->satacmd_bp) {
|
|
|
4796 if (scmd->satacmd_bp->b_flags & B_READ) {
|
|
|
4797 scmd->satacmd_flags &= ~SATA_XFER_DIR_MASK;
|
|
|
4798 scmd->satacmd_flags |= SATA_DIR_READ;
|
|
|
4799 } else {
|
|
|
4800 scmd->satacmd_flags &= ~SATA_XFER_DIR_MASK;
|
|
|
4801 scmd->satacmd_flags |= SATA_DIR_WRITE;
|
|
|
4802 }
|
|
|
4803 }
|
|
|
4804
|
|
|
4805 scmd->satacmd_acdb_len = scsi_cdb_size[GETGROUP(cdbp)];
|
|
|
4806 scmd->satacmd_cmd_reg = SATAC_PACKET;
|
|
|
4807 bcopy(cdbp, scmd->satacmd_acdb, 16);
|
|
|
4808
|
|
|
4809 /*
|
|
|
4810 * For non-read/write commands we need to
|
|
|
4811 * map buffer
|
|
|
4812 */
|
|
|
4813 switch ((uint_t)scsipkt->pkt_cdbp[0]) {
|
|
|
4814 case SCMD_READ:
|
|
|
4815 case SCMD_READ_G1:
|
|
|
4816 case SCMD_READ_G5:
|
|
|
4817 case SCMD_READ_G4:
|
|
|
4818 case SCMD_WRITE:
|
|
|
4819 case SCMD_WRITE_G1:
|
|
|
4820 case SCMD_WRITE_G5:
|
|
|
4821 case SCMD_WRITE_G4:
|
|
|
4822 break;
|
|
|
4823 default:
|
|
|
4824 if (bp->b_flags & (B_PHYS | B_PAGEIO))
|
|
|
4825 bp_mapin(bp);
|
|
|
4826 break;
|
|
|
4827 }
|
|
|
4828
|
|
|
4829 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
|
|
|
4830 /* Need callback function */
|
|
|
4831 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_atapi_completion;
|
|
|
4832 synch = FALSE;
|
|
|
4833 } else
|
|
|
4834 synch = TRUE;
|
|
|
4835
|
|
|
4836 /* Transfer command to HBA */
|
|
|
4837 if (sata_hba_start(spx, &rval) != 0) {
|
|
|
4838 /* Pkt not accepted for execution */
|
|
|
4839 mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
|
|
|
4840 return (rval);
|
|
|
4841 }
|
|
|
4842 mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
|
|
|
4843 /*
|
|
|
4844 * If execution is non-synchronous,
|
|
|
4845 * a callback function will handle potential errors, translate
|
|
|
4846 * the response and will do a callback to a target driver.
|
|
|
4847 * If it was synchronous, check execution status using the same
|
|
|
4848 * framework callback.
|
|
|
4849 */
|
|
|
4850 if (synch) {
|
|
|
4851 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
4852 "synchronous execution status %x\n",
|
|
|
4853 spx->txlt_sata_pkt->satapkt_reason);
|
|
|
4854 sata_txlt_atapi_completion(spx->txlt_sata_pkt);
|
|
|
4855 }
|
|
|
4856 return (TRAN_ACCEPT);
|
|
|
4857 }
|
|
|
4858
|
|
|
4859 /*
|
|
|
4860 * Translate command: Synchronize Cache.
|
|
|
4861 * Translates into Flush Cache command.
|
|
|
4862 * (NO ATAPI implementation yet).
|
|
|
4863 *
|
|
|
4864 * NOTE: We should check if Flush Cache is supported by the device (ATAPI
|
|
|
4865 * devices)
|
|
|
4866 *
|
|
|
4867 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
|
|
|
4868 * appropriate values in scsi_pkt fields.
|
|
|
4869 */
|
|
|
4870 static int
|
|
|
4871 sata_txlt_synchronize_cache(sata_pkt_txlate_t *spx)
|
|
|
4872 {
|
|
|
4873 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
|
|
|
4874 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
|
|
|
4875 int cport = SATA_TXLT_CPORT(spx);
|
|
|
4876 int rval;
|
|
|
4877 int synch;
|
|
|
4878
|
|
|
4879 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
4880
|
|
|
4881 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) {
|
|
|
4882 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx)));
|
|
|
4883 return (rval);
|
|
|
4884 }
|
|
|
4885
|
|
|
4886 scmd->satacmd_addr_type = 0;
|
|
|
4887 scmd->satacmd_cmd_reg = SATAC_FLUSH_CACHE;
|
|
|
4888 scmd->satacmd_device_reg = 0;
|
|
|
4889 scmd->satacmd_sec_count_lsb = 0;
|
|
|
4890 scmd->satacmd_lba_low_lsb = 0;
|
|
|
4891 scmd->satacmd_lba_mid_lsb = 0;
|
|
|
4892 scmd->satacmd_lba_high_lsb = 0;
|
|
|
4893 scmd->satacmd_features_reg = 0;
|
|
|
4894 scmd->satacmd_status_reg = 0;
|
|
|
4895 scmd->satacmd_error_reg = 0;
|
|
|
4896
|
|
|
4897 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
4898 "sata_txlt_synchronize_cache\n", NULL);
|
|
|
4899
|
|
|
4900 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
|
|
|
4901 /* Need to set-up a callback function */
|
|
|
4902 spx->txlt_sata_pkt->satapkt_comp =
|
|
|
4903 sata_txlt_nodata_cmd_completion;
|
|
|
4904 synch = FALSE;
|
|
|
4905 } else
|
|
|
4906 synch = TRUE;
|
|
|
4907
|
|
|
4908 /* Transfer command to HBA */
|
|
|
4909 if (sata_hba_start(spx, &rval) != 0) {
|
|
|
4910 /* Pkt not accepted for execution */
|
|
|
4911 mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
|
|
|
4912 return (rval);
|
|
|
4913 }
|
|
|
4914 mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
|
|
|
4915
|
|
|
4916 /*
|
|
|
4917 * If execution non-synchronous, it had to be completed
|
|
|
4918 * a callback function will handle potential errors, translate
|
|
|
4919 * the response and will do a callback to a target driver.
|
|
|
4920 * If it was synchronous, check status, using the same
|
|
|
4921 * framework callback.
|
|
|
4922 */
|
|
|
4923 if (synch) {
|
|
|
4924 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
4925 "synchronous execution status %x\n",
|
|
|
4926 spx->txlt_sata_pkt->satapkt_reason);
|
|
|
4927 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt);
|
|
|
4928 }
|
|
|
4929 return (TRAN_ACCEPT);
|
|
|
4930 }
|
|
|
4931
|
|
|
4932
|
|
|
4933 /*
|
|
|
4934 * Send pkt to SATA HBA driver
|
|
|
4935 *
|
|
|
4936 * This function may be called only if the operation is requested by scsi_pkt,
|
|
|
4937 * i.e. scsi_pkt is not NULL.
|
|
|
4938 *
|
|
|
4939 * This function has to be called with cport mutex held. It does release
|
|
|
4940 * the mutex when it calls HBA driver sata_tran_start function and
|
|
|
4941 * re-acquires it afterwards.
|
|
|
4942 *
|
|
|
4943 * If return value is 0, pkt was accepted, -1 otherwise
|
|
|
4944 * rval is set to appropriate sata_scsi_start return value.
|
|
|
4945 *
|
|
|
4946 * Note 1:If HBA driver returns value other than TRAN_ACCEPT, it should not
|
|
|
4947 * have called the sata_pkt callback function for this packet.
|
|
|
4948 *
|
|
|
4949 * The scsi callback has to be performed by the caller of this routine.
|
|
|
4950 *
|
|
|
4951 * Note 2: No port multiplier support for now.
|
|
|
4952 */
|
|
|
4953 static int
|
|
|
4954 sata_hba_start(sata_pkt_txlate_t *spx, int *rval)
|
|
|
4955 {
|
|
|
4956 int stat;
|
|
|
4957 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst;
|
|
|
4958 sata_drive_info_t *sdinfo;
|
|
|
4959 sata_device_t sata_device;
|
|
|
4960 uint8_t cmd;
|
|
|
4961 uint32_t cmd_flags;
|
|
|
4962
|
|
|
4963 ASSERT(spx->txlt_sata_pkt != NULL);
|
|
|
4964 ASSERT(mutex_owned(&SATA_CPORT_MUTEX(spx->txlt_sata_hba_inst,
|
|
|
4965 spx->txlt_sata_pkt->satapkt_device.satadev_addr.cport)));
|
|
|
4966
|
|
|
4967 sdinfo = sata_get_device_info(sata_hba_inst,
|
|
|
4968 &spx->txlt_sata_pkt->satapkt_device);
|
|
|
4969 ASSERT(sdinfo != NULL);
|
|
|
4970
|
|
|
4971 /* Clear device reset state? */
|
|
|
4972 if (sdinfo->satadrv_event_flags & SATA_EVNT_CLEAR_DEVICE_RESET) {
|
|
|
4973 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags |=
|
|
|
4974 SATA_CLEAR_DEV_RESET_STATE;
|
|
|
4975 sdinfo->satadrv_event_flags &= ~SATA_EVNT_CLEAR_DEVICE_RESET;
|
|
|
4976 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
|
|
|
4977 "sata_hba_start: clearing device reset state\n", NULL);
|
|
|
4978 }
|
|
|
4979 cmd = spx->txlt_sata_pkt->satapkt_cmd.satacmd_cmd_reg;
|
|
|
4980 cmd_flags = spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags;
|
|
|
4981 sata_device = spx->txlt_sata_pkt->satapkt_device; /* local copy */
|
|
|
4982
|
|
|
4983 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
4984 sdinfo->satadrv_addr.cport)));
|
|
|
4985
|
|
|
4986 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
4987 "Sata cmd 0x%2x\n", cmd);
|
|
|
4988
|
|
|
4989 stat = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
|
|
|
4990 spx->txlt_sata_pkt);
|
|
|
4991
|
|
|
4992 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
4993 sdinfo->satadrv_addr.cport)));
|
|
|
4994 /*
|
|
|
4995 * If sata pkt was accepted and executed in asynchronous mode, i.e.
|
|
|
4996 * with the sata callback, the sata_pkt could be already destroyed
|
|
|
4997 * by the time we check ther return status from the hba_start()
|
|
|
4998 * function, because sata_scsi_destroy_pkt() could have been already
|
|
|
4999 * called (perhaps in the interrupt context). So, in such case, there
|
|
|
5000 * should be no references to it. In other cases, sata_pkt still
|
|
|
5001 * exists.
|
|
|
5002 */
|
|
|
5003 switch (stat) {
|
|
|
5004 case SATA_TRAN_ACCEPTED:
|
|
|
5005 /*
|
|
|
5006 * pkt accepted for execution.
|
|
|
5007 * If it was executed synchronously, it is already completed
|
|
|
5008 * and pkt completion_reason indicates completion status.
|
|
|
5009 */
|
|
|
5010 *rval = TRAN_ACCEPT;
|
|
|
5011 return (0);
|
|
|
5012
|
|
|
5013 case SATA_TRAN_QUEUE_FULL:
|
|
|
5014 /*
|
|
|
5015 * Controller detected queue full condition.
|
|
|
5016 */
|
|
|
5017 SATADBG1(SATA_DBG_HBA_IF, sata_hba_inst,
|
|
|
5018 "sata_hba_start: queue full\n", NULL);
|
|
|
5019
|
|
|
5020 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
|
|
|
5021 *spx->txlt_scsi_pkt->pkt_scbp = STATUS_QFULL;
|
|
|
5022
|
|
|
5023 *rval = TRAN_BUSY;
|
|
|
5024 break;
|
|
|
5025
|
|
|
5026 case SATA_TRAN_PORT_ERROR:
|
|
|
5027 /*
|
|
|
5028 * Communication/link with device or general port error
|
|
|
5029 * detected before pkt execution begun.
|
|
|
5030 */
|
|
|
5031 if (spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual ==
|
|
|
5032 SATA_ADDR_CPORT)
|
|
|
5033 sata_log(sata_hba_inst, CE_CONT,
|
|
|
5034 "port %d error",
|
|
|
5035 sata_device.satadev_addr.cport);
|
|
|
5036 else
|
|
|
5037 sata_log(sata_hba_inst, CE_CONT,
|
|
|
5038 "port %d pmport %d error\n",
|
|
|
5039 sata_device.satadev_addr.cport,
|
|
|
5040 sata_device.satadev_addr.pmport);
|
|
|
5041
|
|
|
5042 /*
|
|
|
5043 * Update the port/device structure.
|
|
|
5044 * sata_pkt should be still valid. Since port error is
|
|
|
5045 * returned, sata_device content should reflect port
|
|
|
5046 * state - it means, that sata address have been changed,
|
|
|
5047 * because original packet's sata address refered to a device
|
|
|
5048 * attached to some port.
|
|
|
5049 */
|
|
|
5050 sata_update_port_info(sata_hba_inst, &sata_device);
|
|
|
5051 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
|
|
|
5052 *rval = TRAN_FATAL_ERROR;
|
|
|
5053 break;
|
|
|
5054
|
|
|
5055 case SATA_TRAN_CMD_UNSUPPORTED:
|
|
|
5056 /*
|
|
|
5057 * Command rejected by HBA as unsupported. It was HBA driver
|
|
|
5058 * that rejected the command, command was not sent to
|
|
|
5059 * an attached device.
|
|
|
5060 */
|
|
|
5061 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
5062 sdinfo->satadrv_addr.cport)));
|
|
|
5063 (void) sata_txlt_invalid_command(spx);
|
|
|
5064 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
5065 sdinfo->satadrv_addr.cport)));
|
|
|
5066
|
|
|
5067 if (sdinfo->satadrv_state & SATA_DSTATE_RESET)
|
|
|
5068 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
|
|
|
5069 "sat_hba_start: cmd 0x%2x rejected "
|
|
|
5070 "with SATA_TRAN_CMD_UNSUPPORTED status\n", cmd);
|
|
|
5071
|
|
|
5072 *rval = TRAN_ACCEPT;
|
|
|
5073 break;
|
|
|
5074
|
|
|
5075 case SATA_TRAN_BUSY:
|
|
|
5076 /*
|
|
|
5077 * Command rejected by HBA because other operation prevents
|
|
|
5078 * accepting the packet, or device is in RESET condition.
|
|
|
5079 */
|
|
|
5080 if (sdinfo != NULL) {
|
|
|
5081 sdinfo->satadrv_state =
|
|
|
5082 spx->txlt_sata_pkt->satapkt_device.satadev_state;
|
|
|
5083
|
|
|
5084 if (sdinfo->satadrv_state & SATA_DSTATE_RESET) {
|
|
|
5085 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
|
|
|
5086 "sata_hba_start: cmd 0x%2x rejected "
|
|
|
5087 "because of device reset condition\n",
|
|
|
5088 cmd);
|
|
|
5089 } else {
|
|
|
5090 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
|
|
|
5091 "sata_hba_start: cmd 0x%2x rejected "
|
|
|
5092 "with SATA_TRAN_BUSY status\n",
|
|
|
5093 cmd);
|
|
|
5094 }
|
|
|
5095 }
|
|
|
5096 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
|
|
|
5097 *rval = TRAN_BUSY;
|
|
|
5098 break;
|
|
|
5099
|
|
|
5100 default:
|
|
|
5101 /* Unrecognized HBA response */
|
|
|
5102 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
5103 "sata_hba_start: unrecognized HBA response "
|
|
|
5104 "to cmd : 0x%2x resp 0x%x", cmd, rval));
|
|
|
5105 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
|
|
|
5106 *rval = TRAN_FATAL_ERROR;
|
|
|
5107 break;
|
|
|
5108 }
|
|
|
5109
|
|
|
5110 /*
|
|
|
5111 * If we got here, the packet was rejected.
|
|
|
5112 * Check if we need to remember reset state clearing request
|
|
|
5113 */
|
|
|
5114 if (cmd_flags & SATA_CLEAR_DEV_RESET_STATE) {
|
|
|
5115 /*
|
|
|
5116 * Check if device is still configured - it may have
|
|
|
5117 * disapeared from the configuration
|
|
|
5118 */
|
|
|
5119 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
|
|
|
5120 if (sdinfo != NULL) {
|
|
|
5121 /*
|
|
|
5122 * Restore the flag that requests clearing of
|
|
|
5123 * the device reset state,
|
|
|
5124 * so the next sata packet may carry it to HBA.
|
|
|
5125 */
|
|
|
5126 sdinfo->satadrv_event_flags |=
|
|
|
5127 SATA_EVNT_CLEAR_DEVICE_RESET;
|
|
|
5128 }
|
|
|
5129 }
|
|
|
5130 return (-1);
|
|
|
5131 }
|
|
|
5132
|
|
|
5133 /*
|
|
|
5134 * Scsi response setup for invalid LBA
|
|
|
5135 *
|
|
|
5136 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
|
|
|
5137 */
|
|
|
5138 static int
|
|
|
5139 sata_txlt_lba_out_of_range(sata_pkt_txlate_t *spx)
|
|
|
5140 {
|
|
|
5141 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
|
|
|
5142 struct scsi_extended_sense *sense;
|
|
|
5143
|
|
|
5144 scsipkt->pkt_reason = CMD_CMPLT;
|
|
|
5145 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
|
|
|
5146 STATE_SENT_CMD | STATE_GOT_STATUS;
|
|
|
5147 *scsipkt->pkt_scbp = STATUS_CHECK;
|
|
|
5148
|
|
|
5149 *scsipkt->pkt_scbp = STATUS_CHECK;
|
|
|
5150 sense = sata_arq_sense(spx);
|
|
|
5151 sense->es_key = KEY_ILLEGAL_REQUEST;
|
|
|
5152 sense->es_add_code = SD_SCSI_LBA_OUT_OF_RANGE;
|
|
|
5153
|
|
|
5154 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
5155 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
|
|
|
5156
|
|
|
5157 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
|
|
|
5158 scsipkt->pkt_comp != NULL)
|
|
|
5159 /* scsi callback required */
|
|
|
5160 (*scsipkt->pkt_comp)(scsipkt);
|
|
|
5161 return (TRAN_ACCEPT);
|
|
|
5162 }
|
|
|
5163
|
|
|
5164
|
|
|
5165 /*
|
|
|
5166 * Analyze device status and error registers and translate them into
|
|
|
5167 * appropriate scsi sense codes.
|
|
|
5168 * NOTE: non-packet commands only for now
|
|
|
5169 */
|
|
|
5170 static void
|
|
|
5171 sata_decode_device_error(sata_pkt_txlate_t *spx,
|
|
|
5172 struct scsi_extended_sense *sense)
|
|
|
5173 {
|
|
|
5174 uint8_t err_reg = spx->txlt_sata_pkt->satapkt_cmd.satacmd_error_reg;
|
|
|
5175
|
|
|
5176 ASSERT(sense != NULL);
|
|
|
5177 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg &
|
|
|
5178 SATA_STATUS_ERR);
|
|
|
5179
|
|
|
5180
|
|
|
5181 if (err_reg & SATA_ERROR_ICRC) {
|
|
|
5182 sense->es_key = KEY_ABORTED_COMMAND;
|
|
|
5183 sense->es_add_code = 0x08; /* Communication failure */
|
|
|
5184 return;
|
|
|
5185 }
|
|
|
5186
|
|
|
5187 if (err_reg & SATA_ERROR_UNC) {
|
|
|
5188 sense->es_key = KEY_MEDIUM_ERROR;
|
|
|
5189 /* Information bytes (LBA) need to be set by a caller */
|
|
|
5190 return;
|
|
|
5191 }
|
|
|
5192
|
|
|
5193 /* ADD HERE: MC error bit handling for ATAPI CD/DVD */
|
|
|
5194 if (err_reg & (SATA_ERROR_MCR | SATA_ERROR_NM)) {
|
|
|
5195 sense->es_key = KEY_UNIT_ATTENTION;
|
|
|
5196 sense->es_add_code = 0x3a; /* No media present */
|
|
|
5197 return;
|
|
|
5198 }
|
|
|
5199
|
|
|
5200 if (err_reg & SATA_ERROR_IDNF) {
|
|
|
5201 if (err_reg & SATA_ERROR_ABORT) {
|
|
|
5202 sense->es_key = KEY_ABORTED_COMMAND;
|
|
|
5203 } else {
|
|
|
5204 sense->es_key = KEY_ILLEGAL_REQUEST;
|
|
|
5205 sense->es_add_code = 0x21; /* LBA out of range */
|
|
|
5206 }
|
|
|
5207 return;
|
|
|
5208 }
|
|
|
5209
|
|
|
5210 if (err_reg & SATA_ERROR_ABORT) {
|
|
|
5211 ASSERT(spx->txlt_sata_pkt != NULL);
|
|
|
5212 sense->es_key = KEY_ABORTED_COMMAND;
|
|
|
5213 return;
|
|
|
5214 }
|
|
|
5215 }
|
|
|
5216
|
|
|
5217 /*
|
|
|
5218 * Extract error LBA from sata_pkt.satapkt_cmd register fields
|
|
|
5219 */
|
|
|
5220 static void
|
|
|
5221 sata_extract_error_lba(sata_pkt_txlate_t *spx, uint64_t *lba)
|
|
|
5222 {
|
|
|
5223 sata_cmd_t *sata_cmd = &spx->txlt_sata_pkt->satapkt_cmd;
|
|
|
5224
|
|
|
5225 *lba = 0;
|
|
|
5226 if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA48) {
|
|
|
5227 *lba = sata_cmd->satacmd_lba_high_msb;
|
|
|
5228 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_msb;
|
|
|
5229 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_msb;
|
|
|
5230 } else if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA28) {
|
|
|
5231 *lba = sata_cmd->satacmd_device_reg & 0xf;
|
|
|
5232 }
|
|
|
5233 *lba = (*lba << 8) | sata_cmd->satacmd_lba_high_lsb;
|
|
|
5234 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_lsb;
|
|
|
5235 *lba = (*lba << 8) | sata_cmd->satacmd_lba_high_lsb;
|
|
|
5236 }
|
|
|
5237
|
|
|
5238 /*
|
|
|
5239 * This is fixed sense format - if LBA exceeds the info field size,
|
|
|
5240 * no valid info will be returned (valid bit in extended sense will
|
|
|
5241 * be set to 0).
|
|
|
5242 */
|
|
|
5243 static struct scsi_extended_sense *
|
|
|
5244 sata_arq_sense(sata_pkt_txlate_t *spx)
|
|
|
5245 {
|
|
|
5246 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
|
|
|
5247 struct scsi_arq_status *arqs;
|
|
|
5248 struct scsi_extended_sense *sense;
|
|
|
5249
|
|
|
5250 /* Fill ARQ sense data */
|
|
|
5251 scsipkt->pkt_state |= STATE_ARQ_DONE;
|
|
|
5252 arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp;
|
|
|
5253 *(uchar_t *)&arqs->sts_status = STATUS_CHECK;
|
|
|
5254 *(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD;
|
|
|
5255 arqs->sts_rqpkt_reason = CMD_CMPLT;
|
|
|
5256 arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
|
|
|
5257 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS;
|
|
|
5258 arqs->sts_rqpkt_resid = 0;
|
|
|
5259 sense = &arqs->sts_sensedata;
|
|
|
5260 bzero(sense, sizeof (struct scsi_extended_sense));
|
|
|
5261 sense->es_valid = 1; /* Valid sense */
|
|
|
5262 sense->es_class = 7; /* Response code 0x70 - current err */
|
|
|
5263 sense->es_key = KEY_NO_SENSE;
|
|
|
5264 sense->es_info_1 = 0;
|
|
|
5265 sense->es_info_2 = 0;
|
|
|
5266 sense->es_info_3 = 0;
|
|
|
5267 sense->es_info_4 = 0;
|
|
|
5268 sense->es_add_len = 6; /* Additional length */
|
|
|
5269 sense->es_cmd_info[0] = 0;
|
|
|
5270 sense->es_cmd_info[1] = 0;
|
|
|
5271 sense->es_cmd_info[2] = 0;
|
|
|
5272 sense->es_cmd_info[3] = 0;
|
|
|
5273 sense->es_add_code = 0;
|
|
|
5274 sense->es_qual_code = 0;
|
|
|
5275 return (sense);
|
|
|
5276 }
|
|
|
5277
|
|
|
5278
|
|
|
5279 /*
|
|
|
5280 * Translate completion status of SATA read/write commands into scsi response.
|
|
|
5281 * pkt completion_reason is checked to determine the completion status.
|
|
|
5282 * Do scsi callback if necessary.
|
|
|
5283 *
|
|
|
5284 * Note: this function may be called also for synchronously executed
|
|
|
5285 * commands.
|
|
|
5286 * This function may be used only if scsi_pkt is non-NULL.
|
|
|
5287 */
|
|
|
5288 static void
|
|
|
5289 sata_txlt_rw_completion(sata_pkt_t *sata_pkt)
|
|
|
5290 {
|
|
|
5291 sata_pkt_txlate_t *spx =
|
|
|
5292 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
|
|
|
5293 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
|
|
|
5294 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
|
|
|
5295 struct scsi_extended_sense *sense;
|
|
|
5296 uint64_t lba;
|
|
|
5297
|
|
|
5298 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
|
|
|
5299 /* Normal completion */
|
|
|
5300 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
|
|
|
5301 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
|
|
|
5302 scsipkt->pkt_reason = CMD_CMPLT;
|
|
|
5303 *scsipkt->pkt_scbp = STATUS_GOOD;
|
|
|
5304 } else {
|
|
|
5305 /*
|
|
|
5306 * Something went wrong - analyze return
|
|
|
5307 */
|
|
|
5308 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
|
|
|
5309 STATE_SENT_CMD | STATE_GOT_STATUS;
|
|
|
5310 scsipkt->pkt_reason = CMD_INCOMPLETE;
|
|
|
5311 *scsipkt->pkt_scbp = STATUS_CHECK;
|
|
|
5312 sense = sata_arq_sense(spx);
|
|
|
5313 ASSERT(sense != NULL);
|
|
|
5314
|
|
|
5315 /*
|
|
|
5316 * SATA_PKT_DEV_ERROR is the only case where we may be able to
|
|
|
5317 * extract form device registers the failing LBA.
|
|
|
5318 */
|
|
|
5319 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
|
|
|
5320 if ((scmd->satacmd_addr_type == ATA_ADDR_LBA48) &&
|
|
|
5321 (scmd->satacmd_lba_mid_msb != 0 ||
|
|
|
5322 scmd->satacmd_lba_high_msb != 0)) {
|
|
|
5323 /*
|
|
|
5324 * We have problem reporting this cmd LBA
|
|
|
5325 * in fixed sense data format, because of
|
|
|
5326 * the size of the scsi LBA fields.
|
|
|
5327 */
|
|
|
5328 sense->es_valid = 0;
|
|
|
5329 } else {
|
|
|
5330 sata_extract_error_lba(spx, &lba);
|
|
|
5331 sense->es_info_1 = (lba & 0xFF000000) >> 24;
|
|
|
5332 sense->es_info_1 = (lba & 0xFF0000) >> 16;
|
|
|
5333 sense->es_info_1 = (lba & 0xFF00) >> 8;
|
|
|
5334 sense->es_info_1 = lba & 0xFF;
|
|
|
5335 }
|
|
|
5336 } else {
|
|
|
5337 /* Invalid extended sense info */
|
|
|
5338 sense->es_valid = 0;
|
|
|
5339 }
|
|
|
5340
|
|
|
5341 switch (sata_pkt->satapkt_reason) {
|
|
|
5342 case SATA_PKT_PORT_ERROR:
|
|
|
5343 /* We may want to handle DEV GONE state as well */
|
|
|
5344 /*
|
|
|
5345 * We have no device data. Assume no data transfered.
|
|
|
5346 */
|
|
|
5347 sense->es_key = KEY_HARDWARE_ERROR;
|
|
|
5348 break;
|
|
|
5349
|
|
|
5350 case SATA_PKT_DEV_ERROR:
|
|
|
5351 if (sata_pkt->satapkt_cmd.satacmd_status_reg &
|
|
|
5352 SATA_STATUS_ERR) {
|
|
|
5353 /*
|
|
|
5354 * determine dev error reason from error
|
|
|
5355 * reg content
|
|
|
5356 */
|
|
|
5357 sata_decode_device_error(spx, sense);
|
|
|
5358 if (sense->es_key == KEY_MEDIUM_ERROR) {
|
|
|
5359 switch (scmd->satacmd_cmd_reg) {
|
|
|
5360 case SATAC_READ_DMA:
|
|
|
5361 case SATAC_READ_DMA_EXT:
|
|
|
5362 case SATAC_READ_DMA_QUEUED:
|
|
|
5363 case SATAC_READ_DMA_QUEUED_EXT:
|
|
|
5364 case SATAC_READ_FPDMA_QUEUED:
|
|
|
5365 /* Unrecovered read error */
|
|
|
5366 sense->es_add_code =
|
|
|
5367 SD_SCSI_UNREC_READ_ERROR;
|
|
|
5368 break;
|
|
|
5369 case SATAC_WRITE_DMA:
|
|
|
5370 case SATAC_WRITE_DMA_EXT:
|
|
|
5371 case SATAC_WRITE_DMA_QUEUED:
|
|
|
5372 case SATAC_WRITE_DMA_QUEUED_EXT:
|
|
|
5373 case SATAC_WRITE_FPDMA_QUEUED:
|
|
|
5374 /* Write error */
|
|
|
5375 sense->es_add_code =
|
|
|
5376 SD_SCSI_WRITE_ERROR;
|
|
|
5377 break;
|
|
|
5378 default:
|
|
|
5379 /* Internal error */
|
|
|
5380 SATA_LOG_D((
|
|
|
5381 spx->txlt_sata_hba_inst,
|
|
|
5382 CE_WARN,
|
|
|
5383 "sata_txlt_rw_completion :"
|
|
|
5384 "internal error - invalid "
|
|
|
5385 "command 0x%2x",
|
|
|
5386 scmd->satacmd_cmd_reg));
|
|
|
5387 break;
|
|
|
5388 }
|
|
|
5389 }
|
|
|
5390 break;
|
|
|
5391 }
|
|
|
5392 /* No extended sense key - no info available */
|
|
|
5393 scsipkt->pkt_reason = CMD_INCOMPLETE;
|
|
|
5394 break;
|
|
|
5395
|
|
|
5396 case SATA_PKT_TIMEOUT:
|
|
|
5397 /* scsipkt->pkt_reason = CMD_TIMEOUT; */
|
|
|
5398 scsipkt->pkt_reason = CMD_INCOMPLETE;
|
|
|
5399 /* No extended sense key ? */
|
|
|
5400 break;
|
|
|
5401
|
|
|
5402 case SATA_PKT_ABORTED:
|
|
|
5403 scsipkt->pkt_reason = CMD_ABORTED;
|
|
|
5404 /* No extended sense key ? */
|
|
|
5405 break;
|
|
|
5406
|
|
|
5407 case SATA_PKT_RESET:
|
|
|
5408 scsipkt->pkt_reason = CMD_RESET;
|
|
|
5409 break;
|
|
|
5410
|
|
|
5411 default:
|
|
|
5412 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
|
|
|
5413 "sata_txlt_rw_completion: "
|
|
|
5414 "invalid packet completion reason"));
|
|
|
5415 scsipkt->pkt_reason = CMD_TRAN_ERR;
|
|
|
5416 break;
|
|
|
5417 }
|
|
|
5418 }
|
|
|
5419 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
5420 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
|
|
|
5421
|
|
|
5422 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
|
|
|
5423 scsipkt->pkt_comp != NULL)
|
|
|
5424 /* scsi callback required */
|
|
|
5425 (*scsipkt->pkt_comp)(scsipkt);
|
|
|
5426
|
|
|
5427 }
|
|
|
5428
|
|
|
5429 /*
|
|
|
5430 * NON FUNCTIONAL IMPLEMENTATION. THIS IS A PLACE HOLDER.
|
|
|
5431 * ATAPI devices are not supported currently (are not be attached recognized
|
|
|
5432 * as valid devices).
|
|
|
5433 * Will be fixed in phase 2 of the development.
|
|
|
5434 */
|
|
|
5435 static void
|
|
|
5436 sata_txlt_atapi_completion(sata_pkt_t *sata_pkt)
|
|
|
5437 {
|
|
|
5438 sata_pkt_txlate_t *spx =
|
|
|
5439 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
|
|
|
5440 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
|
|
|
5441 struct scsi_arq_status *arqs;
|
|
|
5442
|
|
|
5443 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
|
|
|
5444 /* Normal completion */
|
|
|
5445 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
|
|
|
5446 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
|
|
|
5447 scsipkt->pkt_reason = CMD_CMPLT;
|
|
|
5448 *scsipkt->pkt_scbp = STATUS_GOOD;
|
|
|
5449 scsipkt->pkt_resid = 0;
|
|
|
5450 } else {
|
|
|
5451 /*
|
|
|
5452 * Something went wrong - analyze return
|
|
|
5453 */
|
|
|
5454 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
|
|
|
5455 STATE_SENT_CMD | STATE_GOT_STATUS | STATE_ARQ_DONE;
|
|
|
5456 scsipkt->pkt_reason = CMD_CMPLT;
|
|
|
5457
|
|
|
5458 arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp;
|
|
|
5459 *(uchar_t *)&arqs->sts_status = STATUS_CHECK;
|
|
|
5460 *(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD;
|
|
|
5461 arqs->sts_rqpkt_reason = CMD_CMPLT;
|
|
|
5462 arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
|
|
|
5463 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS;
|
|
|
5464 arqs->sts_rqpkt_resid = 0;
|
|
|
5465
|
|
|
5466 bcopy(sata_pkt->satapkt_cmd.satacmd_rqsense,
|
|
|
5467 &arqs->sts_sensedata, SATA_ATAPI_RQSENSE_LEN);
|
|
|
5468 }
|
|
|
5469 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
5470 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
|
|
|
5471
|
|
|
5472 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
|
|
|
5473 scsipkt->pkt_comp != NULL) {
|
|
|
5474 /* scsi callback required */
|
|
|
5475 (*scsipkt->pkt_comp)(scsipkt);
|
|
|
5476 }
|
|
|
5477 }
|
|
|
5478
|
|
|
5479
|
|
|
5480 /*
|
|
|
5481 * Translate completion status of non-data commands (i.e. commands returning
|
|
|
5482 * no data).
|
|
|
5483 * pkt completion_reason is checked to determine the completion status.
|
|
|
5484 * Do scsi callback if necessary (FLAG_NOINTR == 0)
|
|
|
5485 *
|
|
|
5486 * Note: this function may be called also for synchronously executed
|
|
|
5487 * commands.
|
|
|
5488 * This function may be used only if scsi_pkt is non-NULL.
|
|
|
5489 */
|
|
|
5490
|
|
|
5491 static void
|
|
|
5492 sata_txlt_nodata_cmd_completion(sata_pkt_t *sata_pkt)
|
|
|
5493 {
|
|
|
5494 sata_pkt_txlate_t *spx =
|
|
|
5495 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
|
|
|
5496 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
|
|
|
5497 struct scsi_extended_sense *sense;
|
|
|
5498
|
|
|
5499 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
|
|
|
5500 STATE_SENT_CMD | STATE_GOT_STATUS;
|
|
|
5501 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
|
|
|
5502 /* Normal completion */
|
|
|
5503 scsipkt->pkt_reason = CMD_CMPLT;
|
|
|
5504 *scsipkt->pkt_scbp = STATUS_GOOD;
|
|
|
5505 } else {
|
|
|
5506 /* Something went wrong */
|
|
|
5507 scsipkt->pkt_reason = CMD_INCOMPLETE;
|
|
|
5508 *scsipkt->pkt_scbp = STATUS_CHECK;
|
|
|
5509 sense = sata_arq_sense(spx);
|
|
|
5510 switch (sata_pkt->satapkt_reason) {
|
|
|
5511 case SATA_PKT_PORT_ERROR:
|
|
|
5512 /*
|
|
|
5513 * We have no device data. Assume no data transfered.
|
|
|
5514 */
|
|
|
5515 sense->es_key = KEY_HARDWARE_ERROR;
|
|
|
5516 break;
|
|
|
5517
|
|
|
5518 case SATA_PKT_DEV_ERROR:
|
|
|
5519 if (sata_pkt->satapkt_cmd.satacmd_status_reg &
|
|
|
5520 SATA_STATUS_ERR) {
|
|
|
5521 /*
|
|
|
5522 * determine dev error reason from error
|
|
|
5523 * reg content
|
|
|
5524 */
|
|
|
5525 sata_decode_device_error(spx, sense);
|
|
|
5526 break;
|
|
|
5527 }
|
|
|
5528 /* No extended sense key - no info available */
|
|
|
5529 break;
|
|
|
5530
|
|
|
5531 case SATA_PKT_TIMEOUT:
|
|
|
5532 /* scsipkt->pkt_reason = CMD_TIMEOUT; */
|
|
|
5533 scsipkt->pkt_reason = CMD_INCOMPLETE;
|
|
|
5534 /* No extended sense key ? */
|
|
|
5535 break;
|
|
|
5536
|
|
|
5537 case SATA_PKT_ABORTED:
|
|
|
5538 scsipkt->pkt_reason = CMD_ABORTED;
|
|
|
5539 /* No extended sense key ? */
|
|
|
5540 break;
|
|
|
5541
|
|
|
5542 case SATA_PKT_RESET:
|
|
|
5543 /* pkt aborted by an explicit reset from a host */
|
|
|
5544 scsipkt->pkt_reason = CMD_RESET;
|
|
|
5545 break;
|
|
|
5546
|
|
|
5547 default:
|
|
|
5548 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
|
|
|
5549 "sata_txlt_nodata_cmd_completion: "
|
|
|
5550 "invalid packet completion reason %d",
|
|
|
5551 sata_pkt->satapkt_reason));
|
|
|
5552 scsipkt->pkt_reason = CMD_TRAN_ERR;
|
|
|
5553 break;
|
|
|
5554 }
|
|
|
5555
|
|
|
5556 }
|
|
|
5557 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
|
|
|
5558 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
|
|
|
5559
|
|
|
5560 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
|
|
|
5561 scsipkt->pkt_comp != NULL)
|
|
|
5562 /* scsi callback required */
|
|
|
5563 (*scsipkt->pkt_comp)(scsipkt);
|
|
|
5564 }
|
|
|
5565
|
|
|
5566
|
|
|
5567 /*
|
|
|
5568 * Build Mode sense R/W recovery page
|
|
|
5569 * NOT IMPLEMENTED
|
|
|
5570 */
|
|
|
5571
|
|
|
5572 static int
|
|
|
5573 sata_build_msense_page_1(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
|
|
|
5574 {
|
|
|
5575 #ifndef __lock_lint
|
|
|
5576 _NOTE(ARGUNUSED(sdinfo))
|
|
|
5577 _NOTE(ARGUNUSED(pcntrl))
|
|
|
5578 _NOTE(ARGUNUSED(buf))
|
|
|
5579 #endif
|
|
|
5580 return (0);
|
|
|
5581 }
|
|
|
5582
|
|
|
5583 /*
|
|
|
5584 * Build Mode sense caching page - scsi-3 implementation.
|
|
|
5585 * Page length distinguishes previous format from scsi-3 format.
|
|
|
5586 * buf must have space for 0x12 bytes.
|
|
|
5587 * Only DRA (disable read ahead ) and WCE (write cache enable) are changeable.
|
|
|
5588 *
|
|
|
5589 */
|
|
|
5590 static int
|
|
|
5591 sata_build_msense_page_8(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
|
|
|
5592 {
|
|
|
5593 struct mode_cache_scsi3 *page = (struct mode_cache_scsi3 *)buf;
|
|
|
5594 sata_id_t *sata_id = &sdinfo->satadrv_id;
|
|
|
5595
|
|
|
5596 /*
|
|
|
5597 * Most of the fields are set to 0, being not supported and/or disabled
|
|
|
5598 */
|
|
|
5599 bzero(buf, PAGELENGTH_DAD_MODE_CACHE_SCSI3);
|
|
|
5600
|
|
|
5601 if (pcntrl == 0 || pcntrl == 2) {
|
|
|
5602 /*
|
|
|
5603 * For now treat current and default parameters as same
|
|
|
5604 * That may have to change, if target driver will complain
|
|
|
5605 */
|
|
|
5606 page->mode_page.code = MODEPAGE_CACHING; /* PS = 0 */
|
|
|
5607 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3;
|
|
|
5608
|
|
|
5609 if ((sata_id->ai_cmdset82 & SATA_LOOK_AHEAD) &&
|
|
|
5610 !(sata_id->ai_features85 & SATA_LOOK_AHEAD)) {
|
|
|
5611 page->dra = 1; /* Read Ahead disabled */
|
|
|
5612 page->rcd = 1; /* Read Cache disabled */
|
|
|
5613 }
|
|
|
5614 if ((sata_id->ai_cmdset82 & SATA_WRITE_CACHE) &&
|
|
|
5615 (sata_id->ai_features85 & SATA_WRITE_CACHE))
|
|
|
5616 page->wce = 1; /* Write Cache enabled */
|
|
|
5617 } else {
|
|
|
5618 /* Changeable parameters */
|
|
|
5619 page->mode_page.code = MODEPAGE_CACHING;
|
|
|
5620 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3;
|
|
|
5621 if (sata_id->ai_cmdset82 & SATA_LOOK_AHEAD) {
|
|
|
5622 page->dra = 1;
|
|
|
5623 page->rcd = 1;
|
|
|
5624 }
|
|
|
5625 if (sata_id->ai_cmdset82 & SATA_WRITE_CACHE)
|
|
|
5626 page->wce = 1;
|
|
|
5627 }
|
|
|
5628 return (PAGELENGTH_DAD_MODE_CACHE_SCSI3 +
|
|
|
5629 sizeof (struct mode_page));
|
|
|
5630 }
|
|
|
5631
|
|
|
5632 /*
|
|
|
5633 * Build Mode sense exception cntrl page
|
|
|
5634 * NOT IMPLEMENTED
|
|
|
5635 */
|
|
|
5636 static int
|
|
|
5637 sata_build_msense_page_1c(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
|
|
|
5638 {
|
|
|
5639 #ifndef __lock_lint
|
|
|
5640 _NOTE(ARGUNUSED(sdinfo))
|
|
|
5641 _NOTE(ARGUNUSED(pcntrl))
|
|
|
5642 _NOTE(ARGUNUSED(buf))
|
|
|
5643 #endif
|
|
|
5644 return (0);
|
|
|
5645 }
|
|
|
5646
|
|
|
5647
|
|
|
5648 /*
|
|
|
5649 * Build Mode sense power condition page
|
|
|
5650 * NOT IMPLEMENTED.
|
|
|
5651 */
|
|
|
5652 static int
|
|
|
5653 sata_build_msense_page_1a(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
|
|
|
5654 {
|
|
|
5655 #ifndef __lock_lint
|
|
|
5656 _NOTE(ARGUNUSED(sdinfo))
|
|
|
5657 _NOTE(ARGUNUSED(pcntrl))
|
|
|
5658 _NOTE(ARGUNUSED(buf))
|
|
|
5659 #endif
|
|
|
5660 return (0);
|
|
|
5661 }
|
|
|
5662
|
|
|
5663
|
|
|
5664 /*
|
|
|
5665 * Process mode select caching page 8 (scsi3 format only).
|
|
|
5666 * Read Ahead (same as read cache) and Write Cache may be turned on and off
|
|
|
5667 * if these features are supported by the device. If these features are not
|
|
|
5668 * supported, quietly ignore them.
|
|
|
5669 * This function fails only if the SET FEATURE command sent to
|
|
|
5670 * the device fails. The page format is not varified, assuming that the
|
|
|
5671 * target driver operates correctly - if parameters length is too short,
|
|
|
5672 * we just drop the page.
|
|
|
5673 * Two command may be sent if both Read Cache/Read Ahead and Write Cache
|
|
|
5674 * setting have to be changed.
|
|
|
5675 * SET FEATURE command is executed synchronously, i.e. we wait here until
|
|
|
5676 * it is completed, regardless of the scsi pkt directives.
|
|
|
5677 *
|
|
|
5678 * Note: Mode Select Caching page RCD and DRA bits are tied together, i.e.
|
|
|
5679 * changing DRA will change RCD.
|
|
|
5680 *
|
|
|
5681 * More than one SATA command may be executed to perform operations specified
|
|
|
5682 * by mode select pages. The first error terminates further execution.
|
|
|
5683 * Operations performed successully are not backed-up in such case.
|
|
|
5684 *
|
|
|
5685 * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise.
|
|
|
5686 * If operation resulted in changing device setup, dmod flag should be set to
|
|
|
5687 * one (1). If parameters were not changed, dmod flag should be set to 0.
|
|
|
5688 * Upon return, if operation required sending command to the device, the rval
|
|
|
5689 * should be set to the value returned by sata_hba_start. If operation
|
|
|
5690 * did not require device access, rval should be set to TRAN_ACCEPT.
|
|
|
5691 * The pagelen should be set to the length of the page.
|
|
|
5692 *
|
|
|
5693 * This function has to be called with a port mutex held.
|
|
|
5694 *
|
|
|
5695 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
|
|
|
5696 */
|
|
|
5697 int
|
|
|
5698 sata_mode_select_page_8(sata_pkt_txlate_t *spx, struct mode_cache_scsi3 *page,
|
|
|
5699 int parmlen, int *pagelen, int *rval, int *dmod)
|
|
|
5700 {
|
|
|
5701 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
|
|
|
5702 sata_drive_info_t *sdinfo;
|
|
|
5703 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
|
|
|
5704 sata_id_t *sata_id;
|
|
|
5705 struct scsi_extended_sense *sense;
|
|
|
5706 int wce, dra; /* Current settings */
|
|
|
5707
|
|
|
5708 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
|
|
|
5709 &spx->txlt_sata_pkt->satapkt_device);
|
|
|
5710 sata_id = &sdinfo->satadrv_id;
|
|
|
5711 *dmod = 0;
|
|
|
5712
|
|
|
5713 /* Verify parameters length. If too short, drop it */
|
|
|
5714 if (PAGELENGTH_DAD_MODE_CACHE_SCSI3 +
|
|
|
5715 sizeof (struct mode_page) < parmlen) {
|
|
|
5716 *scsipkt->pkt_scbp = STATUS_CHECK;
|
|
|
5717 sense = sata_arq_sense(spx);
|
|
|
5718 sense->es_key = KEY_ILLEGAL_REQUEST;
|
|
|
5719 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_PARAMETER_LIST;
|
|
|
5720 *pagelen = parmlen;
|
|
|
5721 *rval = TRAN_ACCEPT;
|
|
|
5722 return (SATA_FAILURE);
|
|
|
5723 }
|
|
|
5724
|
|
|
5725 *pagelen = PAGELENGTH_DAD_MODE_CACHE_SCSI3 + sizeof (struct mode_page);
|
|
|
5726
|
|
|
5727 /*
|
|
|
5728 * We can manipulate only write cache and read ahead
|
|
|
5729 * (read cache) setting.
|
|
|
5730 */
|
|
|
5731 if (!(sata_id->ai_cmdset82 & SATA_LOOK_AHEAD) &&
|
|
|
5732 !(sata_id->ai_cmdset82 & SATA_WRITE_CACHE)) {
|
|
|
5733 /*
|
|
|
5734 * None of the features is supported - ignore
|
|
|
5735 */
|
|
|
5736 *rval = TRAN_ACCEPT;
|
|
|
5737 return (SATA_SUCCESS);
|
|
|
5738 }
|
|
|
5739
|
|
|
5740 /* Current setting of Read Ahead (and Read Cache) */
|
|
|
5741 if (sata_id->ai_features85 & SATA_LOOK_AHEAD)
|
|
|
5742 dra = 0; /* 0 == not disabled */
|
|
|
5743 else
|
|
|
5744 dra = 1;
|
|
|
5745 /* Current setting of Write Cache */
|
|
|
5746 if (sata_id->ai_features85 & SATA_WRITE_CACHE)
|
|
|
5747 wce = 1;
|
|
|
5748 else
|
|
|
5749 wce = 0;
|
|
|
5750
|
|
|
5751 if (page->dra == dra && page->wce == wce && page->rcd == dra) {
|
|
|
5752 /* nothing to do */
|
|
|
5753 *rval = TRAN_ACCEPT;
|
|
|
5754 return (SATA_SUCCESS);
|
|
|
5755 }
|
|
|
5756 /*
|
|
|
5757 * Need to flip some setting
|
|
|
5758 * Set-up Internal SET FEATURES command(s)
|
|
|
5759 */
|
|
|
5760 scmd->satacmd_flags &= ~SATA_XFER_DIR_MASK;
|
|
|
5761 scmd->satacmd_flags |= SATA_DIR_NODATA_XFER;
|
|
|
5762 scmd->satacmd_addr_type = 0;
|
|
|
5763 scmd->satacmd_device_reg = 0;
|
|
|
5764 scmd->satacmd_status_reg = 0;
|
|
|
5765 scmd->satacmd_error_reg = 0;
|
|
|
5766 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
|
|
|
5767 if (page->dra != dra || page->rcd != dra) {
|
|
|
5768 /* Need to flip read ahead setting */
|
|
|
5769 if (dra == 0)
|
|
|
5770 /* Disable read ahead / read cache */
|
|
|
5771 scmd->satacmd_features_reg =
|
|
|
5772 SATAC_SF_DISABLE_READ_AHEAD;
|
|
|
5773 else
|
|
|
5774 /* Enable read ahead / read cache */
|
|
|
5775 scmd->satacmd_features_reg =
|
|
|
5776 SATAC_SF_ENABLE_READ_AHEAD;
|
|
|
5777
|
|
|
5778 /* Transfer command to HBA */
|
|
|
5779 if (sata_hba_start(spx, rval) != 0)
|
|
|
5780 /*
|
|
|
5781 * Pkt not accepted for execution.
|
|
|
5782 */
|
|
|
5783 return (SATA_FAILURE);
|
|
|
5784
|
|
|
5785 *dmod = 1;
|
|
|
5786
|
|
|
5787 /* Now process return */
|
|
|
5788 if (spx->txlt_sata_pkt->satapkt_reason !=
|
|
|
5789 SATA_PKT_COMPLETED) {
|
|
|
5790 goto failure; /* Terminate */
|
|
|
5791 }
|
|
|
5792 }
|
|
|
5793
|
|
|
5794 /* Note that the packet is not removed, so it could be re-used */
|
|
|
5795 if (page->wce != wce) {
|
|
|
5796 /* Need to flip Write Cache setting */
|
|
|
5797 if (page->wce == 1)
|
|
|
5798 /* Enable write cache */
|
|
|
5799 scmd->satacmd_features_reg =
|
|
|
5800 SATAC_SF_ENABLE_WRITE_CACHE;
|
|
|
5801 else
|
|
|
5802 /* Disable write cache */
|
|
|
5803 scmd->satacmd_features_reg =
|
|
|
5804 SATAC_SF_DISABLE_WRITE_CACHE;
|
|
|
5805
|
|
|
5806 /* Transfer command to HBA */
|
|
|
5807 if (sata_hba_start(spx, rval) != 0)
|
|
|
5808 /*
|
|
|
5809 * Pkt not accepted for execution.
|
|
|
5810 */
|
|
|
5811 return (SATA_FAILURE);
|
|
|
5812
|
|
|
5813 *dmod = 1;
|
|
|
5814
|
|
|
5815 /* Now process return */
|
|
|
5816 if (spx->txlt_sata_pkt->satapkt_reason !=
|
|
|
5817 SATA_PKT_COMPLETED) {
|
|
|
5818 goto failure;
|
|
|
5819 }
|
|
|
5820 }
|
|
|
5821 return (SATA_SUCCESS);
|
|
|
5822
|
|
|
5823 failure:
|
|
|
5824 scsipkt->pkt_reason = CMD_INCOMPLETE;
|
|
|
5825 *scsipkt->pkt_scbp = STATUS_CHECK;
|
|
|
5826 sense = sata_arq_sense(spx);
|
|
|
5827 switch (spx->txlt_sata_pkt->satapkt_reason) {
|
|
|
5828 case SATA_PKT_PORT_ERROR:
|
|
|
5829 /*
|
|
|
5830 * We have no device data. Assume no data transfered.
|
|
|
5831 */
|
|
|
5832 sense->es_key = KEY_HARDWARE_ERROR;
|
|
|
5833 break;
|
|
|
5834
|
|
|
5835 case SATA_PKT_DEV_ERROR:
|
|
|
5836 if (spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg &
|
|
|
5837 SATA_STATUS_ERR) {
|
|
|
5838 /*
|
|
|
5839 * determine dev error reason from error
|
|
|
5840 * reg content
|
|
|
5841 */
|
|
|
5842 sata_decode_device_error(spx, sense);
|
|
|
5843 break;
|
|
|
5844 }
|
|
|
5845 /* No extended sense key - no info available */
|
|
|
5846 break;
|
|
|
5847
|
|
|
5848 case SATA_PKT_TIMEOUT:
|
|
|
5849 /*
|
|
|
5850 * scsipkt->pkt_reason = CMD_TIMEOUT; This causes problems.
|
|
|
5851 */
|
|
|
5852 scsipkt->pkt_reason = CMD_INCOMPLETE;
|
|
|
5853 /* No extended sense key */
|
|
|
5854 break;
|
|
|
5855
|
|
|
5856 case SATA_PKT_ABORTED:
|
|
|
5857 scsipkt->pkt_reason = CMD_ABORTED;
|
|
|
5858 /* No extended sense key */
|
|
|
5859 break;
|
|
|
5860
|
|
|
5861 case SATA_PKT_RESET:
|
|
|
5862 /*
|
|
|
5863 * pkt aborted either by an explicit reset request from
|
|
|
5864 * a host, or due to error recovery
|
|
|
5865 */
|
|
|
5866 scsipkt->pkt_reason = CMD_RESET;
|
|
|
5867 break;
|
|
|
5868
|
|
|
5869 default:
|
|
|
5870 scsipkt->pkt_reason = CMD_TRAN_ERR;
|
|
|
5871 break;
|
|
|
5872 }
|
|
|
5873 return (SATA_FAILURE);
|
|
|
5874 }
|
|
|
5875
|
|
|
5876
|
|
|
5877
|
|
|
5878
|
|
|
5879
|
|
|
5880 /* ************************** LOCAL FUNCTIONS ************************** */
|
|
|
5881
|
|
|
5882 /*
|
|
|
5883 * Validate sata_tran info
|
|
|
5884 * SATA_FAILURE returns if structure is inconsistent or structure revision
|
|
|
5885 * does not match one used by the framework.
|
|
|
5886 *
|
|
|
5887 * Returns SATA_SUCCESS if sata_hba_tran has matching revision and contains
|
|
|
5888 * required function pointers.
|
|
|
5889 * Returns SATA_FAILURE otherwise.
|
|
|
5890 */
|
|
|
5891 static int
|
|
|
5892 sata_validate_sata_hba_tran(dev_info_t *dip, sata_hba_tran_t *sata_tran)
|
|
|
5893 {
|
|
|
5894 if (sata_tran->sata_tran_hba_rev != SATA_TRAN_HBA_REV) {
|
|
|
5895 sata_log(NULL, CE_WARN,
|
|
|
5896 "sata: invalid sata_hba_tran version %d for driver %s",
|
|
|
5897 sata_tran->sata_tran_hba_rev, ddi_driver_name(dip));
|
|
|
5898 return (SATA_FAILURE);
|
|
|
5899 }
|
|
|
5900
|
|
|
5901 if (dip != sata_tran->sata_tran_hba_dip) {
|
|
|
5902 SATA_LOG_D((NULL, CE_WARN,
|
|
|
5903 "sata: inconsistent sata_tran_hba_dip "
|
|
|
5904 "%p / %p", sata_tran->sata_tran_hba_dip, dip));
|
|
|
5905 return (SATA_FAILURE);
|
|
|
5906 }
|
|
|
5907
|
|
|
5908 if (sata_tran->sata_tran_probe_port == NULL ||
|
|
|
5909 sata_tran->sata_tran_start == NULL ||
|
|
|
5910 sata_tran->sata_tran_abort == NULL ||
|
|
|
5911 sata_tran->sata_tran_reset_dport == NULL) {
|
|
|
5912 SATA_LOG_D((NULL, CE_WARN, "sata: sata_hba_tran missing "
|
|
|
5913 "required functions"));
|
|
|
5914 }
|
|
|
5915 return (SATA_SUCCESS);
|
|
|
5916 }
|
|
|
5917
|
|
|
5918 /*
|
|
|
5919 * Remove HBA instance from sata_hba_list.
|
|
|
5920 */
|
|
|
5921 static void
|
|
|
5922 sata_remove_hba_instance(dev_info_t *dip)
|
|
|
5923 {
|
|
|
5924 sata_hba_inst_t *sata_hba_inst;
|
|
|
5925
|
|
|
5926 mutex_enter(&sata_mutex);
|
|
|
5927 for (sata_hba_inst = sata_hba_list;
|
|
|
5928 sata_hba_inst != (struct sata_hba_inst *)NULL;
|
|
|
5929 sata_hba_inst = sata_hba_inst->satahba_next) {
|
|
|
5930 if (sata_hba_inst->satahba_dip == dip)
|
|
|
5931 break;
|
|
|
5932 }
|
|
|
5933
|
|
|
5934 if (sata_hba_inst == (struct sata_hba_inst *)NULL) {
|
|
|
5935 #ifdef SATA_DEBUG
|
|
|
5936 cmn_err(CE_WARN, "sata_remove_hba_instance: "
|
|
|
5937 "unknown HBA instance\n");
|
|
|
5938 #endif
|
|
|
5939 ASSERT(FALSE);
|
|
|
5940 }
|
|
|
5941 if (sata_hba_inst == sata_hba_list) {
|
|
|
5942 sata_hba_list = sata_hba_inst->satahba_next;
|
|
|
5943 if (sata_hba_list) {
|
|
|
5944 sata_hba_list->satahba_prev =
|
|
|
5945 (struct sata_hba_inst *)NULL;
|
|
|
5946 }
|
|
|
5947 if (sata_hba_inst == sata_hba_list_tail) {
|
|
|
5948 sata_hba_list_tail = NULL;
|
|
|
5949 }
|
|
|
5950 } else if (sata_hba_inst == sata_hba_list_tail) {
|
|
|
5951 sata_hba_list_tail = sata_hba_inst->satahba_prev;
|
|
|
5952 if (sata_hba_list_tail) {
|
|
|
5953 sata_hba_list_tail->satahba_next =
|
|
|
5954 (struct sata_hba_inst *)NULL;
|
|
|
5955 }
|
|
|
5956 } else {
|
|
|
5957 sata_hba_inst->satahba_prev->satahba_next =
|
|
|
5958 sata_hba_inst->satahba_next;
|
|
|
5959 sata_hba_inst->satahba_next->satahba_prev =
|
|
|
5960 sata_hba_inst->satahba_prev;
|
|
|
5961 }
|
|
|
5962 mutex_exit(&sata_mutex);
|
|
|
5963 }
|
|
|
5964
|
|
|
5965
|
|
|
5966
|
|
|
5967
|
|
|
5968
|
|
|
5969 /*
|
|
|
5970 * Probe all SATA ports of the specified HBA instance.
|
|
|
5971 * This function is called only from sata_hba_attach(). It does not have to
|
|
|
5972 * be protected by controller mutex, because the hba_attached flag is not set
|
|
|
5973 * yet and no one would be touching this HBA instance other then this thread.
|
|
|
5974 * Determines if port is active and what type of the device is attached
|
|
|
5975 * (if any). Allocates necessary structures for each port.
|
|
|
5976 * Creates attachment point minor node for each non-failed port.
|
|
|
5977 */
|
|
|
5978
|
|
|
5979 static void
|
|
|
5980 sata_probe_ports(sata_hba_inst_t *sata_hba_inst)
|
|
|
5981 {
|
|
|
5982 dev_info_t *dip = SATA_DIP(sata_hba_inst);
|
|
|
5983 int ncport, npmport;
|
|
|
5984 sata_cport_info_t *cportinfo;
|
|
|
5985 sata_drive_info_t *drive;
|
|
|
5986 sata_pmult_info_t *pminfo;
|
|
|
5987 sata_pmport_info_t *pmportinfo;
|
|
|
5988 sata_device_t sata_device;
|
|
|
5989 int rval;
|
|
|
5990 dev_t minor_number;
|
|
|
5991 char name[16];
|
|
|
5992
|
|
|
5993 /*
|
|
|
5994 * Probe controller ports first, to find port status and
|
|
|
5995 * any port multiplier attached.
|
|
|
5996 */
|
|
|
5997 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) {
|
|
|
5998 /* allocate cport structure */
|
|
|
5999 cportinfo = kmem_zalloc(sizeof (sata_cport_info_t), KM_SLEEP);
|
|
|
6000 ASSERT(cportinfo != NULL);
|
|
|
6001 mutex_init(&cportinfo->cport_mutex, NULL, MUTEX_DRIVER, NULL);
|
|
|
6002
|
|
|
6003 mutex_enter(&cportinfo->cport_mutex);
|
|
|
6004
|
|
|
6005 cportinfo->cport_addr.cport = ncport;
|
|
|
6006 cportinfo->cport_addr.pmport = 0;
|
|
|
6007 cportinfo->cport_addr.qual = SATA_ADDR_CPORT;
|
|
|
6008 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
|
|
|
6009 cportinfo->cport_state |= SATA_STATE_PROBING;
|
|
|
6010 SATA_CPORT_INFO(sata_hba_inst, ncport) = cportinfo;
|
|
|
6011
|
|
|
6012 /*
|
|
|
6013 * Regardless if a port is usable or not, create
|
|
|
6014 * an attachment point
|
|
|
6015 */
|
|
|
6016 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6017 minor_number =
|
|
|
6018 SATA_MAKE_AP_MINOR(ddi_get_instance(dip), ncport, 0, 0);
|
|
|
6019 (void) sprintf(name, "%d", ncport);
|
|
|
6020 if (ddi_create_minor_node(dip, name, S_IFCHR,
|
|
|
6021 minor_number, DDI_NT_SATA_ATTACHMENT_POINT, 0) !=
|
|
|
6022 DDI_SUCCESS) {
|
|
|
6023 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: "
|
|
|
6024 "cannot create sata attachment point for port %d",
|
|
|
6025 ncport);
|
|
|
6026 }
|
|
|
6027
|
|
|
6028 /* Probe port */
|
|
|
6029 sata_device.satadev_addr.cport = ncport;
|
|
|
6030 sata_device.satadev_addr.pmport = 0;
|
|
|
6031 sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
|
|
|
6032 sata_device.satadev_rev = SATA_DEVICE_REV;
|
|
|
6033
|
|
|
6034 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
|
|
|
6035 (dip, &sata_device);
|
|
|
6036
|
|
|
6037 mutex_enter(&cportinfo->cport_mutex);
|
|
|
6038 sata_update_port_scr(&cportinfo->cport_scr, &sata_device);
|
|
|
6039 if (rval != SATA_SUCCESS) {
|
|
|
6040 /* Something went wrong? Fail the port */
|
|
|
6041 cportinfo->cport_state = SATA_PSTATE_FAILED;
|
|
|
6042 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6043 continue;
|
|
|
6044 }
|
|
|
6045 cportinfo->cport_state &= ~SATA_STATE_PROBING;
|
|
|
6046 cportinfo->cport_state |= SATA_STATE_PROBED;
|
|
|
6047 cportinfo->cport_dev_type = sata_device.satadev_type;
|
|
|
6048
|
|
|
6049 cportinfo->cport_state |= SATA_STATE_READY;
|
|
|
6050 if (cportinfo->cport_dev_type == SATA_DTYPE_NONE) {
|
|
|
6051 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6052 continue;
|
|
|
6053 }
|
|
|
6054 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
|
|
|
6055 /*
|
|
|
6056 * There is some device attached.
|
|
|
6057 * Allocate device info structure
|
|
|
6058 */
|
|
|
6059 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6060 drive = kmem_zalloc(sizeof (sata_drive_info_t),
|
|
|
6061 KM_SLEEP);
|
|
|
6062 mutex_enter(&cportinfo->cport_mutex);
|
|
|
6063 SATA_CPORTINFO_DRV_INFO(cportinfo) = drive;
|
|
|
6064 drive->satadrv_addr = cportinfo->cport_addr;
|
|
|
6065 drive->satadrv_addr.qual = SATA_ADDR_DCPORT;
|
|
|
6066 drive->satadrv_type = cportinfo->cport_dev_type;
|
|
|
6067 drive->satadrv_state = SATA_STATE_UNKNOWN;
|
|
|
6068 } else {
|
|
|
6069 ASSERT(cportinfo->cport_dev_type == SATA_DTYPE_PMULT);
|
|
|
6070 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6071 pminfo = kmem_zalloc(sizeof (sata_pmult_info_t),
|
|
|
6072 KM_SLEEP);
|
|
|
6073 mutex_enter(&cportinfo->cport_mutex);
|
|
|
6074 ASSERT(pminfo != NULL);
|
|
|
6075 SATA_CPORTINFO_PMULT_INFO(cportinfo) = pminfo;
|
|
|
6076 pminfo->pmult_addr.cport = cportinfo->cport_addr.cport;
|
|
|
6077 pminfo->pmult_addr.pmport = SATA_PMULT_HOSTPORT;
|
|
|
6078 pminfo->pmult_addr.qual = SATA_ADDR_PMPORT;
|
|
|
6079 pminfo->pmult_num_dev_ports =
|
|
|
6080 sata_device.satadev_add_info;
|
|
|
6081 mutex_init(&pminfo->pmult_mutex, NULL, MUTEX_DRIVER,
|
|
|
6082 NULL);
|
|
|
6083 pminfo->pmult_state = SATA_STATE_PROBING;
|
|
|
6084
|
|
|
6085 /* Probe Port Multiplier ports */
|
|
|
6086 for (npmport = 0;
|
|
|
6087 npmport < pminfo->pmult_num_dev_ports;
|
|
|
6088 npmport++) {
|
|
|
6089 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6090 pmportinfo = kmem_zalloc(
|
|
|
6091 sizeof (sata_pmport_info_t), KM_SLEEP);
|
|
|
6092 mutex_enter(&cportinfo->cport_mutex);
|
|
|
6093 ASSERT(pmportinfo != NULL);
|
|
|
6094 pmportinfo->pmport_addr.cport = ncport;
|
|
|
6095 pmportinfo->pmport_addr.pmport = npmport;
|
|
|
6096 pmportinfo->pmport_addr.qual =
|
|
|
6097 SATA_ADDR_PMPORT;
|
|
|
6098 pminfo->pmult_dev_port[npmport] = pmportinfo;
|
|
|
6099 mutex_init(&pmportinfo->pmport_mutex, NULL,
|
|
|
6100 MUTEX_DRIVER, NULL);
|
|
|
6101
|
|
|
6102 sata_device.satadev_addr.pmport = npmport;
|
|
|
6103 sata_device.satadev_addr.qual =
|
|
|
6104 SATA_ADDR_PMPORT;
|
|
|
6105
|
|
|
6106 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6107 /* Create an attachment point */
|
|
|
6108 minor_number = SATA_MAKE_AP_MINOR(
|
|
|
6109 ddi_get_instance(dip), ncport, npmport, 1);
|
|
|
6110 (void) sprintf(name, "%d.%d", ncport, npmport);
|
|
|
6111 if (ddi_create_minor_node(dip, name, S_IFCHR,
|
|
|
6112 minor_number, DDI_NT_SATA_ATTACHMENT_POINT,
|
|
|
6113 0) != DDI_SUCCESS) {
|
|
|
6114 sata_log(sata_hba_inst, CE_WARN,
|
|
|
6115 "sata_hba_attach: "
|
|
|
6116 "cannot create sata attachment "
|
|
|
6117 "point for port %d pmult port %d",
|
|
|
6118 ncport, npmport);
|
|
|
6119 }
|
|
|
6120 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
|
|
|
6121 (dip, &sata_device);
|
|
|
6122 mutex_enter(&cportinfo->cport_mutex);
|
|
|
6123
|
|
|
6124 /* sata_update_port_info() */
|
|
|
6125 sata_update_port_scr(&pmportinfo->pmport_scr,
|
|
|
6126 &sata_device);
|
|
|
6127
|
|
|
6128 if (rval != SATA_SUCCESS) {
|
|
|
6129 pmportinfo->pmport_state =
|
|
|
6130 SATA_PSTATE_FAILED;
|
|
|
6131 continue;
|
|
|
6132 }
|
|
|
6133 pmportinfo->pmport_state &=
|
|
|
6134 ~SATA_STATE_PROBING;
|
|
|
6135 pmportinfo->pmport_state |= SATA_STATE_PROBED;
|
|
|
6136 pmportinfo->pmport_dev_type =
|
|
|
6137 sata_device.satadev_type;
|
|
|
6138
|
|
|
6139 pmportinfo->pmport_state |= SATA_STATE_READY;
|
|
|
6140 if (pmportinfo->pmport_dev_type ==
|
|
|
6141 SATA_DTYPE_NONE)
|
|
|
6142 continue;
|
|
|
6143
|
|
|
6144 /* Port multipliers cannot be chained */
|
|
|
6145 ASSERT(pmportinfo->pmport_dev_type !=
|
|
|
6146 SATA_DTYPE_PMULT);
|
|
|
6147 /*
|
|
|
6148 * There is something attached to Port
|
|
|
6149 * Multiplier device port
|
|
|
6150 * Allocate device info structure
|
|
|
6151 */
|
|
|
6152 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6153 drive = kmem_zalloc(
|
|
|
6154 sizeof (sata_drive_info_t), KM_SLEEP);
|
|
|
6155 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
|
|
|
6156 (dip, &sata_device);
|
|
|
6157 mutex_enter(&cportinfo->cport_mutex);
|
|
|
6158
|
|
|
6159 /* sata_update_port_info() */
|
|
|
6160 sata_update_port_scr(&pmportinfo->pmport_scr,
|
|
|
6161 &sata_device);
|
|
|
6162
|
|
|
6163 pmportinfo->pmport_sata_drive = drive;
|
|
|
6164 drive->satadrv_addr.cport =
|
|
|
6165 pmportinfo->pmport_addr.cport;
|
|
|
6166 drive->satadrv_addr.pmport = npmport;
|
|
|
6167 drive->satadrv_addr.qual = SATA_ADDR_DPMPORT;
|
|
|
6168 drive->satadrv_type = pmportinfo->
|
|
|
6169 pmport_dev_type;
|
|
|
6170 drive->satadrv_state = SATA_STATE_UNKNOWN;
|
|
|
6171 }
|
|
|
6172 pmportinfo->pmport_state =
|
|
|
6173 SATA_STATE_PROBED | SATA_STATE_READY;
|
|
|
6174 }
|
|
|
6175 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6176 }
|
|
|
6177 }
|
|
|
6178
|
|
|
6179
|
|
|
6180
|
|
|
6181 /*
|
|
|
6182 * Create SATA device nodes for specified HBA instance (SCSI target
|
|
|
6183 * device nodes).
|
|
|
6184 * This function is called only from sata_hba_attach(). The hba_attached flag
|
|
|
6185 * is not set yet, so no ports or device data structures would be touched
|
|
|
6186 * by anyone other then this thread, therefore per-port mutex protection is
|
|
|
6187 * not needed.
|
|
|
6188 * The assumption is that there are no target and attachment point minor nodes
|
|
|
6189 * created by the boot subsystems, so we do not need to prune device tree.
|
|
|
6190 * An AP (Attachement Point) node is created for each SATA device port even
|
|
|
6191 * when there is no device attached.
|
|
|
6192 * A target node is created when there is a supported type of device attached,
|
|
|
6193 * but may be removed if it cannot be put online.
|
|
|
6194 *
|
|
|
6195 * This function cannot be called from an interrupt context.
|
|
|
6196 *
|
|
|
6197 * ONLY DISK TARGET NODES ARE CREATED NOW
|
|
|
6198 */
|
|
|
6199 static void
|
|
|
6200 sata_make_device_nodes(dev_info_t *pdip, sata_hba_inst_t *sata_hba_inst)
|
|
|
6201 {
|
|
|
6202 int ncport, npmport;
|
|
|
6203 sata_cport_info_t *cportinfo;
|
|
|
6204 sata_pmult_info_t *pminfo;
|
|
|
6205 sata_pmport_info_t *pmportinfo;
|
|
|
6206 dev_info_t *cdip; /* child dip */
|
|
|
6207 sata_device_t sata_device;
|
|
|
6208 int rval;
|
|
|
6209
|
|
|
6210 /*
|
|
|
6211 * Walk through pre-probed sata ports info in sata_scsi
|
|
|
6212 */
|
|
|
6213 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) {
|
|
|
6214 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
|
|
|
6215 mutex_enter(&cportinfo->cport_mutex);
|
|
|
6216 if (!(cportinfo->cport_state & SATA_STATE_PROBED)) {
|
|
|
6217 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6218 continue;
|
|
|
6219 }
|
|
|
6220 if (cportinfo->cport_state == SATA_PSTATE_FAILED) {
|
|
|
6221 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6222 continue;
|
|
|
6223 }
|
|
|
6224 if (cportinfo->cport_dev_type == SATA_DTYPE_NONE) {
|
|
|
6225 /* No device attached to the controller port */
|
|
|
6226 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6227 continue;
|
|
|
6228 }
|
|
|
6229 /*
|
|
|
6230 * Some device is attached to a controller port.
|
|
|
6231 * We rely on controllers distinquishing between no-device,
|
|
|
6232 * attached port multiplier and other kind of attached device.
|
|
|
6233 * We need to get Identify Device data and determine
|
|
|
6234 * positively the dev type before trying to attach
|
|
|
6235 * the target driver.
|
|
|
6236 */
|
|
|
6237 sata_device.satadev_rev = SATA_DEVICE_REV;
|
|
|
6238 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
|
|
|
6239 /*
|
|
|
6240 * Not port multiplier.
|
|
|
6241 */
|
|
|
6242 sata_device.satadev_addr = cportinfo->cport_addr;
|
|
|
6243 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
|
|
|
6244 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6245 rval = sata_probe_device(sata_hba_inst, &sata_device);
|
|
|
6246 if (rval != SATA_SUCCESS ||
|
|
|
6247 sata_device.satadev_type == SATA_DTYPE_UNKNOWN)
|
|
|
6248 continue;
|
|
|
6249
|
|
|
6250 mutex_enter(&cportinfo->cport_mutex);
|
|
|
6251 sata_save_drive_settings(
|
|
|
6252 SATA_CPORTINFO_DRV_INFO(cportinfo));
|
|
|
6253
|
|
|
6254 if ((sata_device.satadev_type &
|
|
|
6255 SATA_VALID_DEV_TYPE) == 0) {
|
|
|
6256 /*
|
|
|
6257 * Could not determine device type or
|
|
|
6258 * a device is not supported.
|
|
|
6259 * Degrade this device to unknown.
|
|
|
6260 */
|
|
|
6261 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
|
|
|
6262 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6263 continue;
|
|
|
6264 }
|
|
|
6265 cportinfo->cport_dev_type = sata_device.satadev_type;
|
|
|
6266
|
|
|
6267 sata_show_drive_info(sata_hba_inst,
|
|
|
6268 SATA_CPORTINFO_DRV_INFO(cportinfo));
|
|
|
6269
|
|
|
6270 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6271 cdip = sata_create_target_node(pdip, sata_hba_inst,
|
|
|
6272 &sata_device.satadev_addr);
|
|
|
6273 mutex_enter(&cportinfo->cport_mutex);
|
|
|
6274 if (cdip == NULL) {
|
|
|
6275 /*
|
|
|
6276 * Attaching target node failed.
|
|
|
6277 * We retain sata_drive_info structure...
|
|
|
6278 */
|
|
|
6279 (SATA_CPORTINFO_DRV_INFO(cportinfo))->
|
|
|
6280 satadrv_type = SATA_DTYPE_UNKNOWN;
|
|
|
6281 (SATA_CPORTINFO_DRV_INFO(cportinfo))->
|
|
|
6282 satadrv_state = SATA_STATE_UNKNOWN;
|
|
|
6283 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
|
|
|
6284 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6285 continue;
|
|
|
6286 }
|
|
|
6287 (SATA_CPORTINFO_DRV_INFO(cportinfo))->
|
|
|
6288 satadrv_state = SATA_STATE_READY;
|
|
|
6289 } else {
|
|
|
6290 /* This must be Port Multiplier type */
|
|
|
6291 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
|
|
|
6292 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
6293 "sata_make_device_nodes: "
|
|
|
6294 "unknown dev type %x",
|
|
|
6295 cportinfo->cport_dev_type));
|
|
|
6296 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6297 continue;
|
|
|
6298 }
|
|
|
6299 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
|
|
|
6300 for (npmport = 0;
|
|
|
6301 npmport < pminfo->pmult_num_dev_ports;
|
|
|
6302 npmport++) {
|
|
|
6303 pmportinfo = pminfo->pmult_dev_port[npmport];
|
|
|
6304 if (pmportinfo->pmport_state &
|
|
|
6305 SATA_PSTATE_FAILED) {
|
|
|
6306 continue;
|
|
|
6307 }
|
|
|
6308 if (pmportinfo->pmport_dev_type &
|
|
|
6309 SATA_DTYPE_NONE)
|
|
|
6310 /* No device attached */
|
|
|
6311 continue;
|
|
|
6312
|
|
|
6313 sata_device.satadev_addr =
|
|
|
6314 pmportinfo->pmport_addr;
|
|
|
6315 sata_device.satadev_addr.qual =
|
|
|
6316 SATA_ADDR_DPMPORT;
|
|
|
6317 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6318 rval = sata_probe_device(sata_hba_inst,
|
|
|
6319 &sata_device);
|
|
|
6320 if (rval != SATA_SUCCESS ||
|
|
|
6321 sata_device.satadev_type ==
|
|
|
6322 SATA_DTYPE_UNKNOWN) {
|
|
|
6323 mutex_enter(&cportinfo->cport_mutex);
|
|
|
6324 continue;
|
|
|
6325 }
|
|
|
6326 mutex_enter(&cportinfo->cport_mutex);
|
|
|
6327 sata_save_drive_settings(
|
|
|
6328 pmportinfo->pmport_sata_drive);
|
|
|
6329 if ((sata_device.satadev_type &
|
|
|
6330 SATA_VALID_DEV_TYPE) == 0) {
|
|
|
6331 /*
|
|
|
6332 * Could not determine device type.
|
|
|
6333 * Degrade this device to unknown.
|
|
|
6334 */
|
|
|
6335 pmportinfo->pmport_dev_type =
|
|
|
6336 SATA_DTYPE_UNKNOWN;
|
|
|
6337 continue;
|
|
|
6338 }
|
|
|
6339 pmportinfo->pmport_dev_type =
|
|
|
6340 sata_device.satadev_type;
|
|
|
6341
|
|
|
6342 sata_show_drive_info(sata_hba_inst,
|
|
|
6343 pmportinfo->pmport_sata_drive);
|
|
|
6344
|
|
|
6345 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6346 cdip = sata_create_target_node(pdip,
|
|
|
6347 sata_hba_inst, &sata_device.satadev_addr);
|
|
|
6348 mutex_enter(&cportinfo->cport_mutex);
|
|
|
6349 if (cdip == NULL) {
|
|
|
6350 /*
|
|
|
6351 * Attaching target node failed.
|
|
|
6352 * We retain sata_drive_info
|
|
|
6353 * structure...
|
|
|
6354 */
|
|
|
6355 pmportinfo->pmport_sata_drive->
|
|
|
6356 satadrv_type = SATA_DTYPE_UNKNOWN;
|
|
|
6357 pmportinfo->pmport_sata_drive->
|
|
|
6358 satadrv_state = SATA_STATE_UNKNOWN;
|
|
|
6359 pmportinfo->pmport_dev_type =
|
|
|
6360 SATA_DTYPE_UNKNOWN;
|
|
|
6361 continue;
|
|
|
6362 }
|
|
|
6363 pmportinfo->pmport_sata_drive->
|
|
|
6364 satadrv_state |= SATA_STATE_READY;
|
|
|
6365 }
|
|
|
6366 }
|
|
|
6367 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6368 }
|
|
|
6369 }
|
|
|
6370
|
|
|
6371
|
|
|
6372
|
|
|
6373 /*
|
|
|
6374 * Create scsi target node for attached device, create node properties and
|
|
|
6375 * attach the node.
|
|
|
6376 * The node could be removed if the device onlining fails.
|
|
|
6377 *
|
|
|
6378 * A dev_info_t pointer is returned if operation is successful, NULL is
|
|
|
6379 * returned otherwise.
|
|
|
6380 */
|
|
|
6381
|
|
|
6382 static dev_info_t *
|
|
|
6383 sata_create_target_node(dev_info_t *dip, sata_hba_inst_t *sata_hba_inst,
|
|
|
6384 sata_address_t *sata_addr)
|
|
|
6385 {
|
|
|
6386 dev_info_t *cdip = NULL;
|
|
|
6387 int rval;
|
|
|
6388 char *nname = NULL;
|
|
|
6389 char **compatible = NULL;
|
|
|
6390 int ncompatible;
|
|
|
6391 struct scsi_inquiry inq;
|
|
|
6392 sata_device_t sata_device;
|
|
|
6393 sata_drive_info_t *sdinfo;
|
|
|
6394 int target;
|
|
|
6395 int i;
|
|
|
6396
|
|
|
6397 sata_device.satadev_rev = SATA_DEVICE_REV;
|
|
|
6398 sata_device.satadev_addr = *sata_addr;
|
|
|
6399
|
|
|
6400 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport)));
|
|
|
6401
|
|
|
6402 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
|
|
|
6403
|
|
|
6404 target = SATA_TO_SCSI_TARGET(sata_addr->cport,
|
|
|
6405 sata_addr->pmport, sata_addr->qual);
|
|
|
6406
|
|
|
6407 if (sdinfo == NULL) {
|
|
|
6408 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
6409 sata_addr->cport)));
|
|
|
6410 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
6411 "sata_create_target_node: no sdinfo for target %x",
|
|
|
6412 target));
|
|
|
6413 return (NULL);
|
|
|
6414 }
|
|
|
6415
|
|
|
6416 /*
|
|
|
6417 * create scsi inquiry data, expected by
|
|
|
6418 * scsi_hba_nodename_compatible_get()
|
|
|
6419 */
|
|
|
6420 sata_identdev_to_inquiry(sata_hba_inst, sdinfo, (uint8_t *)&inq);
|
|
|
6421 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport)));
|
|
|
6422
|
|
|
6423 /* determine the node name and compatible */
|
|
|
6424 scsi_hba_nodename_compatible_get(&inq, NULL,
|
|
|
6425 inq.inq_dtype, NULL, &nname, &compatible, &ncompatible);
|
|
|
6426
|
|
|
6427 #ifdef SATA_DEBUG
|
|
|
6428 if (sata_debug_flags & SATA_DBG_NODES) {
|
|
|
6429 if (nname == NULL) {
|
|
|
6430 cmn_err(CE_NOTE, "sata_create_target_node: "
|
|
|
6431 "cannot determine nodename for target %d\n",
|
|
|
6432 target);
|
|
|
6433 } else {
|
|
|
6434 cmn_err(CE_WARN, "sata_create_target_node: "
|
|
|
6435 "target %d nodename: %s\n", target, nname);
|
|
|
6436 }
|
|
|
6437 if (compatible == NULL) {
|
|
|
6438 cmn_err(CE_WARN,
|
|
|
6439 "sata_create_target_node: no compatible name\n");
|
|
|
6440 } else {
|
|
|
6441 for (i = 0; i < ncompatible; i++) {
|
|
|
6442 cmn_err(CE_WARN, "sata_create_target_node: "
|
|
|
6443 "compatible name: %s\n", compatible[i]);
|
|
|
6444 }
|
|
|
6445 }
|
|
|
6446 }
|
|
|
6447 #endif
|
|
|
6448
|
|
|
6449 /* if nodename can't be determined, log error and exit */
|
|
|
6450 if (nname == NULL) {
|
|
|
6451 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
6452 "sata_create_target_node: cannot determine nodename "
|
|
|
6453 "for target %d\n", target));
|
|
|
6454 scsi_hba_nodename_compatible_free(nname, compatible);
|
|
|
6455 return (NULL);
|
|
|
6456 }
|
|
|
6457 /*
|
|
|
6458 * Create scsi target node
|
|
|
6459 */
|
|
|
6460 ndi_devi_alloc_sleep(dip, nname, (pnode_t)DEVI_SID_NODEID, &cdip);
|
|
|
6461 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip,
|
|
|
6462 "device-type", "scsi");
|
|
|
6463
|
|
|
6464 if (rval != DDI_PROP_SUCCESS) {
|
|
|
6465 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
|
|
|
6466 "updating device_type prop failed %d", rval));
|
|
|
6467 goto fail;
|
|
|
6468 }
|
|
|
6469
|
|
|
6470 /*
|
|
|
6471 * Create target node properties: target & lun
|
|
|
6472 */
|
|
|
6473 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "target", target);
|
|
|
6474 if (rval != DDI_PROP_SUCCESS) {
|
|
|
6475 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
|
|
|
6476 "updating target prop failed %d", rval));
|
|
|
6477 goto fail;
|
|
|
6478 }
|
|
|
6479 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "lun", 0);
|
|
|
6480 if (rval != DDI_PROP_SUCCESS) {
|
|
|
6481 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
|
|
|
6482 "updating target prop failed %d", rval));
|
|
|
6483 goto fail;
|
|
|
6484 }
|
|
|
6485
|
|
|
6486 /* decorate the node with compatible */
|
|
|
6487 if (ndi_prop_update_string_array(DDI_DEV_T_NONE, cdip, "compatible",
|
|
|
6488 compatible, ncompatible) != DDI_PROP_SUCCESS) {
|
|
|
6489 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
6490 "sata_create_target_node: FAIL compatible props cdip 0x%p",
|
|
|
6491 (void *)cdip));
|
|
|
6492 goto fail;
|
|
|
6493 }
|
|
|
6494
|
|
|
6495 /*
|
|
|
6496 * Now, try to attach the driver. If probing of the device fails,
|
|
|
6497 * the target node may be removed
|
|
|
6498 */
|
|
|
6499 rval = ndi_devi_online(cdip, NDI_ONLINE_ATTACH);
|
|
|
6500
|
|
|
6501 scsi_hba_nodename_compatible_free(nname, compatible);
|
|
|
6502
|
|
|
6503 if (rval == NDI_SUCCESS)
|
|
|
6504 return (cdip);
|
|
|
6505
|
|
|
6506 /* target node was removed - are we sure? */
|
|
|
6507 return (NULL);
|
|
|
6508
|
|
|
6509 fail:
|
|
|
6510 scsi_hba_nodename_compatible_free(nname, compatible);
|
|
|
6511 ddi_prop_remove_all(cdip);
|
|
|
6512 rval = ndi_devi_free(cdip);
|
|
|
6513 if (rval != NDI_SUCCESS) {
|
|
|
6514 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
|
|
|
6515 "node removal failed %d", rval));
|
|
|
6516 }
|
|
|
6517 sata_log(sata_hba_inst, CE_WARN, "sata_create_target_node: "
|
|
|
6518 "cannot create target node for device at port %d",
|
|
|
6519 sata_addr->cport);
|
|
|
6520 return (NULL);
|
|
|
6521 }
|
|
|
6522
|
|
|
6523
|
|
|
6524
|
|
|
6525 /*
|
|
|
6526 * Re-probe sata port, check for a device and attach necessary info
|
|
|
6527 * structures when necessary. Identify Device data is fetched, if possible.
|
|
|
6528 * Assumption: sata address is already validated.
|
|
|
6529 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of
|
|
|
6530 * the presence of a device and its type.
|
|
|
6531 * SATA_FAILURE is returned if one of the operations failed.
|
|
|
6532 */
|
|
|
6533 static int
|
|
|
6534 sata_reprobe_port(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
|
|
|
6535 {
|
|
|
6536 sata_cport_info_t *cportinfo;
|
|
|
6537 sata_drive_info_t *sdinfo;
|
|
|
6538 int rval;
|
|
|
6539
|
|
|
6540 /* We only care about host sata cport for now */
|
|
|
6541 cportinfo = SATA_CPORT_INFO(sata_hba_inst,
|
|
|
6542 sata_device->satadev_addr.cport);
|
|
|
6543 /* probe port */
|
|
|
6544 mutex_enter(&cportinfo->cport_mutex);
|
|
|
6545 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
|
|
|
6546 cportinfo->cport_state |= SATA_STATE_PROBING;
|
|
|
6547 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6548
|
|
|
6549 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
|
|
|
6550 (SATA_DIP(sata_hba_inst), sata_device);
|
|
|
6551
|
|
|
6552 mutex_enter(&cportinfo->cport_mutex);
|
|
|
6553 if (rval != SATA_SUCCESS) {
|
|
|
6554 cportinfo->cport_state = SATA_PSTATE_FAILED;
|
|
|
6555 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6556 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_hba_ioctl: "
|
|
|
6557 "connect: port probbing failed"));
|
|
|
6558 return (SATA_FAILURE);
|
|
|
6559 }
|
|
|
6560
|
|
|
6561 /*
|
|
|
6562 * update sata port state and set device type
|
|
|
6563 */
|
|
|
6564 sata_update_port_info(sata_hba_inst, sata_device);
|
|
|
6565 cportinfo->cport_state |= SATA_STATE_PROBED;
|
|
|
6566
|
|
|
6567 /*
|
|
|
6568 * Sanity check - Port is active? Is the link active?
|
|
|
6569 * Is there any device attached?
|
|
|
6570 */
|
|
|
6571 if ((cportinfo->cport_state &
|
|
|
6572 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
|
|
|
6573 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
|
|
|
6574 SATA_PORT_DEVLINK_UP) {
|
|
|
6575 /*
|
|
|
6576 * Port in non-usable state or no link active/no device.
|
|
|
6577 * Free info structure if necessary (direct attached drive
|
|
|
6578 * only, for now!
|
|
|
6579 */
|
|
|
6580 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
|
|
|
6581 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
|
|
|
6582 /* Add here differentiation for device attached or not */
|
|
|
6583 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
|
|
|
6584 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6585 if (sdinfo != NULL)
|
|
|
6586 kmem_free(sdinfo, sizeof (sata_drive_info_t));
|
|
|
6587 return (SATA_SUCCESS);
|
|
|
6588 }
|
|
|
6589
|
|
|
6590 cportinfo->cport_state |= SATA_STATE_READY;
|
|
|
6591 cportinfo->cport_dev_type = sata_device->satadev_type;
|
|
|
6592 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
|
|
|
6593
|
|
|
6594 /*
|
|
|
6595 * If we are re-probing the port, there may be
|
|
|
6596 * sata_drive_info structure attached
|
|
|
6597 * (or sata_pm_info, if PMult is supported).
|
|
|
6598 */
|
|
|
6599 if (sata_device->satadev_type == SATA_DTYPE_NONE) {
|
|
|
6600 /*
|
|
|
6601 * There is no device, so remove device info structure,
|
|
|
6602 * if necessary. Direct attached drive only!
|
|
|
6603 */
|
|
|
6604 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
|
|
|
6605 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
|
|
|
6606 if (sdinfo != NULL) {
|
|
|
6607 kmem_free(sdinfo, sizeof (sata_drive_info_t));
|
|
|
6608 sata_log(sata_hba_inst, CE_WARN,
|
|
|
6609 "SATA device detached "
|
|
|
6610 "from port %d", cportinfo->cport_addr.cport);
|
|
|
6611 }
|
|
|
6612 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6613 return (SATA_SUCCESS);
|
|
|
6614 }
|
|
|
6615
|
|
|
6616 if (sata_device->satadev_type != SATA_DTYPE_PMULT) {
|
|
|
6617 if (sdinfo == NULL) {
|
|
|
6618 /*
|
|
|
6619 * There is some device attached, but there is
|
|
|
6620 * no sata_drive_info structure - allocate one
|
|
|
6621 */
|
|
|
6622 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6623 sdinfo = kmem_zalloc(
|
|
|
6624 sizeof (sata_drive_info_t), KM_SLEEP);
|
|
|
6625 mutex_enter(&cportinfo->cport_mutex);
|
|
|
6626 /*
|
|
|
6627 * Recheck, if port state did not change when we
|
|
|
6628 * released mutex.
|
|
|
6629 */
|
|
|
6630 if (cportinfo->cport_state & SATA_STATE_READY) {
|
|
|
6631 SATA_CPORTINFO_DRV_INFO(cportinfo) = sdinfo;
|
|
|
6632 sdinfo->satadrv_addr = cportinfo->cport_addr;
|
|
|
6633 sdinfo->satadrv_addr.qual = SATA_ADDR_DCPORT;
|
|
|
6634 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
|
|
|
6635 sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
|
|
|
6636 sata_log(sata_hba_inst, CE_WARN,
|
|
|
6637 "SATA device attached to port %d",
|
|
|
6638 cportinfo->cport_addr.cport);
|
|
|
6639 } else {
|
|
|
6640 /*
|
|
|
6641 * Port is not in ready state, we
|
|
|
6642 * cannot attach a device.
|
|
|
6643 */
|
|
|
6644 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6645 kmem_free(sdinfo, sizeof (sata_drive_info_t));
|
|
|
6646 return (SATA_SUCCESS);
|
|
|
6647 }
|
|
|
6648 }
|
|
|
6649
|
|
|
6650 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
|
|
|
6651 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual;
|
|
|
6652 } else {
|
|
|
6653 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
|
|
|
6654 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6655 return (SATA_SUCCESS);
|
|
|
6656 }
|
|
|
6657 mutex_exit(&cportinfo->cport_mutex);
|
|
|
6658 /*
|
|
|
6659 * Figure out what kind of device we are really
|
|
|
6660 * dealing with.
|
|
|
6661 */
|
|
|
6662 return (sata_probe_device(sata_hba_inst, sata_device));
|
|
|
6663 }
|
|
|
6664
|
|
|
6665
|
|
|
6666 /*
|
|
|
6667 * Validate sata address.
|
|
|
6668 * Specified cport, pmport and qualifier has to match
|
|
|
6669 * passed sata_scsi configuration info.
|
|
|
6670 * The presence of an attached device is not verified.
|
|
|
6671 *
|
|
|
6672 * Returns 0 when address is valid, -1 otherwise.
|
|
|
6673 */
|
|
|
6674 static int
|
|
|
6675 sata_validate_sata_address(sata_hba_inst_t *sata_hba_inst, int cport,
|
|
|
6676 int pmport, int qual)
|
|
|
6677 {
|
|
|
6678 if (qual == SATA_ADDR_DCPORT && pmport != 0)
|
|
|
6679 goto invalid_address;
|
|
|
6680 if (cport >= SATA_NUM_CPORTS(sata_hba_inst))
|
|
|
6681 goto invalid_address;
|
|
|
6682 if ((qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) &&
|
|
|
6683 ((SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != SATA_DTYPE_PMULT) ||
|
|
|
6684 (SATA_PMULT_INFO(sata_hba_inst, cport) == NULL) ||
|
|
|
6685 (pmport >= SATA_NUM_PMPORTS(sata_hba_inst, cport))))
|
|
|
6686 goto invalid_address;
|
|
|
6687
|
|
|
6688 return (0);
|
|
|
6689
|
|
|
6690 invalid_address:
|
|
|
6691 return (-1);
|
|
|
6692
|
|
|
6693 }
|
|
|
6694
|
|
|
6695 /*
|
|
|
6696 * Validate scsi address
|
|
|
6697 * SCSI target address is translated into SATA cport/pmport and compared
|
|
|
6698 * with a controller port/device configuration. LUN has to be 0.
|
|
|
6699 * Returns 0 if a scsi target refers to an attached device,
|
|
|
6700 * returns 1 if address is valid but device is not attached,
|
|
|
6701 * returns -1 if bad address or device is of an unsupported type.
|
|
|
6702 * Upon return sata_device argument is set.
|
|
|
6703 */
|
|
|
6704 static int
|
|
|
6705 sata_validate_scsi_address(sata_hba_inst_t *sata_hba_inst,
|
|
|
6706 struct scsi_address *ap, sata_device_t *sata_device)
|
|
|
6707 {
|
|
|
6708 int cport, pmport, qual, rval;
|
|
|
6709
|
|
|
6710 rval = -1; /* Invalid address */
|
|
|
6711 if (ap->a_lun != 0)
|
|
|
6712 goto out;
|
|
|
6713
|
|
|
6714 qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target);
|
|
|
6715 cport = SCSI_TO_SATA_CPORT(ap->a_target);
|
|
|
6716 pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
|
|
|
6717
|
|
|
6718 if (qual != SATA_ADDR_DCPORT && qual != SATA_ADDR_DPMPORT)
|
|
|
6719 goto out;
|
|
|
6720
|
|
|
6721 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, qual) ==
|
|
|
6722 0) {
|
|
|
6723
|
|
|
6724 sata_cport_info_t *cportinfo;
|
|
|
6725 sata_pmult_info_t *pmultinfo;
|
|
|
6726 sata_drive_info_t *sdinfo = NULL;
|
|
|
6727
|
|
|
6728 rval = 1; /* Valid sata address */
|
|
|
6729
|
|
|
6730 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
|
|
|
6731 if (qual == SATA_ADDR_DCPORT) {
|
|
|
6732 if (cportinfo == NULL ||
|
|
|
6733 cportinfo->cport_dev_type == SATA_DTYPE_NONE)
|
|
|
6734 goto out;
|
|
|
6735
|
|
|
6736 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT ||
|
|
|
6737 (cportinfo->cport_dev_type &
|
|
|
6738 SATA_VALID_DEV_TYPE) == 0) {
|
|
|
6739 rval = -1;
|
|
|
6740 goto out;
|
|
|
6741 }
|
|
|
6742 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
|
|
|
6743
|
|
|
6744 } else if (qual == SATA_ADDR_DPMPORT) {
|
|
|
6745 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
|
|
|
6746 if (pmultinfo == NULL) {
|
|
|
6747 rval = -1;
|
|
|
6748 goto out;
|
|
|
6749 }
|
|
|
6750 if (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport) ==
|
|
|
6751 NULL ||
|
|
|
6752 SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport,
|
|
|
6753 pmport) == SATA_DTYPE_NONE)
|
|
|
6754 goto out;
|
|
|
6755
|
|
|
6756 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport,
|
|
|
6757 pmport);
|
|
|
6758 } else {
|
|
|
6759 rval = -1;
|
|
|
6760 goto out;
|
|
|
6761 }
|
|
|
6762 if ((sdinfo == NULL) ||
|
|
|
6763 (sdinfo->satadrv_type & SATA_VALID_DEV_TYPE) == 0)
|
|
|
6764 goto out;
|
|
|
6765
|
|
|
6766 sata_device->satadev_type = sdinfo->satadrv_type;
|
|
|
6767 sata_device->satadev_addr.qual = qual;
|
|
|
6768 sata_device->satadev_addr.cport = cport;
|
|
|
6769 sata_device->satadev_addr.pmport = pmport;
|
|
|
6770 sata_device->satadev_rev = SATA_DEVICE_REV_1;
|
|
|
6771 return (0);
|
|
|
6772 }
|
|
|
6773 out:
|
|
|
6774 if (rval == 1) {
|
|
|
6775 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
|
|
|
6776 "sata_validate_scsi_address: no valid target %x lun %x",
|
|
|
6777 ap->a_target, ap->a_lun);
|
|
|
6778 }
|
|
|
6779 return (rval);
|
|
|
6780 }
|
|
|
6781
|
|
|
6782 /*
|
|
|
6783 * Find dip corresponding to passed device number
|
|
|
6784 *
|
|
|
6785 * Returns NULL if invalid device number is passed or device cannot be found,
|
|
|
6786 * Returns dip is device is found.
|
|
|
6787 */
|
|
|
6788 static dev_info_t *
|
|
|
6789 sata_devt_to_devinfo(dev_t dev)
|
|
|
6790 {
|
|
|
6791 dev_info_t *dip;
|
|
|
6792 #ifndef __lock_lint
|
|
|
6793 struct devnames *dnp;
|
|
|
6794 major_t major = getmajor(dev);
|
|
|
6795 int instance = SATA_MINOR2INSTANCE(getminor(dev));
|
|
|
6796
|
|
|
6797 if (major >= devcnt)
|
|
|
6798 return (NULL);
|
|
|
6799
|
|
|
6800 dnp = &devnamesp[major];
|
|
|
6801 LOCK_DEV_OPS(&(dnp->dn_lock));
|
|
|
6802 dip = dnp->dn_head;
|
|
|
6803 while (dip && (ddi_get_instance(dip) != instance)) {
|
|
|
6804 dip = ddi_get_next(dip);
|
|
|
6805 }
|
|
|
6806 UNLOCK_DEV_OPS(&(dnp->dn_lock));
|
|
|
6807 #endif
|
|
|
6808
|
|
|
6809 return (dip);
|
|
|
6810 }
|
|
|
6811
|
|
|
6812
|
|
|
6813 /*
|
|
|
6814 * Probe device.
|
|
|
6815 * This function issues Identify Device command and initialize local
|
|
|
6816 * sata_drive_info structure if the device can be identified.
|
|
|
6817 * The device type is determined by examining Identify Device
|
|
|
6818 * command response.
|
|
|
6819 * If the sata_hba_inst has linked drive info structure for this
|
|
|
6820 * device address, the Identify Device data is stored into sata_drive_info
|
|
|
6821 * structure linked to the port info structure.
|
|
|
6822 *
|
|
|
6823 * sata_device has to refer to the valid sata port(s) for HBA described
|
|
|
6824 * by sata_hba_inst structure.
|
|
|
6825 *
|
|
|
6826 * Returns: SATA_SUCCESS if device type was successfully probed and port-linked
|
|
|
6827 * drive info structure was updated;
|
|
|
6828 * SATA_FAILURE if there is no device, or device was not probed
|
|
|
6829 * successully.
|
|
|
6830 * If a device cannot be identified, sata_device's dev_state and dev_type
|
|
|
6831 * fields are set to unknown.
|
|
|
6832 *
|
|
|
6833 */
|
|
|
6834
|
|
|
6835 static int
|
|
|
6836 sata_probe_device(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
|
|
|
6837 {
|
|
|
6838 sata_drive_info_t *sdinfo;
|
|
|
6839 sata_drive_info_t new_sdinfo; /* local drive info struct */
|
|
|
6840 int retry_cnt;
|
|
|
6841
|
|
|
6842 ASSERT((SATA_CPORT_STATE(sata_hba_inst,
|
|
|
6843 sata_device->satadev_addr.cport) &
|
|
|
6844 (SATA_STATE_PROBED | SATA_STATE_READY)) != 0);
|
|
|
6845
|
|
|
6846 sata_device->satadev_type = SATA_DTYPE_NONE;
|
|
|
6847
|
|
|
6848 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
6849 sata_device->satadev_addr.cport)));
|
|
|
6850
|
|
|
6851 /* Get pointer to port-linked sata device info structure */
|
|
|
6852 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
|
|
|
6853 if (sdinfo != NULL) {
|
|
|
6854 sdinfo->satadrv_state &=
|
|
|
6855 ~(SATA_STATE_PROBED | SATA_STATE_READY);
|
|
|
6856 sdinfo->satadrv_state |= SATA_STATE_PROBING;
|
|
|
6857 } else {
|
|
|
6858 /* No device to probe */
|
|
|
6859 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
6860 sata_device->satadev_addr.cport)));
|
|
|
6861 sata_device->satadev_type = SATA_DTYPE_NONE;
|
|
|
6862 sata_device->satadev_state = SATA_STATE_UNKNOWN;
|
|
|
6863 return (SATA_FAILURE);
|
|
|
6864 }
|
|
|
6865 /*
|
|
|
6866 * Need to issue both types of identify device command and
|
|
|
6867 * determine device type by examining retreived data/status.
|
|
|
6868 * First, ATA Identify Device.
|
|
|
6869 */
|
|
|
6870 bzero(&new_sdinfo, sizeof (sata_drive_info_t));
|
|
|
6871 new_sdinfo.satadrv_addr = sata_device->satadev_addr;
|
|
|
6872 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
6873 sata_device->satadev_addr.cport)));
|
|
|
6874 for (retry_cnt = 0; retry_cnt <= SATA_DEVICE_IDENTIFY_RETRY;
|
|
|
6875 retry_cnt++) {
|
|
|
6876 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK;
|
|
|
6877 if (sata_identify_device(sata_hba_inst, &new_sdinfo) == 0) {
|
|
|
6878 /* Got something responding to ATA Identify Device */
|
|
|
6879 if (sata_set_udma_mode(sata_hba_inst, &new_sdinfo) !=
|
|
|
6880 SATA_SUCCESS) {
|
|
|
6881 /* Try one more time */
|
|
|
6882 if (sata_set_udma_mode(sata_hba_inst,
|
|
|
6883 &new_sdinfo) != SATA_SUCCESS)
|
|
|
6884 goto failure;
|
|
|
6885 }
|
|
|
6886 sata_device->satadev_type = new_sdinfo.satadrv_type;
|
|
|
6887 break;
|
|
|
6888 }
|
|
|
6889 if (SATA_FEATURES(sata_hba_inst) & SATA_CTLF_ATAPI) {
|
|
|
6890 /*
|
|
|
6891 * HBA supports ATAPI - try to issue Identify Packet
|
|
|
6892 * Device command.
|
|
|
6893 */
|
|
|
6894 new_sdinfo.satadrv_type = SATA_DTYPE_ATAPICD;
|
|
|
6895 if (sata_identify_device(sata_hba_inst,
|
|
|
6896 &new_sdinfo) == 0) {
|
|
|
6897 /*
|
|
|
6898 * Got something responding to Identify Packet
|
|
|
6899 * Device cmd.
|
|
|
6900 */
|
|
|
6901 /* Set UDMA mode here as well ? - phase 2 */
|
|
|
6902 sata_device->satadev_type =
|
|
|
6903 new_sdinfo.satadrv_type;
|
|
|
6904 break;
|
|
|
6905 }
|
|
|
6906 }
|
|
|
6907 }
|
|
|
6908 if (retry_cnt <= SATA_DEVICE_IDENTIFY_RETRY) {
|
|
|
6909 /* save device info, if possible */
|
|
|
6910 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
6911 sata_device->satadev_addr.cport)));
|
|
|
6912 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
|
|
|
6913 if (sdinfo == NULL) {
|
|
|
6914 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
6915 sata_device->satadev_addr.cport)));
|
|
|
6916 return (SATA_FAILURE);
|
|
|
6917 }
|
|
|
6918 /*
|
|
|
6919 * Copy drive info into the port-linked drive info structure.
|
|
|
6920 */
|
|
|
6921 *sdinfo = new_sdinfo;
|
|
|
6922 sdinfo->satadrv_state &= ~SATA_STATE_PROBING;
|
|
|
6923 sdinfo->satadrv_state |= SATA_STATE_PROBED;
|
|
|
6924 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
|
|
|
6925 SATA_CPORT_DEV_TYPE(sata_hba_inst,
|
|
|
6926 sata_device->satadev_addr.cport) =
|
|
|
6927 sdinfo->satadrv_type;
|
|
|
6928 else /* SATA_ADDR_DPMPORT */
|
|
|
6929 SATA_PMPORT_DEV_TYPE(sata_hba_inst,
|
|
|
6930 sata_device->satadev_addr.cport,
|
|
|
6931 sata_device->satadev_addr.pmport) =
|
|
|
6932 sdinfo->satadrv_type;
|
|
|
6933 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
6934 sata_device->satadev_addr.cport)));
|
|
|
6935 return (SATA_SUCCESS);
|
|
|
6936 }
|
|
|
6937
|
|
|
6938 failure:
|
|
|
6939 /*
|
|
|
6940 * Looks like we cannot determine the device type.
|
|
|
6941 */
|
|
|
6942 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
6943 sata_device->satadev_addr.cport)));
|
|
|
6944 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
|
|
|
6945 if (sdinfo != NULL) {
|
|
|
6946 sata_device->satadev_type = SATA_DTYPE_UNKNOWN;
|
|
|
6947 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
|
|
|
6948 sdinfo->satadrv_state &= ~SATA_STATE_PROBING;
|
|
|
6949 sdinfo->satadrv_state = SATA_STATE_PROBED;
|
|
|
6950 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
|
|
|
6951 SATA_CPORT_DEV_TYPE(sata_hba_inst,
|
|
|
6952 sata_device->satadev_addr.cport) =
|
|
|
6953 SATA_DTYPE_UNKNOWN;
|
|
|
6954 else {
|
|
|
6955 /* SATA_ADDR_DPMPORT */
|
|
|
6956 if ((SATA_PMULT_INFO(sata_hba_inst,
|
|
|
6957 sata_device->satadev_addr.cport) != NULL) &&
|
|
|
6958 (SATA_PMPORT_INFO(sata_hba_inst,
|
|
|
6959 sata_device->satadev_addr.cport,
|
|
|
6960 sata_device->satadev_addr.pmport) != NULL))
|
|
|
6961 SATA_PMPORT_DEV_TYPE(sata_hba_inst,
|
|
|
6962 sata_device->satadev_addr.cport,
|
|
|
6963 sata_device->satadev_addr.pmport) =
|
|
|
6964 SATA_DTYPE_UNKNOWN;
|
|
|
6965 }
|
|
|
6966 }
|
|
|
6967 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
6968 sata_device->satadev_addr.cport)));
|
|
|
6969 return (SATA_FAILURE);
|
|
|
6970 }
|
|
|
6971
|
|
|
6972
|
|
|
6973 /*
|
|
|
6974 * Get pointer to sata_drive_info structure.
|
|
|
6975 *
|
|
|
6976 * The sata_device has to contain address (cport, pmport and qualifier) for
|
|
|
6977 * specified sata_scsi structure.
|
|
|
6978 *
|
|
|
6979 * Returns NULL if device address is not valid for this HBA configuration.
|
|
|
6980 * Otherwise, returns a pointer to sata_drive_info structure.
|
|
|
6981 *
|
|
|
6982 * This function should be called with a port mutex held.
|
|
|
6983 */
|
|
|
6984 static sata_drive_info_t *
|
|
|
6985 sata_get_device_info(sata_hba_inst_t *sata_hba_inst,
|
|
|
6986 sata_device_t *sata_device)
|
|
|
6987 {
|
|
|
6988 uint8_t cport = sata_device->satadev_addr.cport;
|
|
|
6989 uint8_t pmport = sata_device->satadev_addr.pmport;
|
|
|
6990 uint8_t qual = sata_device->satadev_addr.qual;
|
|
|
6991
|
|
|
6992 if (cport >= SATA_NUM_CPORTS(sata_hba_inst))
|
|
|
6993 return (NULL);
|
|
|
6994
|
|
|
6995 if (!(SATA_CPORT_STATE(sata_hba_inst, cport) &
|
|
|
6996 (SATA_STATE_PROBED | SATA_STATE_READY)))
|
|
|
6997 /* Port not probed yet */
|
|
|
6998 return (NULL);
|
|
|
6999
|
|
|
7000 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_NONE)
|
|
|
7001 return (NULL);
|
|
|
7002
|
|
|
7003 if (qual == SATA_ADDR_DCPORT) {
|
|
|
7004 /* Request for a device on a controller port */
|
|
|
7005 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) ==
|
|
|
7006 SATA_DTYPE_PMULT)
|
|
|
7007 /* Port multiplier attached */
|
|
|
7008 return (NULL);
|
|
|
7009 return (SATA_CPORT_DRV_INFO(sata_hba_inst, cport));
|
|
|
7010 }
|
|
|
7011 if (qual == SATA_ADDR_DPMPORT) {
|
|
|
7012 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
|
|
|
7013 SATA_DTYPE_PMULT)
|
|
|
7014 return (NULL);
|
|
|
7015
|
|
|
7016 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport))
|
|
|
7017 return (NULL);
|
|
|
7018
|
|
|
7019 return (SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport));
|
|
|
7020 }
|
|
|
7021
|
|
|
7022 /* we should not get here */
|
|
|
7023 return (NULL);
|
|
|
7024 }
|
|
|
7025
|
|
|
7026
|
|
|
7027 /*
|
|
|
7028 * sata_identify_device.
|
|
|
7029 * Send Identify Device command to SATA HBA driver.
|
|
|
7030 * If command executes successfully, update sata_drive_info structure pointed
|
|
|
7031 * to by sdinfo argument, including Identify Device data.
|
|
|
7032 * If command fails, invalidate data in sata_drive_info.
|
|
|
7033 *
|
|
|
7034 * Cannot be called from interrupt level.
|
|
|
7035 *
|
|
|
7036 * Returns 0 if device was identified as supported device, -1 otherwise.
|
|
|
7037 */
|
|
|
7038 static int
|
|
|
7039 sata_identify_device(sata_hba_inst_t *sata_hba_inst,
|
|
|
7040 sata_drive_info_t *sdinfo)
|
|
|
7041 {
|
|
|
7042 uint16_t cfg_word;
|
|
|
7043 int i;
|
|
|
7044
|
|
|
7045 /* fetch device identify data */
|
|
|
7046 if (sata_fetch_device_identify_data(sata_hba_inst, sdinfo) != 0)
|
|
|
7047 goto fail_unknown;
|
|
|
7048
|
|
|
7049 cfg_word = sdinfo->satadrv_id.ai_config;
|
|
|
7050 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK &&
|
|
|
7051 (cfg_word & SATA_ATA_TYPE_MASK) != SATA_ATA_TYPE) {
|
|
|
7052 /* Change device type to reflect Identify Device data */
|
|
|
7053 if (((cfg_word & SATA_ATAPI_TYPE_MASK) ==
|
|
|
7054 SATA_ATAPI_TYPE) &&
|
|
|
7055 ((cfg_word & SATA_ATAPI_ID_DEV_TYPE) ==
|
|
|
7056 SATA_ATAPI_CDROM_DEV)) {
|
|
|
7057 sdinfo->satadrv_type = SATA_DTYPE_ATAPICD;
|
|
|
7058 } else {
|
|
|
7059 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
|
|
|
7060 }
|
|
|
7061 } else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD &&
|
|
|
7062 (((cfg_word & SATA_ATAPI_TYPE_MASK) != SATA_ATAPI_TYPE) ||
|
|
|
7063 ((cfg_word & SATA_ATAPI_ID_DEV_TYPE) != SATA_ATAPI_CDROM_DEV))) {
|
|
|
7064 /* Change device type to reflect Identify Device data ! */
|
|
|
7065 if ((sdinfo->satadrv_id.ai_config & SATA_ATA_TYPE_MASK) ==
|
|
|
7066 SATA_ATA_TYPE) {
|
|
|
7067 sdinfo->satadrv_type = SATA_DTYPE_ATADISK;
|
|
|
7068 } else {
|
|
|
7069 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
|
|
|
7070 }
|
|
|
7071 }
|
|
|
7072 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
|
|
|
7073 if (sdinfo->satadrv_capacity == 0) {
|
|
|
7074 /* Non-LBA disk. Too bad... */
|
|
|
7075 sata_log(sata_hba_inst, CE_WARN,
|
|
|
7076 "SATA disk device at port %d does not support LBA",
|
|
|
7077 sdinfo->satadrv_addr.cport);
|
|
|
7078 goto fail_unknown;
|
|
|
7079 }
|
|
|
7080 }
|
|
|
7081 /* Check for Ultra DMA modes 6 through 0 being supported */
|
|
|
7082 for (i = 6; i >= 0; --i) {
|
|
|
7083 if (sdinfo->satadrv_id.ai_ultradma & (1 << i))
|
|
|
7084 break;
|
|
|
7085 }
|
|
|
7086 /*
|
|
|
7087 * At least UDMA 4 mode has to be supported. If mode 4 or
|
|
|
7088 * higher are not supported by the device, fail this
|
|
|
7089 * device.
|
|
|
7090 */
|
|
|
7091 if (i < 4) {
|
|
|
7092 /* No required Ultra DMA mode supported */
|
|
|
7093 sata_log(sata_hba_inst, CE_WARN,
|
|
|
7094 "SATA disk device at port %d does not support UDMA "
|
|
|
7095 "mode 4 or higher", sdinfo->satadrv_addr.cport);
|
|
|
7096 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
7097 "mode 4 or higher required, %d supported", i));
|
|
|
7098 goto fail_unknown;
|
|
|
7099 }
|
|
|
7100
|
|
|
7101 return (0);
|
|
|
7102
|
|
|
7103 fail_unknown:
|
|
|
7104 /* Invalidate sata_drive_info ? */
|
|
|
7105 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
|
|
|
7106 sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
|
|
|
7107 return (-1);
|
|
|
7108 }
|
|
|
7109
|
|
|
7110 /*
|
|
|
7111 * Log/display device information
|
|
|
7112 */
|
|
|
7113 static void
|
|
|
7114 sata_show_drive_info(sata_hba_inst_t *sata_hba_inst,
|
|
|
7115 sata_drive_info_t *sdinfo)
|
|
|
7116 {
|
|
|
7117 int valid_version;
|
|
|
7118 char msg_buf[MAXPATHLEN];
|
|
|
7119
|
|
|
7120 /* Show HBA path */
|
|
|
7121 (void) ddi_pathname(SATA_DIP(sata_hba_inst), msg_buf);
|
|
|
7122
|
|
|
7123 cmn_err(CE_CONT, "?%s :\n", msg_buf);
|
|
|
7124
|
|
|
7125 if (sdinfo->satadrv_type == SATA_DTYPE_UNKNOWN) {
|
|
|
7126 (void) sprintf(msg_buf,
|
|
|
7127 "Unsupported SATA device type (cfg 0x%x) at ",
|
|
|
7128 sdinfo->satadrv_id.ai_config);
|
|
|
7129 } else {
|
|
|
7130 (void) sprintf(msg_buf, "SATA %s device at",
|
|
|
7131 sdinfo->satadrv_type == SATA_DTYPE_ATADISK ?
|
|
|
7132 "disk":"CD/DVD (ATAPI)");
|
|
|
7133 }
|
|
|
7134 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DCPORT)
|
|
|
7135 cmn_err(CE_CONT, "?\t%s port %d\n",
|
|
|
7136 msg_buf, sdinfo->satadrv_addr.cport);
|
|
|
7137 else
|
|
|
7138 cmn_err(CE_CONT, "?\t%s port %d pmport %d\n",
|
|
|
7139 msg_buf, sdinfo->satadrv_addr.cport,
|
|
|
7140 sdinfo->satadrv_addr.pmport);
|
|
|
7141
|
|
|
7142 bcopy(&sdinfo->satadrv_id.ai_model, msg_buf,
|
|
|
7143 sizeof (sdinfo->satadrv_id.ai_model));
|
|
|
7144 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_model));
|
|
|
7145 msg_buf[sizeof (sdinfo->satadrv_id.ai_model)] = '\0';
|
|
|
7146 cmn_err(CE_CONT, "?\tmodel %s\n", msg_buf);
|
|
|
7147
|
|
|
7148 bcopy(&sdinfo->satadrv_id.ai_fw, msg_buf,
|
|
|
7149 sizeof (sdinfo->satadrv_id.ai_fw));
|
|
|
7150 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_fw));
|
|
|
7151 msg_buf[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0';
|
|
|
7152 cmn_err(CE_CONT, "?\tfirmware %s\n", msg_buf);
|
|
|
7153
|
|
|
7154 bcopy(&sdinfo->satadrv_id.ai_drvser, msg_buf,
|
|
|
7155 sizeof (sdinfo->satadrv_id.ai_drvser));
|
|
|
7156 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_drvser));
|
|
|
7157 msg_buf[sizeof (sdinfo->satadrv_id.ai_drvser)] = '\0';
|
|
|
7158 cmn_err(CE_CONT, "?\tserial number %sn", msg_buf);
|
|
|
7159
|
|
|
7160 #ifdef SATA_DEBUG
|
|
|
7161 if (sdinfo->satadrv_id.ai_majorversion != 0 &&
|
|
|
7162 sdinfo->satadrv_id.ai_majorversion != 0xffff) {
|
|
|
7163 int i;
|
|
|
7164 for (i = 14; i >= 2; i--) {
|
|
|
7165 if (sdinfo->satadrv_id.ai_majorversion & (1 << i)) {
|
|
|
7166 valid_version = i;
|
|
|
7167 break;
|
|
|
7168 }
|
|
|
7169 }
|
|
|
7170 cmn_err(CE_CONT,
|
|
|
7171 "?\tATA/ATAPI-%d supported, majver 0x%x minver 0x%x\n",
|
|
|
7172 valid_version,
|
|
|
7173 sdinfo->satadrv_id.ai_majorversion,
|
|
|
7174 sdinfo->satadrv_id.ai_minorversion);
|
|
|
7175 }
|
|
|
7176 #endif
|
|
|
7177 /* Log some info */
|
|
|
7178 cmn_err(CE_CONT, "?\tsupported features:\n");
|
|
|
7179 msg_buf[0] = '\0';
|
|
|
7180 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48)
|
|
|
7181 (void) strlcat(msg_buf, "48-bit LBA", MAXPATHLEN);
|
|
|
7182 else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28)
|
|
|
7183 (void) strlcat(msg_buf, "28-bit LBA", MAXPATHLEN);
|
|
|
7184 if (sdinfo->satadrv_features_support & SATA_DEV_F_DMA)
|
|
|
7185 (void) strlcat(msg_buf, ", DMA", MAXPATHLEN);
|
|
|
7186 if (sdinfo->satadrv_features_support & SATA_DEV_F_NCQ)
|
|
|
7187 (void) strlcat(msg_buf, ", Native Command Queueing",
|
|
|
7188 MAXPATHLEN);
|
|
|
7189 else if (sdinfo->satadrv_id.ai_cmdset83 & SATA_RW_DMA_QUEUED_CMD)
|
|
|
7190 (void) strlcat(msg_buf, ", Queuing", MAXPATHLEN);
|
|
|
7191 cmn_err(CE_CONT, "?\t %s\n", msg_buf);
|
|
|
7192 if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA2)
|
|
|
7193 cmn_err(CE_CONT, "?\tSATA1 & SATA2 compatible\n");
|
|
|
7194 else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA1)
|
|
|
7195 cmn_err(CE_CONT, "?\tSATA1 compatible\n");
|
|
|
7196
|
|
|
7197 #ifdef __i386
|
|
|
7198 (void) sprintf(msg_buf, "\tcapacity = %llu sectors\n",
|
|
|
7199 sdinfo->satadrv_capacity);
|
|
|
7200 #else
|
|
|
7201 (void) sprintf(msg_buf, "\tcapacity = %lu sectors\n",
|
|
|
7202 sdinfo->satadrv_capacity);
|
|
|
7203 #endif
|
|
|
7204 cmn_err(CE_CONT, "?%s", msg_buf);
|
|
|
7205 }
|
|
|
7206
|
|
|
7207
|
|
|
7208 /*
|
|
|
7209 * sata_save_drive_settings extracts current setting of the device and stores
|
|
|
7210 * it for future reference, in case the device setup would need to be restored
|
|
|
7211 * after the device reset.
|
|
|
7212 *
|
|
|
7213 * At the moment only read ahead and write cache settings are saved, if the
|
|
|
7214 * device supports these features at all.
|
|
|
7215 */
|
|
|
7216 static void
|
|
|
7217 sata_save_drive_settings(sata_drive_info_t *sdinfo)
|
|
|
7218 {
|
|
|
7219 if (!(sdinfo->satadrv_id.ai_cmdset82 & SATA_LOOK_AHEAD) &&
|
|
|
7220 !(sdinfo->satadrv_id.ai_cmdset82 & SATA_WRITE_CACHE)) {
|
|
|
7221 /* None of the features is supported - do nothing */
|
|
|
7222 return;
|
|
|
7223 }
|
|
|
7224
|
|
|
7225 /* Current setting of Read Ahead (and Read Cache) */
|
|
|
7226 if (sdinfo->satadrv_id.ai_features85 & SATA_LOOK_AHEAD)
|
|
|
7227 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD;
|
|
|
7228 else
|
|
|
7229 sdinfo->satadrv_settings &= ~SATA_DEV_READ_AHEAD;
|
|
|
7230
|
|
|
7231 /* Current setting of Write Cache */
|
|
|
7232 if (sdinfo->satadrv_id.ai_features85 & SATA_WRITE_CACHE)
|
|
|
7233 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
|
|
|
7234 else
|
|
|
7235 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
|
|
|
7236 }
|
|
|
7237
|
|
|
7238
|
|
|
7239 /*
|
|
|
7240 * sata_check_capacity function determines a disk capacity
|
|
|
7241 * and addressing mode (LBA28/LBA48) by examining a disk identify device data.
|
|
|
7242 *
|
|
|
7243 * NOTE: CHS mode is not supported! If a device does not support LBA,
|
|
|
7244 * this function is not called.
|
|
|
7245 *
|
|
|
7246 * Returns device capacity in number of blocks, i.e. largest addressable LBA+1
|
|
|
7247 */
|
|
|
7248 static uint64_t
|
|
|
7249 sata_check_capacity(sata_drive_info_t *sdinfo)
|
|
|
7250 {
|
|
|
7251 uint64_t capacity = 0;
|
|
|
7252 int i;
|
|
|
7253
|
|
|
7254 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK ||
|
|
|
7255 !sdinfo->satadrv_id.ai_cap & SATA_LBA_SUPPORT)
|
|
|
7256 /* Capacity valid only for LBA-addressable disk devices */
|
|
|
7257 return (0);
|
|
|
7258
|
|
|
7259 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) &&
|
|
|
7260 (sdinfo->satadrv_id.ai_cmdset83 & SATA_EXT48) &&
|
|
|
7261 (sdinfo->satadrv_id.ai_features86 & SATA_EXT48)) {
|
|
|
7262 /* LBA48 mode supported and enabled */
|
|
|
7263 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA48 |
|
|
|
7264 SATA_DEV_F_LBA28;
|
|
|
7265 for (i = 3; i >= 0; --i) {
|
|
|
7266 capacity <<= 16;
|
|
|
7267 capacity += sdinfo->satadrv_id.ai_addrsecxt[i];
|
|
|
7268 }
|
|
|
7269 } else {
|
|
|
7270 capacity = sdinfo->satadrv_id.ai_addrsec[1];
|
|
|
7271 capacity <<= 16;
|
|
|
7272 capacity += sdinfo->satadrv_id.ai_addrsec[0];
|
|
|
7273 if (capacity >= 0x1000000)
|
|
|
7274 /* LBA28 mode */
|
|
|
7275 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA28;
|
|
|
7276 }
|
|
|
7277 return (capacity);
|
|
|
7278 }
|
|
|
7279
|
|
|
7280
|
|
|
7281 /*
|
|
|
7282 * Allocate consistent buffer for DMA transfer
|
|
|
7283 *
|
|
|
7284 * Cannot be called from interrupt level or with mutex held - it may sleep.
|
|
|
7285 *
|
|
|
7286 * Returns pointer to allocated buffer structure, or NULL if allocation failed.
|
|
|
7287 */
|
|
|
7288 static struct buf *
|
|
|
7289 sata_alloc_local_buffer(sata_pkt_txlate_t *spx, int len)
|
|
|
7290 {
|
|
|
7291 struct scsi_address ap;
|
|
|
7292 struct buf *bp;
|
|
|
7293 ddi_dma_attr_t cur_dma_attr;
|
|
|
7294
|
|
|
7295 ASSERT(spx->txlt_sata_pkt != NULL);
|
|
|
7296 ap.a_hba_tran = spx->txlt_sata_hba_inst->satahba_scsi_tran;
|
|
|
7297 ap.a_target = SATA_TO_SCSI_TARGET(
|
|
|
7298 spx->txlt_sata_pkt->satapkt_device.satadev_addr.cport,
|
|
|
7299 spx->txlt_sata_pkt->satapkt_device.satadev_addr.pmport,
|
|
|
7300 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual);
|
|
|
7301 ap.a_lun = 0;
|
|
|
7302
|
|
|
7303 bp = scsi_alloc_consistent_buf(&ap, NULL, len,
|
|
|
7304 B_READ, SLEEP_FUNC, NULL);
|
|
|
7305
|
|
|
7306 if (bp != NULL) {
|
|
|
7307 /* Allocate DMA resources for this buffer */
|
|
|
7308 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp;
|
|
|
7309 /*
|
|
|
7310 * We use a local version of the dma_attr, to account
|
|
|
7311 * for a device addressing limitations.
|
|
|
7312 * sata_adjust_dma_attr() will handle sdinfo == NULL which
|
|
|
7313 * will cause dma attributes to be adjusted to a lowest
|
|
|
7314 * acceptable level.
|
|
|
7315 */
|
|
|
7316 sata_adjust_dma_attr(NULL,
|
|
|
7317 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr);
|
|
|
7318
|
|
|
7319 if (sata_dma_buf_setup(spx, PKT_CONSISTENT,
|
|
|
7320 SLEEP_FUNC, NULL, &cur_dma_attr) != DDI_SUCCESS) {
|
|
|
7321 scsi_free_consistent_buf(bp);
|
|
|
7322 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
|
|
|
7323 bp = NULL;
|
|
|
7324 }
|
|
|
7325 }
|
|
|
7326 return (bp);
|
|
|
7327 }
|
|
|
7328
|
|
|
7329 /*
|
|
|
7330 * Release local buffer (consistent buffer for DMA transfer) allocated
|
|
|
7331 * via sata_alloc_local_buffer().
|
|
|
7332 */
|
|
|
7333 static void
|
|
|
7334 sata_free_local_buffer(sata_pkt_txlate_t *spx)
|
|
|
7335 {
|
|
|
7336 ASSERT(spx->txlt_sata_pkt != NULL);
|
|
|
7337 ASSERT(spx->txlt_dma_cookie_list != NULL);
|
|
|
7338 ASSERT(spx->txlt_dma_cookie_list_len != 0);
|
|
|
7339 ASSERT(spx->txlt_buf_dma_handle != NULL);
|
|
|
7340 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp != NULL);
|
|
|
7341
|
|
|
7342 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 0;
|
|
|
7343 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = NULL;
|
|
|
7344
|
|
|
7345 /* Free DMA resources */
|
|
|
7346 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle);
|
|
|
7347 ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
|
|
|
7348 spx->txlt_buf_dma_handle = 0;
|
|
|
7349
|
|
|
7350 kmem_free(spx->txlt_dma_cookie_list,
|
|
|
7351 spx->txlt_dma_cookie_list_len * sizeof (ddi_dma_cookie_t));
|
|
|
7352 spx->txlt_dma_cookie_list = NULL;
|
|
|
7353 spx->txlt_dma_cookie_list_len = 0;
|
|
|
7354
|
|
|
7355 /* Free buffer */
|
|
|
7356 scsi_free_consistent_buf(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp);
|
|
|
7357 }
|
|
|
7358
|
|
|
7359
|
|
|
7360
|
|
|
7361
|
|
|
7362 /*
|
|
|
7363 * Allocate sata_pkt
|
|
|
7364 * Pkt structure version and embedded strcutures version are initialized.
|
|
|
7365 * sata_pkt and sata_pkt_txlate structures are cross-linked.
|
|
|
7366 *
|
|
|
7367 * Since this may be called in interrupt context by sata_scsi_init_pkt,
|
|
|
7368 * callback argument determines if it can sleep or not.
|
|
|
7369 * Hence, it should not be called from interrupt context.
|
|
|
7370 *
|
|
|
7371 * If successful, non-NULL pointer to a sata pkt is returned.
|
|
|
7372 * Upon failure, NULL pointer is returned.
|
|
|
7373 */
|
|
|
7374 static sata_pkt_t *
|
|
|
7375 sata_pkt_alloc(sata_pkt_txlate_t *spx, int (*callback)(caddr_t))
|
|
|
7376 {
|
|
|
7377 sata_pkt_t *spkt;
|
|
|
7378 int kmsflag;
|
|
|
7379
|
|
|
7380 kmsflag = (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP;
|
|
|
7381 spkt = kmem_zalloc(sizeof (sata_pkt_t), kmsflag);
|
|
|
7382 if (spkt == NULL) {
|
|
|
7383 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
|
|
|
7384 "sata_pkt_alloc: failed"));
|
|
|
7385 return (NULL);
|
|
|
7386 }
|
|
|
7387 spkt->satapkt_rev = SATA_PKT_REV;
|
|
|
7388 spkt->satapkt_cmd.satacmd_rev = SATA_CMD_REV;
|
|
|
7389 spkt->satapkt_device.satadev_rev = SATA_DEVICE_REV;
|
|
|
7390 spkt->satapkt_framework_private = spx;
|
|
|
7391 spx->txlt_sata_pkt = spkt;
|
|
|
7392 return (spkt);
|
|
|
7393 }
|
|
|
7394
|
|
|
7395 /*
|
|
|
7396 * Free sata pkt allocated via sata_pkt_alloc()
|
|
|
7397 */
|
|
|
7398 static void
|
|
|
7399 sata_pkt_free(sata_pkt_txlate_t *spx)
|
|
|
7400 {
|
|
|
7401 ASSERT(spx->txlt_sata_pkt != NULL);
|
|
|
7402 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp == NULL);
|
|
|
7403 kmem_free(spx->txlt_sata_pkt, sizeof (sata_pkt_t));
|
|
|
7404 spx->txlt_sata_pkt = NULL;
|
|
|
7405 }
|
|
|
7406
|
|
|
7407
|
|
|
7408 /*
|
|
|
7409 * Adjust DMA attributes.
|
|
|
7410 * SCSI cmds block count is up to 24 bits, SATA cmd block count vary
|
|
|
7411 * from 8 bits to 16 bits, depending on a command being used.
|
|
|
7412 * Limiting max block count arbitrarily to 256 for all read/write
|
|
|
7413 * commands may affects performance, so check both the device and
|
|
|
7414 * controller capability before adjusting dma attributes.
|
|
|
7415 * For ATAPI CD/DVD dma granularity has to be adjusted as well,
|
|
|
7416 * because these devices support block size of 2k rather
|
|
|
7417 * then 512 bytes.
|
|
|
7418 */
|
|
|
7419 void
|
|
|
7420 sata_adjust_dma_attr(sata_drive_info_t *sdinfo, ddi_dma_attr_t *dma_attr,
|
|
|
7421 ddi_dma_attr_t *adj_dma_attr)
|
|
|
7422 {
|
|
|
7423 uint32_t count_max;
|
|
|
7424
|
|
|
7425 /* Copy original attributes */
|
|
|
7426 *adj_dma_attr = *dma_attr;
|
|
|
7427
|
|
|
7428 /*
|
|
|
7429 * Things to consider: device addressing capability,
|
|
|
7430 * "excessive" controller DMA capabilities.
|
|
|
7431 * If a device is being probed/initialized, there are
|
|
|
7432 * no device info - use default limits then.
|
|
|
7433 */
|
|
|
7434 if (sdinfo == NULL) {
|
|
|
7435 count_max = dma_attr->dma_attr_granular * 0x100;
|
|
|
7436 if (dma_attr->dma_attr_count_max > count_max)
|
|
|
7437 adj_dma_attr->dma_attr_count_max = count_max;
|
|
|
7438 if (dma_attr->dma_attr_maxxfer > count_max)
|
|
|
7439 adj_dma_attr->dma_attr_maxxfer = count_max;
|
|
|
7440 return;
|
|
|
7441 }
|
|
|
7442 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) {
|
|
|
7443 /* arbitrarily modify controller dma granularity */
|
|
|
7444 adj_dma_attr->dma_attr_granular = SATA_ATAPI_SECTOR_SIZE;
|
|
|
7445 }
|
|
|
7446
|
|
|
7447 if (sdinfo->satadrv_features_support & (SATA_DEV_F_LBA48)) {
|
|
|
7448 /*
|
|
|
7449 * 16-bit sector count may be used - we rely on
|
|
|
7450 * the assumption that only read and write cmds
|
|
|
7451 * will request more than 256 sectors worth of data
|
|
|
7452 */
|
|
|
7453 count_max = adj_dma_attr->dma_attr_granular * 0x10000;
|
|
|
7454 } else {
|
|
|
7455 /*
|
|
|
7456 * 8-bit sector count will be used - default limits
|
|
|
7457 * for dma attributes
|
|
|
7458 */
|
|
|
7459 count_max = adj_dma_attr->dma_attr_granular * 0x100;
|
|
|
7460 }
|
|
|
7461
|
|
|
7462
|
|
|
7463 /*
|
|
|
7464 * Adjust controler dma attributes, if necessary
|
|
|
7465 */
|
|
|
7466 if (dma_attr->dma_attr_count_max > count_max)
|
|
|
7467 adj_dma_attr->dma_attr_count_max = count_max;
|
|
|
7468 if (dma_attr->dma_attr_maxxfer > count_max)
|
|
|
7469 adj_dma_attr->dma_attr_maxxfer = count_max;
|
|
|
7470 }
|
|
|
7471
|
|
|
7472
|
|
|
7473 /*
|
|
|
7474 * Allocate DMA resources for the buffer
|
|
|
7475 * This function handles initial DMA resource allocation as well as
|
|
|
7476 * DMA window shift and may be called repeatedly for the same DMA window
|
|
|
7477 * until all DMA cookies in the DMA window are processed.
|
|
|
7478 *
|
|
|
7479 * Returns DDI_SUCCESS upon successful operation,
|
|
|
7480 * returns failure code returned by failing commands or DDI_FAILURE when
|
|
|
7481 * internal cleanup failed.
|
|
|
7482 */
|
|
|
7483 static int
|
|
|
7484 sata_dma_buf_setup(sata_pkt_txlate_t *spx, int flags,
|
|
|
7485 int (*callback)(caddr_t), caddr_t arg,
|
|
|
7486 ddi_dma_attr_t *cur_dma_attr)
|
|
|
7487 {
|
|
|
7488 int rval;
|
|
|
7489 ddi_dma_cookie_t cookie;
|
|
|
7490 off_t offset;
|
|
|
7491 size_t size;
|
|
|
7492 int max_sg_len, req_sg_len, i;
|
|
|
7493 uint_t dma_flags;
|
|
|
7494 struct buf *bp;
|
|
|
7495 uint64_t max_txfer_len;
|
|
|
7496 uint64_t cur_txfer_len;
|
|
|
7497
|
|
|
7498 ASSERT(spx->txlt_sata_pkt != NULL);
|
|
|
7499 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
|
|
|
7500 ASSERT(bp != NULL);
|
|
|
7501
|
|
|
7502
|
|
|
7503 if (spx->txlt_buf_dma_handle == NULL) {
|
|
|
7504 /*
|
|
|
7505 * No DMA resources allocated so far - this is a first call
|
|
|
7506 * for this sata pkt.
|
|
|
7507 */
|
|
|
7508 rval = ddi_dma_alloc_handle(SATA_DIP(spx->txlt_sata_hba_inst),
|
|
|
7509 cur_dma_attr, callback, arg, &spx->txlt_buf_dma_handle);
|
|
|
7510
|
|
|
7511 if (rval != DDI_SUCCESS) {
|
|
|
7512 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
|
|
|
7513 "sata_dma_buf_setup: no buf DMA resources %x",
|
|
|
7514 rval));
|
|
|
7515 return (rval);
|
|
|
7516 }
|
|
|
7517
|
|
|
7518 if (bp->b_flags & B_READ)
|
|
|
7519 dma_flags = DDI_DMA_READ;
|
|
|
7520 else
|
|
|
7521 dma_flags = DDI_DMA_WRITE;
|
|
|
7522
|
|
|
7523 if (flags & PKT_CONSISTENT)
|
|
|
7524 dma_flags |= DDI_DMA_CONSISTENT;
|
|
|
7525
|
|
|
7526 if (flags & PKT_DMA_PARTIAL)
|
|
|
7527 dma_flags |= DDI_DMA_PARTIAL;
|
|
|
7528
|
|
|
7529 rval = ddi_dma_buf_bind_handle(spx->txlt_buf_dma_handle,
|
|
|
7530 bp, dma_flags, callback, arg,
|
|
|
7531 &cookie, &spx->txlt_curwin_num_dma_cookies);
|
|
|
7532
|
|
|
7533 switch (rval) {
|
|
|
7534 case DDI_DMA_PARTIAL_MAP:
|
|
|
7535 SATADBG1(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
|
|
|
7536 "sata_dma_buf_setup: DMA Partial Map\n", NULL);
|
|
|
7537 /*
|
|
|
7538 * Partial DMA mapping.
|
|
|
7539 * Retrieve number of DMA windows for this request.
|
|
|
7540 */
|
|
|
7541 if (ddi_dma_numwin(spx->txlt_buf_dma_handle,
|
|
|
7542 &spx->txlt_num_dma_win) != DDI_SUCCESS) {
|
|
|
7543 (void) ddi_dma_unbind_handle(
|
|
|
7544 spx->txlt_buf_dma_handle);
|
|
|
7545 (void) ddi_dma_free_handle(
|
|
|
7546 &spx->txlt_buf_dma_handle);
|
|
|
7547 spx->txlt_buf_dma_handle = NULL;
|
|
|
7548 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
|
|
|
7549 "sata_dma_buf_setup: numwin failed\n"));
|
|
|
7550 return (DDI_FAILURE);
|
|
|
7551 }
|
|
|
7552 spx->txlt_cur_dma_win = 0;
|
|
|
7553 break;
|
|
|
7554
|
|
|
7555 case DDI_DMA_MAPPED:
|
|
|
7556 /* DMA fully mapped */
|
|
|
7557 spx->txlt_num_dma_win = 1;
|
|
|
7558 spx->txlt_cur_dma_win = 0;
|
|
|
7559 break;
|
|
|
7560
|
|
|
7561 default:
|
|
|
7562 /* DMA mapping failed */
|
|
|
7563 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
|
|
|
7564 spx->txlt_buf_dma_handle = NULL;
|
|
|
7565 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
|
|
|
7566 "sata_dma_buf_setup: buf dma handle binding "
|
|
|
7567 "failed %x\n", rval));
|
|
|
7568 return (rval);
|
|
|
7569 }
|
|
|
7570 spx->txlt_curwin_processed_dma_cookies = 0;
|
|
|
7571 spx->txlt_dma_cookie_list = NULL;
|
|
|
7572 } else {
|
|
|
7573 /*
|
|
|
7574 * DMA setup is reused. Check if we need to process more
|
|
|
7575 * cookies in current window, or to get next window, if any.
|
|
|
7576 */
|
|
|
7577
|
|
|
7578 ASSERT(spx->txlt_curwin_processed_dma_cookies <=
|
|
|
7579 spx->txlt_curwin_num_dma_cookies);
|
|
|
7580
|
|
|
7581 if (spx->txlt_curwin_processed_dma_cookies ==
|
|
|
7582 spx->txlt_curwin_num_dma_cookies) {
|
|
|
7583 /*
|
|
|
7584 * All cookies from current DMA window were processed.
|
|
|
7585 * Get next DMA window.
|
|
|
7586 */
|
|
|
7587 spx->txlt_cur_dma_win++;
|
|
|
7588 if (spx->txlt_cur_dma_win < spx->txlt_num_dma_win) {
|
|
|
7589 (void) ddi_dma_getwin(spx->txlt_buf_dma_handle,
|
|
|
7590 spx->txlt_cur_dma_win, &offset, &size,
|
|
|
7591 &cookie,
|
|
|
7592 &spx->txlt_curwin_num_dma_cookies);
|
|
|
7593 spx->txlt_curwin_processed_dma_cookies = 0;
|
|
|
7594
|
|
|
7595 } else {
|
|
|
7596 /* No more windows! End of request! */
|
|
|
7597 /* What to do? - panic for now */
|
|
|
7598 ASSERT(spx->txlt_cur_dma_win >=
|
|
|
7599 spx->txlt_num_dma_win);
|
|
|
7600
|
|
|
7601 spx->txlt_curwin_num_dma_cookies = 0;
|
|
|
7602 spx->txlt_curwin_processed_dma_cookies = 0;
|
|
|
7603 spx->txlt_sata_pkt->
|
|
|
7604 satapkt_cmd.satacmd_num_dma_cookies = 0;
|
|
|
7605 return (DDI_SUCCESS);
|
|
|
7606 }
|
|
|
7607 }
|
|
|
7608 }
|
|
|
7609 /* There better be at least one DMA cookie */
|
|
|
7610 ASSERT((spx->txlt_curwin_num_dma_cookies -
|
|
|
7611 spx->txlt_curwin_processed_dma_cookies) > 0);
|
|
|
7612
|
|
|
7613 if (spx->txlt_curwin_processed_dma_cookies == 0) {
|
|
|
7614 /*
|
|
|
7615 * Processing a new DMA window - set-up dma cookies list.
|
|
|
7616 * We may reuse previously allocated cookie array if it is
|
|
|
7617 * possible.
|
|
|
7618 */
|
|
|
7619 if (spx->txlt_dma_cookie_list != NULL &&
|
|
|
7620 spx->txlt_dma_cookie_list_len <
|
|
|
7621 spx->txlt_curwin_num_dma_cookies) {
|
|
|
7622 /*
|
|
|
7623 * New DMA window contains more cookies than
|
|
|
7624 * the previous one. We need larger cookie list - free
|
|
|
7625 * the old one.
|
|
|
7626 */
|
|
|
7627 (void) kmem_free(spx->txlt_dma_cookie_list,
|
|
|
7628 spx->txlt_dma_cookie_list_len *
|
|
|
7629 sizeof (ddi_dma_cookie_t));
|
|
|
7630 spx->txlt_dma_cookie_list = NULL;
|
|
|
7631 spx->txlt_dma_cookie_list_len = 0;
|
|
|
7632 }
|
|
|
7633 if (spx->txlt_dma_cookie_list == NULL) {
|
|
|
7634 /* Allocate new dma cookie array */
|
|
|
7635 spx->txlt_dma_cookie_list = kmem_zalloc(
|
|
|
7636 sizeof (ddi_dma_cookie_t) *
|
|
|
7637 spx->txlt_curwin_num_dma_cookies, KM_SLEEP);
|
|
|
7638 spx->txlt_dma_cookie_list_len =
|
|
|
7639 spx->txlt_curwin_num_dma_cookies;
|
|
|
7640 }
|
|
|
7641 /*
|
|
|
7642 * Copy all DMA cookies into local list, so we will know their
|
|
|
7643 * dma_size in advance of setting the sata_pkt.
|
|
|
7644 * One cookie was already fetched, so copy it.
|
|
|
7645 */
|
|
|
7646 *(&spx->txlt_dma_cookie_list[0]) = cookie;
|
|
|
7647 for (i = 1; i < spx->txlt_curwin_num_dma_cookies; i++) {
|
|
|
7648 ddi_dma_nextcookie(spx->txlt_buf_dma_handle, &cookie);
|
|
|
7649 *(&spx->txlt_dma_cookie_list[i]) = cookie;
|
|
|
7650 }
|
|
|
7651 } else {
|
|
|
7652 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
|
|
|
7653 "sata_dma_buf_setup: sliding within DMA window, "
|
|
|
7654 "cur cookie %d, total cookies %d\n",
|
|
|
7655 spx->txlt_curwin_processed_dma_cookies,
|
|
|
7656 spx->txlt_curwin_num_dma_cookies);
|
|
|
7657 }
|
|
|
7658
|
|
|
7659 /*
|
|
|
7660 * Set-up sata_pkt cookie list.
|
|
|
7661 * No single cookie transfer size would exceed max transfer size of
|
|
|
7662 * an ATA command used for addressed device (tha adjustment of the dma
|
|
|
7663 * attributes took care of this). But there may be more
|
|
|
7664 * then one cookie, so the cmd cookie list has to be
|
|
|
7665 * constrained by both a maximum scatter gather list length and
|
|
|
7666 * a maximum transfer size restriction of an ATA command.
|
|
|
7667 */
|
|
|
7668
|
|
|
7669 max_sg_len = cur_dma_attr->dma_attr_sgllen;
|
|
|
7670 req_sg_len = MIN(max_sg_len,
|
|
|
7671 (spx->txlt_curwin_num_dma_cookies -
|
|
|
7672 spx->txlt_curwin_processed_dma_cookies));
|
|
|
7673
|
|
|
7674 ASSERT(req_sg_len > 0);
|
|
|
7675
|
|
|
7676 max_txfer_len = MAX((cur_dma_attr->dma_attr_granular * 0x100),
|
|
|
7677 cur_dma_attr->dma_attr_maxxfer);
|
|
|
7678
|
|
|
7679 /* One cookie should be always available */
|
|
|
7680 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list =
|
|
|
7681 &spx->txlt_dma_cookie_list[spx->txlt_curwin_processed_dma_cookies];
|
|
|
7682
|
|
|
7683 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 1;
|
|
|
7684
|
|
|
7685 cur_txfer_len =
|
|
|
7686 (uint64_t)spx->txlt_dma_cookie_list[
|
|
|
7687 spx->txlt_curwin_processed_dma_cookies].dmac_size;
|
|
|
7688
|
|
|
7689 spx->txlt_curwin_processed_dma_cookies++;
|
|
|
7690
|
|
|
7691 ASSERT(cur_txfer_len <= max_txfer_len);
|
|
|
7692
|
|
|
7693 /* Add more cookies to the scatter-gather list */
|
|
|
7694 for (i = 1; i < req_sg_len; i++) {
|
|
|
7695 if (cur_txfer_len < max_txfer_len) {
|
|
|
7696 /*
|
|
|
7697 * Check if the next cookie could be used by
|
|
|
7698 * this sata_pkt.
|
|
|
7699 */
|
|
|
7700 if ((cur_txfer_len +
|
|
|
7701 spx->txlt_dma_cookie_list[
|
|
|
7702 spx->txlt_curwin_processed_dma_cookies].
|
|
|
7703 dmac_size) <= max_txfer_len) {
|
|
|
7704 /* Yes, transfer lenght is within bounds */
|
|
|
7705 spx->txlt_sata_pkt->
|
|
|
7706 satapkt_cmd.satacmd_num_dma_cookies++;
|
|
|
7707 cur_txfer_len +=
|
|
|
7708 spx->txlt_dma_cookie_list[
|
|
|
7709 spx->txlt_curwin_processed_dma_cookies].
|
|
|
7710 dmac_size;
|
|
|
7711 spx->txlt_curwin_processed_dma_cookies++;
|
|
|
7712 } else {
|
|
|
7713 /* No, transfer would exceed max lenght. */
|
|
|
7714 SATADBG3(SATA_DBG_DMA_SETUP,
|
|
|
7715 spx->txlt_sata_hba_inst,
|
|
|
7716 "ncookies %d, size 0x%lx, "
|
|
|
7717 "max_size 0x%lx\n",
|
|
|
7718 spx->txlt_sata_pkt->
|
|
|
7719 satapkt_cmd.satacmd_num_dma_cookies,
|
|
|
7720 cur_txfer_len, max_txfer_len);
|
|
|
7721 break;
|
|
|
7722 }
|
|
|
7723 } else {
|
|
|
7724 /* Cmd max transfer length reached */
|
|
|
7725 SATADBG3(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
|
|
|
7726 "Max transfer length? "
|
|
|
7727 "ncookies %d, size 0x%lx, max_size 0x%lx\n",
|
|
|
7728 spx->txlt_sata_pkt->
|
|
|
7729 satapkt_cmd.satacmd_num_dma_cookies,
|
|
|
7730 cur_txfer_len, max_txfer_len);
|
|
|
7731 break;
|
|
|
7732 }
|
|
|
7733 }
|
|
|
7734
|
|
|
7735 ASSERT(cur_txfer_len != 0);
|
|
|
7736 spx->txlt_total_residue -= cur_txfer_len;
|
|
|
7737
|
|
|
7738 return (DDI_SUCCESS);
|
|
|
7739 }
|
|
|
7740
|
|
|
7741 /*
|
|
|
7742 * Fetch Device Identify data.
|
|
|
7743 * Send DEVICE IDENTIFY command to a device and get the device identify data.
|
|
|
7744 * The device_info structure has to be set to device type (for selecting proper
|
|
|
7745 * device identify command).
|
|
|
7746 *
|
|
|
7747 * Returns 0 if success, -1 otherwise.
|
|
|
7748 *
|
|
|
7749 * Cannot be called in an interrupt context.
|
|
|
7750 */
|
|
|
7751
|
|
|
7752 static int
|
|
|
7753 sata_fetch_device_identify_data(sata_hba_inst_t *sata_hba_inst,
|
|
|
7754 sata_drive_info_t *sdinfo)
|
|
|
7755 {
|
|
|
7756 struct buf *bp;
|
|
|
7757 sata_pkt_t *spkt;
|
|
|
7758 sata_cmd_t *scmd;
|
|
|
7759 sata_pkt_txlate_t *spx;
|
|
|
7760 int rval;
|
|
|
7761
|
|
|
7762 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
|
|
|
7763 spx->txlt_sata_hba_inst = sata_hba_inst;
|
|
|
7764 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
|
|
|
7765 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
|
|
|
7766 if (spkt == NULL) {
|
|
|
7767 kmem_free(spx, sizeof (sata_pkt_txlate_t));
|
|
|
7768 return (-1);
|
|
|
7769 }
|
|
|
7770 /* address is needed now */
|
|
|
7771 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
|
|
|
7772
|
|
|
7773 /*
|
|
|
7774 * Allocate buffer for Identify Data return data
|
|
|
7775 */
|
|
|
7776 bp = sata_alloc_local_buffer(spx, sizeof (sata_id_t));
|
|
|
7777 if (bp == NULL) {
|
|
|
7778 sata_pkt_free(spx);
|
|
|
7779 kmem_free(spx, sizeof (sata_pkt_txlate_t));
|
|
|
7780 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
7781 "sata_fetch_device_identify_data: "
|
|
|
7782 "cannot allocate buffer for ID"));
|
|
|
7783 return (-1);
|
|
|
7784 }
|
|
|
7785
|
|
|
7786 /* Fill sata_pkt */
|
|
|
7787 sdinfo->satadrv_state = SATA_STATE_PROBING;
|
|
|
7788 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
|
|
|
7789 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
|
|
|
7790 /* Synchronous mode, no callback */
|
|
|
7791 spkt->satapkt_comp = NULL;
|
|
|
7792 /* Timeout 30s */
|
|
|
7793 spkt->satapkt_time = sata_default_pkt_time;
|
|
|
7794
|
|
|
7795 scmd = &spkt->satapkt_cmd;
|
|
|
7796 scmd->satacmd_bp = bp;
|
|
|
7797 scmd->satacmd_flags = SATA_DIR_READ | SATA_IGNORE_DEV_RESET_STATE;
|
|
|
7798
|
|
|
7799 /* Build Identify Device cmd in the sata_pkt */
|
|
|
7800 scmd->satacmd_addr_type = 0; /* N/A */
|
|
|
7801 scmd->satacmd_sec_count_lsb = 0; /* N/A */
|
|
|
7802 scmd->satacmd_lba_low_lsb = 0; /* N/A */
|
|
|
7803 scmd->satacmd_lba_mid_lsb = 0; /* N/A */
|
|
|
7804 scmd->satacmd_lba_high_lsb = 0; /* N/A */
|
|
|
7805 scmd->satacmd_features_reg = 0; /* N/A */
|
|
|
7806 scmd->satacmd_device_reg = 0; /* Always device 0 */
|
|
|
7807 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) {
|
|
|
7808 /* Identify Packet Device cmd */
|
|
|
7809 scmd->satacmd_cmd_reg = SATAC_ID_PACKET_DEVICE;
|
|
|
7810 } else {
|
|
|
7811 /* Identify Device cmd - mandatory for all other devices */
|
|
|
7812 scmd->satacmd_cmd_reg = SATAC_ID_DEVICE;
|
|
|
7813 }
|
|
|
7814
|
|
|
7815 /* Send pkt to SATA HBA driver */
|
|
|
7816 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
|
|
|
7817 SATA_TRAN_ACCEPTED ||
|
|
|
7818 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
|
|
|
7819 /*
|
|
|
7820 * Woops, no Identify Data.
|
|
|
7821 * Invalidate sata_drive_info ?
|
|
|
7822 */
|
|
|
7823 rval = -1;
|
|
|
7824 } else {
|
|
|
7825 /* Update sata_drive_info */
|
|
|
7826 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
|
|
|
7827 DDI_DMA_SYNC_FORKERNEL);
|
|
|
7828 if (rval != DDI_SUCCESS) {
|
|
|
7829 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
|
|
|
7830 "sata_fetch_device_identify_data: "
|
|
|
7831 "sync pkt failed"));
|
|
|
7832 rval = -1;
|
|
|
7833 goto fail;
|
|
|
7834 }
|
|
|
7835 bcopy(bp->b_un.b_addr, &sdinfo->satadrv_id,
|
|
|
7836 sizeof (sata_id_t));
|
|
|
7837
|
|
|
7838 sdinfo->satadrv_features_support = 0;
|
|
|
7839 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
|
|
|
7840 /*
|
|
|
7841 * Retrieve capacity (disks only) and addressing mode
|
|
|
7842 */
|
|
|
7843 sdinfo->satadrv_capacity = sata_check_capacity(sdinfo);
|
|
|
7844 } else {
|
|
|
7845 /*
|
|
|
7846 * For ATAPI devices one has to issue Get Capacity cmd
|
|
|
7847 * (not needed at the moment)
|
|
|
7848 */
|
|
|
7849 sdinfo->satadrv_capacity = 0;
|
|
|
7850 }
|
|
|
7851 /* Setup supported features flags */
|
|
|
7852 if (sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT)
|
|
|
7853 sdinfo->satadrv_features_support |= SATA_DEV_F_DMA;
|
|
|
7854
|
|
|
7855 /* Check for NCQ support */
|
|
|
7856 if (sdinfo->satadrv_id.ai_satacap != 0 &&
|
|
|
7857 sdinfo->satadrv_id.ai_satacap != 0xffff) {
|
|
|
7858 /* SATA compliance */
|
|
|
7859 if (sdinfo->satadrv_id.ai_satacap & SATA_NCQ)
|
|
|
7860 sdinfo->satadrv_features_support |=
|
|
|
7861 SATA_DEV_F_NCQ;
|
|
|
7862 if (sdinfo->satadrv_id.ai_satacap &
|
|
|
7863 (SATA_1_SPEED | SATA_2_SPEED)) {
|
|
|
7864 if (sdinfo->satadrv_id.ai_satacap &
|
|
|
7865 SATA_2_SPEED)
|
|
|
7866 sdinfo->satadrv_features_support |=
|
|
|
7867 SATA_DEV_F_SATA2;
|
|
|
7868 if (sdinfo->satadrv_id.ai_satacap &
|
|
|
7869 SATA_1_SPEED)
|
|
|
7870 sdinfo->satadrv_features_support |=
|
|
|
7871 SATA_DEV_F_SATA1;
|
|
|
7872 } else {
|
|
|
7873 sdinfo->satadrv_features_support |=
|
|
|
7874 SATA_DEV_F_SATA1;
|
|
|
7875 }
|
|
|
7876 }
|
|
|
7877
|
|
|
7878 sdinfo->satadrv_queue_depth = sdinfo->satadrv_id.ai_qdepth;
|
|
|
7879 if (sdinfo->satadrv_id.ai_cmdset83 & SATA_RW_DMA_QUEUED_CMD)
|
|
|
7880 if (sdinfo->satadrv_queue_depth == 0)
|
|
|
7881 sdinfo->satadrv_queue_depth = 1;
|
|
|
7882
|
|
|
7883 rval = 0;
|
|
|
7884 }
|
|
|
7885 fail:
|
|
|
7886 /* Free allocated resources */
|
|
|
7887 sata_free_local_buffer(spx);
|
|
|
7888 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
|
|
|
7889 sata_pkt_free(spx);
|
|
|
7890 kmem_free(spx, sizeof (sata_pkt_txlate_t));
|
|
|
7891
|
|
|
7892 return (rval);
|
|
|
7893 }
|
|
|
7894
|
|
|
7895
|
|
|
7896 /*
|
|
|
7897 * SATA spec requires that the device supports at least UDMA 4 mode and
|
|
|
7898 * UDMA mode is selected.
|
|
|
7899 * Some devices (bridged devices) may not come-up with default UDMA mode
|
|
|
7900 * set correctly, so this function is setting it.
|
|
|
7901 *
|
|
|
7902 * Returns SATA_SUCCESS if proper UDMA mode is selected.
|
|
|
7903 * Returns SATA_FAILURE if proper UDMA mode could not be selected.
|
|
|
7904 */
|
|
|
7905 static int
|
|
|
7906 sata_set_udma_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo)
|
|
|
7907 {
|
|
|
7908 sata_pkt_t *spkt;
|
|
|
7909 sata_cmd_t *scmd;
|
|
|
7910 sata_pkt_txlate_t *spx;
|
|
|
7911 int result = SATA_SUCCESS;
|
|
|
7912 int i, mode;
|
|
|
7913
|
|
|
7914 ASSERT(sdinfo != NULL);
|
|
|
7915 ASSERT(sata_hba_inst != NULL);
|
|
|
7916
|
|
|
7917 /* Find highest Ultra DMA mode supported */
|
|
|
7918 for (mode = 6; mode >= 0; --mode) {
|
|
|
7919 if (sdinfo->satadrv_id.ai_ultradma & (1 << mode))
|
|
|
7920 break;
|
|
|
7921 }
|
|
|
7922 if (mode < 4)
|
|
|
7923 return (SATA_FAILURE);
|
|
|
7924
|
|
|
7925 /* Find UDMA mode currently selected */
|
|
|
7926 for (i = 6; i >= 0; --i) {
|
|
|
7927 if (sdinfo->satadrv_id.ai_ultradma & (1 << (i + 8)))
|
|
|
7928 break;
|
|
|
7929 }
|
|
|
7930
|
|
|
7931 if (i < mode) {
|
|
|
7932 /* Set UDMA mode via SET FEATURES COMMAND */
|
|
|
7933 /* Prepare packet for SET FEATURES COMMAND */
|
|
|
7934 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
|
|
|
7935 spx->txlt_sata_hba_inst = sata_hba_inst;
|
|
|
7936 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
|
|
|
7937 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
|
|
|
7938 if (spkt == NULL) {
|
|
|
7939 result = SATA_FAILURE;
|
|
|
7940 goto failure;
|
|
|
7941 }
|
|
|
7942 /* Fill sata_pkt */
|
|
|
7943 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
|
|
|
7944 /* Timeout 30s */
|
|
|
7945 spkt->satapkt_time = sata_default_pkt_time;
|
|
|
7946 /* Synchronous mode, no callback, interrupts */
|
|
|
7947 spkt->satapkt_op_mode =
|
|
|
7948 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
|
|
|
7949 spkt->satapkt_comp = NULL;
|
|
|
7950 scmd = &spkt->satapkt_cmd;
|
|
|
7951 scmd->satacmd_flags = SATA_DIR_NODATA_XFER |
|
|
|
7952 SATA_IGNORE_DEV_RESET_STATE;
|
|
|
7953 scmd->satacmd_addr_type = 0;
|
|
|
7954 scmd->satacmd_device_reg = 0;
|
|
|
7955 scmd->satacmd_status_reg = 0;
|
|
|
7956 scmd->satacmd_error_reg = 0;
|
|
|
7957 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
|
|
|
7958 scmd->satacmd_features_reg = SATAC_SF_TRANSFER_MODE;
|
|
|
7959 scmd->satacmd_sec_count_lsb =
|
|
|
7960 SATAC_TRANSFER_MODE_ULTRA_DMA | mode;
|
|
|
7961
|
|
|
7962 /* Transfer command to HBA */
|
|
|
7963 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
|
|
|
7964 spkt) != SATA_TRAN_ACCEPTED ||
|
|
|
7965 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
|
|
|
7966 /* Pkt execution failed */
|
|
|
7967 result = SATA_FAILURE;
|
|
|
7968 }
|
|
|
7969 failure:
|
|
|
7970 if (result == SATA_FAILURE)
|
|
|
7971 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
7972 "sata_set_udma_mode: could not set UDMA "
|
|
|
7973 "mode %", mode));
|
|
|
7974
|
|
|
7975 /* Free allocated resources */
|
|
|
7976 if (spkt != NULL)
|
|
|
7977 sata_pkt_free(spx);
|
|
|
7978 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
|
|
|
7979 }
|
|
|
7980 return (result);
|
|
|
7981 }
|
|
|
7982
|
|
|
7983
|
|
|
7984 /*
|
|
|
7985 * Update port SCR block
|
|
|
7986 */
|
|
|
7987 static void
|
|
|
7988 sata_update_port_scr(sata_port_scr_t *port_scr, sata_device_t *device)
|
|
|
7989 {
|
|
|
7990 port_scr->sstatus = device->satadev_scr.sstatus;
|
|
|
7991 port_scr->serror = device->satadev_scr.serror;
|
|
|
7992 port_scr->scontrol = device->satadev_scr.scontrol;
|
|
|
7993 port_scr->sactive = device->satadev_scr.sactive;
|
|
|
7994 port_scr->snotific = device->satadev_scr.snotific;
|
|
|
7995 }
|
|
|
7996
|
|
|
7997 /*
|
|
|
7998 * Update state and copy port ss* values from passed sata_device structure.
|
|
|
7999 * sata_address is validated - if not valid, nothing is changed in sata_scsi
|
|
|
8000 * configuration struct.
|
|
|
8001 *
|
|
|
8002 * SATA_PSTATE_SHUTDOWN in port state is not reset to 0 by this function
|
|
|
8003 * regardless of the state in device argument.
|
|
|
8004 *
|
|
|
8005 * Port mutex should be held while calling this function.
|
|
|
8006 */
|
|
|
8007 static void
|
|
|
8008 sata_update_port_info(sata_hba_inst_t *sata_hba_inst,
|
|
|
8009 sata_device_t *sata_device)
|
|
|
8010 {
|
|
|
8011 ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst,
|
|
|
8012 sata_device->satadev_addr.cport)));
|
|
|
8013
|
|
|
8014 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT ||
|
|
|
8015 sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) {
|
|
|
8016
|
|
|
8017 sata_cport_info_t *cportinfo;
|
|
|
8018
|
|
|
8019 if (SATA_NUM_CPORTS(sata_hba_inst) <=
|
|
|
8020 sata_device->satadev_addr.cport)
|
|
|
8021 return;
|
|
|
8022
|
|
|
8023 cportinfo = SATA_CPORT_INFO(sata_hba_inst,
|
|
|
8024 sata_device->satadev_addr.cport);
|
|
|
8025 sata_update_port_scr(&cportinfo->cport_scr, sata_device);
|
|
|
8026
|
|
|
8027 /* Preserve SATA_PSTATE_SHUTDOWN flag */
|
|
|
8028 cportinfo->cport_state &= ~(SATA_PSTATE_PWRON |
|
|
|
8029 SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED);
|
|
|
8030 cportinfo->cport_state |=
|
|
|
8031 sata_device->satadev_state & SATA_PSTATE_VALID;
|
|
|
8032 } else {
|
|
|
8033 sata_pmport_info_t *pmportinfo;
|
|
|
8034
|
|
|
8035 if ((sata_device->satadev_addr.qual != SATA_ADDR_PMPORT) ||
|
|
|
8036 (sata_device->satadev_addr.qual != SATA_ADDR_DPMPORT) ||
|
|
|
8037 SATA_NUM_PMPORTS(sata_hba_inst,
|
|
|
8038 sata_device->satadev_addr.cport) <
|
|
|
8039 sata_device->satadev_addr.pmport)
|
|
|
8040 return;
|
|
|
8041
|
|
|
8042 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
|
|
|
8043 sata_device->satadev_addr.cport,
|
|
|
8044 sata_device->satadev_addr.pmport);
|
|
|
8045 sata_update_port_scr(&pmportinfo->pmport_scr, sata_device);
|
|
|
8046
|
|
|
8047 /* Preserve SATA_PSTATE_SHUTDOWN flag */
|
|
|
8048 pmportinfo->pmport_state &=
|
|
|
8049 ~(SATA_PSTATE_PWRON | SATA_PSTATE_PWROFF |
|
|
|
8050 SATA_PSTATE_FAILED);
|
|
|
8051 pmportinfo->pmport_state |=
|
|
|
8052 sata_device->satadev_state & SATA_PSTATE_VALID;
|
|
|
8053 }
|
|
|
8054 }
|
|
|
8055
|
|
|
8056
|
|
|
8057
|
|
|
8058 /*
|
|
|
8059 * Extract SATA port specification from an IOCTL argument.
|
|
|
8060 *
|
|
|
8061 * This function return the port the user land send us as is, unless it
|
|
|
8062 * cannot retrieve port spec, then -1 is returned.
|
|
|
8063 *
|
|
|
8064 * Note: Only cport - no port multiplier port.
|
|
|
8065 */
|
|
|
8066 static int32_t
|
|
|
8067 sata_get_port_num(sata_hba_inst_t *sata_hba_inst, struct devctl_iocdata *dcp)
|
|
|
8068 {
|
|
|
8069 int32_t port;
|
|
|
8070
|
|
|
8071 /* Extract port number from nvpair in dca structure */
|
|
|
8072 if (nvlist_lookup_int32(ndi_dc_get_ap_data(dcp), "port", &port) != 0) {
|
|
|
8073 SATA_LOG_D((sata_hba_inst, CE_NOTE,
|
|
|
8074 "sata_get_port_num: invalid port spec 0x%x in ioctl",
|
|
|
8075 port));
|
|
|
8076 port = -1;
|
|
|
8077 }
|
|
|
8078
|
|
|
8079 return (port);
|
|
|
8080 }
|
|
|
8081
|
|
|
8082 /*
|
|
|
8083 * Get dev_info_t pointer to the device node pointed to by port argument.
|
|
|
8084 * NOTE: target argument is a value used in ioctls to identify
|
|
|
8085 * the AP - it is not a sata_address.
|
|
|
8086 * It is a combination of cport, pmport and address qualifier, encodded same
|
|
|
8087 * way as a scsi target number.
|
|
|
8088 * At this moment it carries only cport number.
|
|
|
8089 *
|
|
|
8090 * No PMult hotplug support.
|
|
|
8091 *
|
|
|
8092 * Returns dev_info_t pointer if target device was found, NULL otherwise.
|
|
|
8093 */
|
|
|
8094
|
|
|
8095 static dev_info_t *
|
|
|
8096 sata_get_target_dip(dev_info_t *dip, int32_t port)
|
|
|
8097 {
|
|
|
8098 dev_info_t *cdip = NULL;
|
|
|
8099 int target, tgt;
|
|
|
8100 int ncport;
|
|
|
8101 int circ;
|
|
|
8102
|
|
|
8103 ncport = port & SATA_CFGA_CPORT_MASK;
|
|
|
8104 target = SATA_TO_SCSI_TARGET(ncport, 0, SATA_ADDR_DCPORT);
|
|
|
8105
|
|
|
8106 ndi_devi_enter(dip, &circ);
|
|
|
8107 for (cdip = ddi_get_child(dip); cdip != NULL; ) {
|
|
|
8108 dev_info_t *next = ddi_get_next_sibling(cdip);
|
|
|
8109
|
|
|
8110 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip,
|
|
|
8111 DDI_PROP_DONTPASS, "target", -1);
|
|
|
8112 if (tgt == -1) {
|
|
|
8113 /*
|
|
|
8114 * This is actually an error condition, but not
|
|
|
8115 * a fatal one. Just continue the search.
|
|
|
8116 */
|
|
|
8117 cdip = next;
|
|
|
8118 continue;
|
|
|
8119 }
|
|
|
8120
|
|
|
8121 if (tgt == target)
|
|
|
8122 break;
|
|
|
8123
|
|
|
8124 cdip = next;
|
|
|
8125 }
|
|
|
8126 ndi_devi_exit(dip, circ);
|
|
|
8127
|
|
|
8128 return (cdip);
|
|
|
8129 }
|
|
|
8130
|
|
|
8131
|
|
|
8132 /*
|
|
|
8133 * sata_cfgadm_state:
|
|
|
8134 * Use the sata port state and state of the target node to figure out
|
|
|
8135 * the cfgadm_state.
|
|
|
8136 *
|
|
|
8137 * The port argument is a value with encoded cport,
|
|
|
8138 * pmport and address qualifier, in the same manner as a scsi target number.
|
|
|
8139 * SCSI_TO_SATA_CPORT macro extracts cport number,
|
|
|
8140 * SCSI_TO_SATA_PMPORT extracts pmport number and
|
|
|
8141 * SCSI_TO_SATA_ADDR_QUAL extracts port mulitplier qualifier flag.
|
|
|
8142 *
|
|
|
8143 * For now, support is for cports only - no pmultiplier ports.
|
|
|
8144 */
|
|
|
8145
|
|
|
8146 static void
|
|
|
8147 sata_cfgadm_state(sata_hba_inst_t *sata_hba_inst, int32_t port,
|
|
|
8148 devctl_ap_state_t *ap_state)
|
|
|
8149 {
|
|
|
8150 uint16_t cport;
|
|
|
8151 int port_state;
|
|
|
8152
|
|
|
8153 /* Cport only */
|
|
|
8154 cport = SCSI_TO_SATA_CPORT(port);
|
|
|
8155
|
|
|
8156 port_state = SATA_CPORT_STATE(sata_hba_inst, cport);
|
|
|
8157 if (port_state & SATA_PSTATE_SHUTDOWN ||
|
|
|
8158 port_state & SATA_PSTATE_FAILED) {
|
|
|
8159 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED;
|
|
|
8160 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
|
|
|
8161 if (port_state & SATA_PSTATE_FAILED)
|
|
|
8162 ap_state->ap_condition = AP_COND_FAILED;
|
|
|
8163 else
|
|
|
8164 ap_state->ap_condition = AP_COND_UNKNOWN;
|
|
|
8165
|
|
|
8166 return;
|
|
|
8167 }
|
|
|
8168
|
|
|
8169 /* Need to check pmult device port here as well, when supported */
|
|
|
8170
|
|
|
8171 /* Port is enabled and ready */
|
|
|
8172
|
|
|
8173 switch (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport)) {
|
|
|
8174 case SATA_DTYPE_NONE:
|
|
|
8175 {
|
|
|
8176 /* No device attached */
|
|
|
8177 ap_state->ap_rstate = AP_RSTATE_EMPTY;
|
|
|
8178 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
|
|
|
8179 ap_state->ap_condition = AP_COND_OK;
|
|
|
8180 break;
|
|
|
8181 }
|
|
|
8182 case SATA_DTYPE_UNKNOWN:
|
|
|
8183 case SATA_DTYPE_ATAPINONCD:
|
|
|
8184 case SATA_DTYPE_PMULT: /* Until PMult is supported */
|
|
|
8185 {
|
|
|
8186 /* Unknown device attached */
|
|
|
8187 ap_state->ap_rstate = AP_RSTATE_CONNECTED;
|
|
|
8188 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
|
|
|
8189 ap_state->ap_condition = AP_COND_UNKNOWN;
|
|
|
8190 break;
|
|
|
8191 }
|
|
|
8192 case SATA_DTYPE_ATADISK:
|
|
|
8193 case SATA_DTYPE_ATAPICD:
|
|
|
8194 {
|
|
|
8195 dev_info_t *tdip = NULL;
|
|
|
8196 dev_info_t *dip = NULL;
|
|
|
8197 int circ;
|
|
|
8198
|
|
|
8199 dip = SATA_DIP(sata_hba_inst);
|
|
|
8200 tdip = sata_get_target_dip(dip, port);
|
|
|
8201 ap_state->ap_rstate = AP_RSTATE_CONNECTED;
|
|
|
8202 if (tdip != NULL) {
|
|
|
8203 ndi_devi_enter(dip, &circ);
|
|
|
8204 mutex_enter(&(DEVI(tdip)->devi_lock));
|
|
|
8205 if ((DEVI_IS_DEVICE_OFFLINE(tdip)) ||
|
|
|
8206 (DEVI_IS_DEVICE_DOWN(tdip))) {
|
|
|
8207 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
|
|
|
8208 } else {
|
|
|
8209 ap_state->ap_ostate = AP_OSTATE_CONFIGURED;
|
|
|
8210 }
|
|
|
8211 ap_state->ap_condition = AP_COND_OK;
|
|
|
8212 mutex_exit(&(DEVI(tdip)->devi_lock));
|
|
|
8213 ndi_devi_exit(dip, circ);
|
|
|
8214 } else {
|
|
|
8215 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
|
|
|
8216 ap_state->ap_condition = AP_COND_UNKNOWN;
|
|
|
8217 }
|
|
|
8218 break;
|
|
|
8219 }
|
|
|
8220 default:
|
|
|
8221 ap_state->ap_rstate = AP_RSTATE_CONNECTED;
|
|
|
8222 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
|
|
|
8223 ap_state->ap_condition = AP_COND_UNKNOWN;
|
|
|
8224 /*
|
|
|
8225 * This is actually internal error condition (non fatal),
|
|
|
8226 * beacuse we already checked all defined device types.
|
|
|
8227 */
|
|
|
8228 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
8229 "sata_cfgadm_state: Internal error: "
|
|
|
8230 "unknown device type"));
|
|
|
8231 break;
|
|
|
8232 }
|
|
|
8233 }
|
|
|
8234
|
|
|
8235 /*
|
|
|
8236 * Start or terminate the thread, depending on flag arg and current state
|
|
|
8237 */
|
|
|
8238 static void
|
|
|
8239 sata_event_thread_control(int startstop)
|
|
|
8240 {
|
|
|
8241 static int sata_event_thread_terminating = 0;
|
|
|
8242 static int sata_event_thread_starting = 0;
|
|
|
8243 int i;
|
|
|
8244
|
|
|
8245 mutex_enter(&sata_event_mutex);
|
|
|
8246
|
|
|
8247 if (startstop == 0 && (sata_event_thread_starting == 1 ||
|
|
|
8248 sata_event_thread_terminating == 1)) {
|
|
|
8249 mutex_exit(&sata_event_mutex);
|
|
|
8250 return;
|
|
|
8251 }
|
|
|
8252 if (startstop == 1 && sata_event_thread_starting == 1) {
|
|
|
8253 mutex_exit(&sata_event_mutex);
|
|
|
8254 return;
|
|
|
8255 }
|
|
|
8256 if (startstop == 1 && sata_event_thread_terminating == 1) {
|
|
|
8257 sata_event_thread_starting = 1;
|
|
|
8258 /* wait til terminate operation completes */
|
|
|
8259 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT;
|
|
|
8260 while (sata_event_thread_terminating == 1) {
|
|
|
8261 if (i-- <= 0) {
|
|
|
8262 sata_event_thread_starting = 0;
|
|
|
8263 mutex_exit(&sata_event_mutex);
|
|
|
8264 #ifdef SATA_DEBUG
|
|
|
8265 cmn_err(CE_WARN, "sata_event_thread_control: "
|
|
|
8266 "timeout waiting for thread to terminate");
|
|
|
8267 #endif
|
|
|
8268 return;
|
|
|
8269 }
|
|
|
8270 mutex_exit(&sata_event_mutex);
|
|
|
8271 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT));
|
|
|
8272 mutex_enter(&sata_event_mutex);
|
|
|
8273 }
|
|
|
8274 }
|
|
|
8275 if (startstop == 1) {
|
|
|
8276 if (sata_event_thread == NULL) {
|
|
|
8277 sata_event_thread = thread_create(NULL, 0,
|
|
|
8278 (void (*)())sata_event_daemon,
|
|
|
8279 &sata_hba_list, 0, &p0, TS_RUN, minclsyspri);
|
|
|
8280 }
|
|
|
8281 sata_event_thread_starting = 0;
|
|
|
8282 mutex_exit(&sata_event_mutex);
|
|
|
8283 return;
|
|
|
8284 }
|
|
|
8285
|
|
|
8286 /*
|
|
|
8287 * If we got here, thread may need to be terminated
|
|
|
8288 */
|
|
|
8289 if (sata_event_thread != NULL) {
|
|
|
8290 int i;
|
|
|
8291 /* Signal event thread to go away */
|
|
|
8292 sata_event_thread_terminating = 1;
|
|
|
8293 sata_event_thread_terminate = 1;
|
|
|
8294 cv_signal(&sata_event_cv);
|
|
|
8295 /*
|
|
|
8296 * Wait til daemon terminates.
|
|
|
8297 */
|
|
|
8298 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT;
|
|
|
8299 while (sata_event_thread_terminate == 1) {
|
|
|
8300 mutex_exit(&sata_event_mutex);
|
|
|
8301 if (i-- <= 0) {
|
|
|
8302 /* Daemon did not go away !!! */
|
|
|
8303 #ifdef SATA_DEBUG
|
|
|
8304 cmn_err(CE_WARN, "sata_event_thread_control: "
|
|
|
8305 "cannot terminate event daemon thread");
|
|
|
8306 #endif
|
|
|
8307 mutex_enter(&sata_event_mutex);
|
|
|
8308 break;
|
|
|
8309 }
|
|
|
8310 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT));
|
|
|
8311 mutex_enter(&sata_event_mutex);
|
|
|
8312 }
|
|
|
8313 sata_event_thread_terminating = 0;
|
|
|
8314 }
|
|
|
8315 ASSERT(sata_event_thread_terminating == 0);
|
|
|
8316 ASSERT(sata_event_thread_starting == 0);
|
|
|
8317 mutex_exit(&sata_event_mutex);
|
|
|
8318 }
|
|
|
8319
|
|
|
8320
|
|
|
8321 /*
|
|
|
8322 * Log sata message
|
|
|
8323 * dev pathname msg line preceeds the logged message.
|
|
|
8324 */
|
|
|
8325
|
|
|
8326 static void
|
|
|
8327 sata_log(sata_hba_inst_t *sata_hba_inst, uint_t level, char *fmt, ...)
|
|
|
8328 {
|
|
|
8329 char pathname[128];
|
|
|
8330 dev_info_t *dip;
|
|
|
8331 va_list ap;
|
|
|
8332
|
|
|
8333 mutex_enter(&sata_log_mutex);
|
|
|
8334
|
|
|
8335 va_start(ap, fmt);
|
|
|
8336 (void) vsprintf(sata_log_buf, fmt, ap);
|
|
|
8337 va_end(ap);
|
|
|
8338
|
|
|
8339 if (sata_hba_inst != NULL) {
|
|
|
8340 dip = SATA_DIP(sata_hba_inst);
|
|
|
8341 (void) ddi_pathname(dip, pathname);
|
|
|
8342 } else {
|
|
|
8343 pathname[0] = 0;
|
|
|
8344 }
|
|
|
8345 if (level == CE_CONT) {
|
|
|
8346 if (sata_debug_flags == 0)
|
|
|
8347 cmn_err(level, "?%s:\n %s\n", pathname, sata_log_buf);
|
|
|
8348 else
|
|
|
8349 cmn_err(level, "%s:\n %s\n", pathname, sata_log_buf);
|
|
|
8350 } else
|
|
|
8351 cmn_err(level, "%s:\n %s", pathname, sata_log_buf);
|
|
|
8352
|
|
|
8353 mutex_exit(&sata_log_mutex);
|
|
|
8354 }
|
|
|
8355
|
|
|
8356
|
|
|
8357 /* ******** Asynchronous HBA events handling & hotplugging support ******** */
|
|
|
8358
|
|
|
8359 /*
|
|
|
8360 * SATA HBA event notification function.
|
|
|
8361 * Events reported by SATA HBA drivers per HBA instance relate to a change in
|
|
|
8362 * a port and/or device state or a controller itself.
|
|
|
8363 * Events for different addresses/addr types cannot be combined.
|
|
|
8364 * A warning message is generated for each event type.
|
|
|
8365 * Events are not processed by this function, so only the
|
|
|
8366 * event flag(s)is set for an affected entity and the event thread is
|
|
|
8367 * waken up. Event daemon thread processes all events.
|
|
|
8368 *
|
|
|
8369 * NOTE: Since more than one event may be reported at the same time, one
|
|
|
8370 * cannot determine a sequence of events when opposite event are reported, eg.
|
|
|
8371 * LINK_LOST and LINK_ESTABLISHED. Actual port status during event processing
|
|
|
8372 * is taking precedence over reported events, i.e. may cause ignoring some
|
|
|
8373 * events.
|
|
|
8374 */
|
|
|
8375 #define SATA_EVENT_MAX_MSG_LENGTH 79
|
|
|
8376
|
|
|
8377 void
|
|
|
8378 sata_hba_event_notify(dev_info_t *dip, sata_device_t *sata_device, int event)
|
|
|
8379 {
|
|
|
8380 sata_hba_inst_t *sata_hba_inst = NULL;
|
|
|
8381 sata_address_t *saddr;
|
|
|
8382 sata_drive_info_t *sdinfo;
|
|
|
8383 sata_port_stats_t *pstats;
|
|
|
8384 int cport, pmport;
|
|
|
8385 char buf1[SATA_EVENT_MAX_MSG_LENGTH + 1];
|
|
|
8386 char buf2[SATA_EVENT_MAX_MSG_LENGTH + 1];
|
|
|
8387 char *lcp;
|
|
|
8388 static char *err_msg_evnt_1 =
|
|
|
8389 "sata_hba_event_notify: invalid port event 0x%x ";
|
|
|
8390 static char *err_msg_evnt_2 =
|
|
|
8391 "sata_hba_event_notify: invalid device event 0x%x ";
|
|
|
8392 int linkevent;
|
|
|
8393
|
|
|
8394 /*
|
|
|
8395 * There is a possibility that an event will be generated on HBA
|
|
|
8396 * that has not completed attachment or is detaching.
|
|
|
8397 * HBA driver should prevent this, but just in case it does not,
|
|
|
8398 * we need to ignore events for such HBA.
|
|
|
8399 */
|
|
|
8400 mutex_enter(&sata_mutex);
|
|
|
8401 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
|
|
|
8402 sata_hba_inst = sata_hba_inst->satahba_next) {
|
|
|
8403 if (SATA_DIP(sata_hba_inst) == dip)
|
|
|
8404 if (sata_hba_inst->satahba_attached == 1)
|
|
|
8405 break;
|
|
|
8406 }
|
|
|
8407 mutex_exit(&sata_mutex);
|
|
|
8408 if (sata_hba_inst == NULL)
|
|
|
8409 /* HBA not attached */
|
|
|
8410 return;
|
|
|
8411
|
|
|
8412 ASSERT(sata_device != NULL);
|
|
|
8413
|
|
|
8414 /*
|
|
|
8415 * Validate address before - do not proceed with invalid address.
|
|
|
8416 */
|
|
|
8417 saddr = &sata_device->satadev_addr;
|
|
|
8418 if (saddr->cport >= SATA_NUM_CPORTS(sata_hba_inst))
|
|
|
8419 return;
|
|
|
8420 if (saddr->qual == SATA_ADDR_PMPORT ||
|
|
|
8421 saddr->qual == SATA_ADDR_DPMPORT)
|
|
|
8422 /* Port Multiplier not supported yet */
|
|
|
8423 return;
|
|
|
8424
|
|
|
8425 cport = saddr->cport;
|
|
|
8426 pmport = saddr->pmport;
|
|
|
8427
|
|
|
8428 buf1[0] = buf2[0] = '\0';
|
|
|
8429
|
|
|
8430 /*
|
|
|
8431 * Events refer to devices, ports and controllers - each has
|
|
|
8432 * unique address. Events for different addresses cannot be combined.
|
|
|
8433 */
|
|
|
8434 if (saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT)) {
|
|
|
8435
|
|
|
8436 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
|
|
|
8437
|
|
|
8438 /* qualify this event(s) */
|
|
|
8439 if ((event & SATA_EVNT_PORT_EVENTS) == 0) {
|
|
|
8440 /* Invalid event for the device port */
|
|
|
8441 (void) sprintf(buf2, err_msg_evnt_1,
|
|
|
8442 event & SATA_EVNT_PORT_EVENTS);
|
|
|
8443 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
|
|
|
8444 goto event_info;
|
|
|
8445 }
|
|
|
8446 if (saddr->qual == SATA_ADDR_CPORT) {
|
|
|
8447 /* Controller's device port event */
|
|
|
8448
|
|
|
8449 (SATA_CPORT_INFO(sata_hba_inst, cport))->
|
|
|
8450 cport_event_flags |=
|
|
|
8451 event & SATA_EVNT_PORT_EVENTS;
|
|
|
8452 pstats =
|
|
|
8453 &(SATA_CPORT_INFO(sata_hba_inst, cport))->
|
|
|
8454 cport_stats;
|
|
|
8455 } else {
|
|
|
8456 /* Port multiplier's device port event */
|
|
|
8457 (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))->
|
|
|
8458 pmport_event_flags |=
|
|
|
8459 event & SATA_EVNT_PORT_EVENTS;
|
|
|
8460 pstats =
|
|
|
8461 &(SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))->
|
|
|
8462 pmport_stats;
|
|
|
8463 }
|
|
|
8464
|
|
|
8465 /*
|
|
|
8466 * Add to statistics and log the message. We have to do it
|
|
|
8467 * here rather than in the event daemon, because there may be
|
|
|
8468 * multiple events occuring before they are processed.
|
|
|
8469 */
|
|
|
8470 linkevent = event &
|
|
|
8471 (SATA_EVNT_LINK_LOST | SATA_EVNT_LINK_ESTABLISHED);
|
|
|
8472 if (linkevent) {
|
|
|
8473 if (linkevent == (SATA_EVNT_LINK_LOST |
|
|
|
8474 SATA_EVNT_LINK_ESTABLISHED)) {
|
|
|
8475 /* This is likely event combination */
|
|
|
8476 (void) strlcat(buf1, "link lost/established, ",
|
|
|
8477 SATA_EVENT_MAX_MSG_LENGTH);
|
|
|
8478
|
|
|
8479 if (pstats->link_lost < 0xffffffffffffffff)
|
|
|
8480 pstats->link_lost++;
|
|
|
8481 if (pstats->link_established <
|
|
|
8482 0xffffffffffffffff)
|
|
|
8483 pstats->link_established++;
|
|
|
8484 linkevent = 0;
|
|
|
8485 } else if (linkevent & SATA_EVNT_LINK_LOST) {
|
|
|
8486 (void) strlcat(buf1, "link lost, ",
|
|
|
8487 SATA_EVENT_MAX_MSG_LENGTH);
|
|
|
8488
|
|
|
8489 if (pstats->link_lost < 0xffffffffffffffff)
|
|
|
8490 pstats->link_lost++;
|
|
|
8491 } else {
|
|
|
8492 (void) strlcat(buf1, "link established, ",
|
|
|
8493 SATA_EVENT_MAX_MSG_LENGTH);
|
|
|
8494 if (pstats->link_established <
|
|
|
8495 0xffffffffffffffff)
|
|
|
8496 pstats->link_established++;
|
|
|
8497 }
|
|
|
8498 }
|
|
|
8499 if (event & SATA_EVNT_DEVICE_ATTACHED) {
|
|
|
8500 (void) strlcat(buf1, "device attached, ",
|
|
|
8501 SATA_EVENT_MAX_MSG_LENGTH);
|
|
|
8502 if (pstats->device_attached < 0xffffffffffffffff)
|
|
|
8503 pstats->device_attached++;
|
|
|
8504 }
|
|
|
8505 if (event & SATA_EVNT_DEVICE_DETACHED) {
|
|
|
8506 (void) strlcat(buf1, "device detached, ",
|
|
|
8507 SATA_EVENT_MAX_MSG_LENGTH);
|
|
|
8508 if (pstats->device_detached < 0xffffffffffffffff)
|
|
|
8509 pstats->device_detached++;
|
|
|
8510 }
|
|
|
8511 if (event & SATA_EVNT_PWR_LEVEL_CHANGED) {
|
|
|
8512 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
|
|
|
8513 "port %d power level changed", cport);
|
|
|
8514 if (pstats->port_pwr_changed < 0xffffffffffffffff)
|
|
|
8515 pstats->port_pwr_changed++;
|
|
|
8516 }
|
|
|
8517
|
|
|
8518 if ((event & ~SATA_EVNT_PORT_EVENTS) != 0) {
|
|
|
8519 /* There should be no other events for this address */
|
|
|
8520 (void) sprintf(buf2, err_msg_evnt_1,
|
|
|
8521 event & ~SATA_EVNT_PORT_EVENTS);
|
|
|
8522 }
|
|
|
8523 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
|
|
|
8524
|
|
|
8525 } else if (saddr->qual & (SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT)) {
|
|
|
8526 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
|
|
|
8527
|
|
|
8528 /* qualify this event */
|
|
|
8529 if ((event & SATA_EVNT_DEVICE_RESET) == 0) {
|
|
|
8530 /* Invalid event for a device */
|
|
|
8531 (void) sprintf(buf2, err_msg_evnt_2,
|
|
|
8532 event & SATA_EVNT_DEVICE_RESET);
|
|
|
8533 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
|
|
|
8534 goto event_info;
|
|
|
8535 }
|
|
|
8536 /* drive event */
|
|
|
8537 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
|
|
|
8538 if (sdinfo != NULL) {
|
|
|
8539 if (event & SATA_EVNT_DEVICE_RESET) {
|
|
|
8540 (void) strlcat(buf1, "device reset, ",
|
|
|
8541 SATA_EVENT_MAX_MSG_LENGTH);
|
|
|
8542 if (sdinfo->satadrv_stats.drive_reset <
|
|
|
8543 0xffffffffffffffff)
|
|
|
8544 sdinfo->satadrv_stats.drive_reset++;
|
|
|
8545 sdinfo->satadrv_event_flags |=
|
|
|
8546 SATA_EVNT_DEVICE_RESET;
|
|
|
8547 }
|
|
|
8548 }
|
|
|
8549 if ((event & ~SATA_EVNT_DEVICE_RESET) != 0) {
|
|
|
8550 /* Invalid event for a device */
|
|
|
8551 (void) sprintf(buf2, err_msg_evnt_2,
|
|
|
8552 event & ~SATA_EVNT_DRIVE_EVENTS);
|
|
|
8553 }
|
|
|
8554 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
|
|
|
8555 } else {
|
|
|
8556 if (saddr->qual != SATA_ADDR_NULL) {
|
|
|
8557 /* Wrong address qualifier */
|
|
|
8558 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
8559 "sata_hba_event_notify: invalid address 0x%x",
|
|
|
8560 *(uint32_t *)saddr));
|
|
|
8561 return;
|
|
|
8562 }
|
|
|
8563 if ((event & SATA_EVNT_CONTROLLER_EVENTS) == 0 ||
|
|
|
8564 (event & ~SATA_EVNT_CONTROLLER_EVENTS) != 0) {
|
|
|
8565 /* Invalid event for the controller */
|
|
|
8566 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
8567 "sata_hba_event_notify: invalid event 0x%x for "
|
|
|
8568 "controller",
|
|
|
8569 event & SATA_EVNT_CONTROLLER_EVENTS));
|
|
|
8570 return;
|
|
|
8571 }
|
|
|
8572 buf1[0] = '\0';
|
|
|
8573 /* This may be a frequent and not interesting event */
|
|
|
8574 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
|
|
|
8575 "controller power level changed\n", NULL);
|
|
|
8576
|
|
|
8577 mutex_enter(&sata_hba_inst->satahba_mutex);
|
|
|
8578 if (sata_hba_inst->satahba_stats.ctrl_pwr_change <
|
|
|
8579 0xffffffffffffffff)
|
|
|
8580 sata_hba_inst->satahba_stats.ctrl_pwr_change++;
|
|
|
8581
|
|
|
8582 sata_hba_inst->satahba_event_flags |=
|
|
|
8583 SATA_EVNT_PWR_LEVEL_CHANGED;
|
|
|
8584 mutex_exit(&sata_hba_inst->satahba_mutex);
|
|
|
8585 }
|
|
|
8586 /*
|
|
|
8587 * If we got here, there is something to do with this HBA
|
|
|
8588 * instance.
|
|
|
8589 */
|
|
|
8590 mutex_enter(&sata_hba_inst->satahba_mutex);
|
|
|
8591 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
|
|
|
8592 mutex_exit(&sata_hba_inst->satahba_mutex);
|
|
|
8593 mutex_enter(&sata_mutex);
|
|
|
8594 sata_event_pending |= SATA_EVNT_MAIN; /* global event indicator */
|
|
|
8595 mutex_exit(&sata_mutex);
|
|
|
8596
|
|
|
8597 /* Tickle event thread */
|
|
|
8598 mutex_enter(&sata_event_mutex);
|
|
|
8599 if (sata_event_thread_active == 0)
|
|
|
8600 cv_signal(&sata_event_cv);
|
|
|
8601 mutex_exit(&sata_event_mutex);
|
|
|
8602
|
|
|
8603 event_info:
|
|
|
8604 if (buf1[0] != '\0') {
|
|
|
8605 lcp = strrchr(buf1, ',');
|
|
|
8606 if (lcp != NULL)
|
|
|
8607 *lcp = '\0';
|
|
|
8608 }
|
|
|
8609 if (saddr->qual == SATA_ADDR_CPORT ||
|
|
|
8610 saddr->qual == SATA_ADDR_DCPORT) {
|
|
|
8611 if (buf1[0] != '\0') {
|
|
|
8612 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n",
|
|
|
8613 cport, buf1);
|
|
|
8614 }
|
|
|
8615 if (buf2[0] != '\0') {
|
|
|
8616 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n",
|
|
|
8617 cport, buf2);
|
|
|
8618 }
|
|
|
8619 } else if (saddr->qual == SATA_ADDR_PMPORT ||
|
|
|
8620 saddr->qual == SATA_ADDR_DPMPORT) {
|
|
|
8621 if (buf1[0] != '\0') {
|
|
|
8622 sata_log(sata_hba_inst, CE_NOTE,
|
|
|
8623 "port %d pmport %d: %s\n", cport, pmport, buf1);
|
|
|
8624 }
|
|
|
8625 if (buf2[0] != '\0') {
|
|
|
8626 sata_log(sata_hba_inst, CE_NOTE,
|
|
|
8627 "port %d pmport %d: %s\n", cport, pmport, buf2);
|
|
|
8628 }
|
|
|
8629 }
|
|
|
8630 }
|
|
|
8631
|
|
|
8632
|
|
|
8633 /*
|
|
|
8634 * Event processing thread.
|
|
|
8635 * Arg is a pointer to the sata_hba_list pointer.
|
|
|
8636 * It is not really needed, because sata_hba_list is global and static
|
|
|
8637 */
|
|
|
8638 static void
|
|
|
8639 sata_event_daemon(void *arg)
|
|
|
8640 {
|
|
|
8641 #ifndef __lock_lint
|
|
|
8642 _NOTE(ARGUNUSED(arg))
|
|
|
8643 #endif
|
|
|
8644 sata_hba_inst_t *sata_hba_inst;
|
|
|
8645 clock_t lbolt;
|
|
|
8646
|
|
|
8647 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
|
|
|
8648 "SATA event daemon started\n", NULL);
|
|
|
8649 loop:
|
|
|
8650 /*
|
|
|
8651 * Process events here. Walk through all registered HBAs
|
|
|
8652 */
|
|
|
8653 mutex_enter(&sata_mutex);
|
|
|
8654 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
|
|
|
8655 sata_hba_inst = sata_hba_inst->satahba_next) {
|
|
|
8656 ASSERT(sata_hba_inst != NULL);
|
|
|
8657 mutex_enter(&sata_hba_inst->satahba_mutex);
|
|
|
8658 if (sata_hba_inst->satahba_attached != 1 ||
|
|
|
8659 (sata_hba_inst->satahba_event_flags &
|
|
|
8660 SATA_EVNT_SKIP) != 0) {
|
|
|
8661 mutex_exit(&sata_hba_inst->satahba_mutex);
|
|
|
8662 continue;
|
|
|
8663 }
|
|
|
8664 if (sata_hba_inst->satahba_event_flags & SATA_EVNT_MAIN) {
|
|
|
8665 sata_hba_inst->satahba_event_flags |= SATA_EVNT_SKIP;
|
|
|
8666 mutex_exit(&sata_hba_inst->satahba_mutex);
|
|
|
8667 mutex_exit(&sata_mutex);
|
|
|
8668 /* Got the controller with pending event */
|
|
|
8669 sata_process_controller_events(sata_hba_inst);
|
|
|
8670 /*
|
|
|
8671 * Since global mutex was released, there is a
|
|
|
8672 * possibility that HBA list has changed, so start
|
|
|
8673 * over from the top. Just processed controller
|
|
|
8674 * will be passed-over because of the SKIP flag.
|
|
|
8675 */
|
|
|
8676 goto loop;
|
|
|
8677 }
|
|
|
8678 mutex_exit(&sata_hba_inst->satahba_mutex);
|
|
|
8679 }
|
|
|
8680 /* Clear SKIP flag in all controllers */
|
|
|
8681 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
|
|
|
8682 sata_hba_inst = sata_hba_inst->satahba_next) {
|
|
|
8683 mutex_enter(&sata_hba_inst->satahba_mutex);
|
|
|
8684 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_SKIP;
|
|
|
8685 mutex_exit(&sata_hba_inst->satahba_mutex);
|
|
|
8686 }
|
|
|
8687 mutex_exit(&sata_mutex);
|
|
|
8688
|
|
|
8689 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
|
|
|
8690 "SATA EVENT DAEMON suspending itself", NULL);
|
|
|
8691
|
|
|
8692 #ifdef SATA_DEBUG
|
|
|
8693 if ((sata_func_enable & SATA_ENABLE_PROCESS_EVENTS) == 0) {
|
|
|
8694 sata_log(sata_hba_inst, CE_WARN,
|
|
|
8695 "SATA EVENTS PROCESSING DISABLED\n");
|
|
|
8696 thread_exit(); /* Daemon will not run again */
|
|
|
8697 }
|
|
|
8698 #endif
|
|
|
8699 mutex_enter(&sata_event_mutex);
|
|
|
8700 sata_event_thread_active = 0;
|
|
|
8701 mutex_exit(&sata_event_mutex);
|
|
|
8702 /*
|
|
|
8703 * Go to sleep/suspend itself and wake up either because new event or
|
|
|
8704 * wait timeout. Exit if there is a termination request (driver
|
|
|
8705 * unload).
|
|
|
8706 */
|
|
|
8707 do {
|
|
|
8708 lbolt = ddi_get_lbolt();
|
|
|
8709 lbolt += drv_usectohz(SATA_EVNT_DAEMON_SLEEP_TIME);
|
|
|
8710 mutex_enter(&sata_event_mutex);
|
|
|
8711 (void) cv_timedwait(&sata_event_cv, &sata_event_mutex, lbolt);
|
|
|
8712
|
|
|
8713 if (sata_event_thread_active != 0) {
|
|
|
8714 mutex_exit(&sata_event_mutex);
|
|
|
8715 continue;
|
|
|
8716 }
|
|
|
8717
|
|
|
8718 /* Check if it is time to go away */
|
|
|
8719 if (sata_event_thread_terminate == 1) {
|
|
|
8720 /*
|
|
|
8721 * It is up to the thread setting above flag to make
|
|
|
8722 * sure that this thread is not killed prematurely.
|
|
|
8723 */
|
|
|
8724 sata_event_thread_terminate = 0;
|
|
|
8725 sata_event_thread = NULL;
|
|
|
8726 mutex_exit(&sata_event_mutex);
|
|
|
8727 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
|
|
|
8728 "SATA_EVENT_DAEMON_TERMINATING", NULL);
|
|
|
8729 thread_exit(); { _NOTE(NOT_REACHED) }
|
|
|
8730 }
|
|
|
8731 mutex_exit(&sata_event_mutex);
|
|
|
8732 } while (!(sata_event_pending & SATA_EVNT_MAIN));
|
|
|
8733
|
|
|
8734 mutex_enter(&sata_event_mutex);
|
|
|
8735 sata_event_thread_active = 1;
|
|
|
8736 mutex_exit(&sata_event_mutex);
|
|
|
8737
|
|
|
8738 mutex_enter(&sata_mutex);
|
|
|
8739 sata_event_pending &= ~SATA_EVNT_MAIN;
|
|
|
8740 mutex_exit(&sata_mutex);
|
|
|
8741
|
|
|
8742 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
|
|
|
8743 "SATA EVENT DAEMON READY TO PROCESS EVENT", NULL);
|
|
|
8744
|
|
|
8745 goto loop;
|
|
|
8746 }
|
|
|
8747
|
|
|
8748 /*
|
|
|
8749 * Specific HBA instance event processing.
|
|
|
8750 *
|
|
|
8751 * NOTE: At the moment, device event processing is limited to hard disks
|
|
|
8752 * only.
|
|
|
8753 * cports only are supported - no pmports.
|
|
|
8754 */
|
|
|
8755 static void
|
|
|
8756 sata_process_controller_events(sata_hba_inst_t *sata_hba_inst)
|
|
|
8757 {
|
|
|
8758 int ncport;
|
|
|
8759 uint32_t event_flags;
|
|
|
8760 sata_address_t *saddr;
|
|
|
8761
|
|
|
8762 SATADBG1(SATA_DBG_EVENTS_CNTRL, sata_hba_inst,
|
|
|
8763 "Processing controller %d event(s)",
|
|
|
8764 ddi_get_instance(SATA_DIP(sata_hba_inst)));
|
|
|
8765
|
|
|
8766 mutex_enter(&sata_hba_inst->satahba_mutex);
|
|
|
8767 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_MAIN;
|
|
|
8768 event_flags = sata_hba_inst->satahba_event_flags;
|
|
|
8769 mutex_exit(&sata_hba_inst->satahba_mutex);
|
|
|
8770 /*
|
|
|
8771 * Process controller power change first
|
|
|
8772 * HERE
|
|
|
8773 */
|
|
|
8774 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED)
|
|
|
8775 sata_process_cntrl_pwr_level_change(sata_hba_inst);
|
|
|
8776
|
|
|
8777 /*
|
|
|
8778 * Search through ports/devices to identify affected port/device.
|
|
|
8779 * We may have to process events for more than one port/device.
|
|
|
8780 */
|
|
|
8781 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) {
|
|
|
8782 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
|
|
|
8783 event_flags = (SATA_CPORT_INFO(sata_hba_inst, ncport))->
|
|
|
8784 cport_event_flags;
|
|
|
8785 /* Check if port was locked by IOCTL processing */
|
|
|
8786 if (event_flags & SATA_APCTL_LOCK_PORT_BUSY) {
|
|
|
8787 /*
|
|
|
8788 * We ignore port events because port is busy
|
|
|
8789 * with AP control processing. Set again
|
|
|
8790 * controller and main event flag, so that
|
|
|
8791 * events may be processed by the next daemon
|
|
|
8792 * run.
|
|
|
8793 */
|
|
|
8794 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
|
|
|
8795 mutex_enter(&sata_hba_inst->satahba_mutex);
|
|
|
8796 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
|
|
|
8797 mutex_exit(&sata_hba_inst->satahba_mutex);
|
|
|
8798 mutex_enter(&sata_mutex);
|
|
|
8799 sata_event_pending |= SATA_EVNT_MAIN;
|
|
|
8800 mutex_exit(&sata_mutex);
|
|
|
8801 SATADBG1(SATA_DBG_EVENTS_PROCPST, sata_hba_inst,
|
|
|
8802 "Event processing postponed until "
|
|
|
8803 "AP control processing completes",
|
|
|
8804 NULL);
|
|
|
8805 /* Check other ports */
|
|
|
8806 continue;
|
|
|
8807 } else {
|
|
|
8808 /*
|
|
|
8809 * Set BSY flag so that AP control would not
|
|
|
8810 * interfere with events processing for
|
|
|
8811 * this port.
|
|
|
8812 */
|
|
|
8813 (SATA_CPORT_INFO(sata_hba_inst, ncport))->
|
|
|
8814 cport_event_flags |= SATA_EVNT_LOCK_PORT_BUSY;
|
|
|
8815 }
|
|
|
8816 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
|
|
|
8817
|
|
|
8818 saddr = &(SATA_CPORT_INFO(sata_hba_inst, ncport))->cport_addr;
|
|
|
8819
|
|
|
8820 if ((event_flags &
|
|
|
8821 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) {
|
|
|
8822 /*
|
|
|
8823 * Got port event.
|
|
|
8824 * We need some hierarchy of event processing as they
|
|
|
8825 * are affecting each other:
|
|
|
8826 * 1. port failed
|
|
|
8827 * 2. device detached/attached
|
|
|
8828 * 3. link events - link events may trigger device
|
|
|
8829 * detached or device attached events in some
|
|
|
8830 * circumstances.
|
|
|
8831 * 4. port power level changed
|
|
|
8832 */
|
|
|
8833 if (event_flags & SATA_EVNT_PORT_FAILED) {
|
|
|
8834 sata_process_port_failed_event(sata_hba_inst,
|
|
|
8835 saddr);
|
|
|
8836 }
|
|
|
8837 if (event_flags & SATA_EVNT_DEVICE_DETACHED) {
|
|
|
8838 sata_process_device_detached(sata_hba_inst,
|
|
|
8839 saddr);
|
|
|
8840 }
|
|
|
8841 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) {
|
|
|
8842 sata_process_device_attached(sata_hba_inst,
|
|
|
8843 saddr);
|
|
|
8844 }
|
|
|
8845 if (event_flags &
|
|
|
8846 (SATA_EVNT_LINK_ESTABLISHED |
|
|
|
8847 SATA_EVNT_LINK_LOST)) {
|
|
|
8848 sata_process_port_link_events(sata_hba_inst,
|
|
|
8849 saddr);
|
|
|
8850 }
|
|
|
8851 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) {
|
|
|
8852 sata_process_port_pwr_change(sata_hba_inst,
|
|
|
8853 saddr);
|
|
|
8854 }
|
|
|
8855 }
|
|
|
8856 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, ncport) !=
|
|
|
8857 SATA_DTYPE_NONE) {
|
|
|
8858 /* May have device event */
|
|
|
8859 sata_process_device_reset(sata_hba_inst, saddr);
|
|
|
8860 }
|
|
|
8861 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
|
|
|
8862 /* Release PORT_BUSY flag */
|
|
|
8863 (SATA_CPORT_INFO(sata_hba_inst, ncport))->
|
|
|
8864 cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY;
|
|
|
8865 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
|
|
|
8866
|
|
|
8867 } /* End of loop through the controller SATA ports */
|
|
|
8868 }
|
|
|
8869
|
|
|
8870 /*
|
|
|
8871 * Process HBA power level change reported by HBA driver.
|
|
|
8872 * Not implemented at this time - event is ignored.
|
|
|
8873 */
|
|
|
8874 static void
|
|
|
8875 sata_process_cntrl_pwr_level_change(sata_hba_inst_t *sata_hba_inst)
|
|
|
8876 {
|
|
|
8877 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
|
|
|
8878 "Processing controller power level change", NULL);
|
|
|
8879
|
|
|
8880 /* Ignoring it for now */
|
|
|
8881 mutex_enter(&sata_hba_inst->satahba_mutex);
|
|
|
8882 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED;
|
|
|
8883 mutex_exit(&sata_hba_inst->satahba_mutex);
|
|
|
8884 }
|
|
|
8885
|
|
|
8886 /*
|
|
|
8887 * Process port power level change reported by HBA driver.
|
|
|
8888 * Not implemented at this time - event is ignored.
|
|
|
8889 */
|
|
|
8890 static void
|
|
|
8891 sata_process_port_pwr_change(sata_hba_inst_t *sata_hba_inst,
|
|
|
8892 sata_address_t *saddr)
|
|
|
8893 {
|
|
|
8894 sata_cport_info_t *cportinfo;
|
|
|
8895
|
|
|
8896 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
|
|
|
8897 "Processing port power level change", NULL);
|
|
|
8898
|
|
|
8899 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
|
|
|
8900 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
|
|
|
8901 /* Reset event flag */
|
|
|
8902 cportinfo->cport_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED;
|
|
|
8903 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
|
|
|
8904 }
|
|
|
8905
|
|
|
8906 /*
|
|
|
8907 * Process port failure reported by HBA driver.
|
|
|
8908 * cports support only - no pmports.
|
|
|
8909 */
|
|
|
8910 static void
|
|
|
8911 sata_process_port_failed_event(sata_hba_inst_t *sata_hba_inst,
|
|
|
8912 sata_address_t *saddr)
|
|
|
8913 {
|
|
|
8914 sata_cport_info_t *cportinfo;
|
|
|
8915
|
|
|
8916 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
|
|
|
8917 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
|
|
|
8918 /* Reset event flag first */
|
|
|
8919 cportinfo->cport_event_flags &= ~SATA_EVNT_PORT_FAILED;
|
|
|
8920 /* If the port is in SHUTDOWN or FAILED state, ignore this event. */
|
|
|
8921 if ((cportinfo->cport_state &
|
|
|
8922 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0) {
|
|
|
8923 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
|
|
|
8924 cport_mutex);
|
|
|
8925 return;
|
|
|
8926 }
|
|
|
8927 /* Fail the port */
|
|
|
8928 cportinfo->cport_state = SATA_PSTATE_FAILED;
|
|
|
8929 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
|
|
|
8930 sata_log(sata_hba_inst, CE_WARN, "port %d failed", saddr->cport);
|
|
|
8931 }
|
|
|
8932
|
|
|
8933 /*
|
|
|
8934 * Device Reset Event processing.
|
|
|
8935 * The seqeunce is managed by 3 stage flags:
|
|
|
8936 * - reset event reported,
|
|
|
8937 * - reset event being processed,
|
|
|
8938 * - request to clear device reset state.
|
|
|
8939 */
|
|
|
8940 static void
|
|
|
8941 sata_process_device_reset(sata_hba_inst_t *sata_hba_inst,
|
|
|
8942 sata_address_t *saddr)
|
|
|
8943 {
|
|
|
8944 sata_drive_info_t old_sdinfo; /* local copy of the drive info */
|
|
|
8945 sata_drive_info_t *sdinfo;
|
|
|
8946 sata_cport_info_t *cportinfo;
|
|
|
8947 sata_device_t sata_device;
|
|
|
8948 int rval;
|
|
|
8949
|
|
|
8950 /* We only care about host sata cport for now */
|
|
|
8951 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
|
|
|
8952
|
|
|
8953 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
|
|
|
8954
|
|
|
8955 /* If the port is in SHUTDOWN or FAILED state, ignore reset event. */
|
|
|
8956 if ((cportinfo->cport_state &
|
|
|
8957 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
|
|
|
8958 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
|
|
|
8959 cport_mutex);
|
|
|
8960 return;
|
|
|
8961 }
|
|
|
8962
|
|
|
8963 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) &
|
|
|
8964 SATA_VALID_DEV_TYPE) == 0) {
|
|
|
8965 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
|
|
|
8966 cport_mutex);
|
|
|
8967 return;
|
|
|
8968 }
|
|
|
8969 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
|
|
|
8970 if (sdinfo == NULL) {
|
|
|
8971 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
|
|
|
8972 cport_mutex);
|
|
|
8973 return;
|
|
|
8974 }
|
|
|
8975
|
|
|
8976 if ((sdinfo->satadrv_event_flags & SATA_EVNT_DEVICE_RESET) == 0) {
|
|
|
8977 /* Nothing to do */
|
|
|
8978 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
|
|
|
8979 cport_mutex);
|
|
|
8980 return;
|
|
|
8981 }
|
|
|
8982
|
|
|
8983 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
|
|
|
8984 "Processing port %d device reset", saddr->cport);
|
|
|
8985
|
|
|
8986 if (sdinfo->satadrv_event_flags & SATA_EVNT_INPROC_DEVICE_RESET) {
|
|
|
8987 /* Something is weird - new device reset event */
|
|
|
8988 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
|
|
|
8989 "Overlapping device reset events!", NULL);
|
|
|
8990 /* Just leave */
|
|
|
8991 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
|
|
|
8992 cport_mutex);
|
|
|
8993 return;
|
|
|
8994 }
|
|
|
8995
|
|
|
8996 /* Clear event flag */
|
|
|
8997 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET;
|
|
|
8998
|
|
|
8999 /* It seems that we always need to check the port state first */
|
|
|
9000 sata_device.satadev_rev = SATA_DEVICE_REV;
|
|
|
9001 sata_device.satadev_addr = *saddr;
|
|
|
9002 /*
|
|
|
9003 * We have to exit mutex, because the HBA probe port function may
|
|
|
9004 * block on its own mutex.
|
|
|
9005 */
|
|
|
9006 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
|
|
|
9007 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
|
|
|
9008 (SATA_DIP(sata_hba_inst), &sata_device);
|
|
|
9009 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
|
|
|
9010 sata_update_port_info(sata_hba_inst, &sata_device);
|
|
|
9011 if (rval != SATA_SUCCESS) {
|
|
|
9012 /* Something went wrong? Fail the port */
|
|
|
9013 cportinfo->cport_state = SATA_PSTATE_FAILED;
|
|
|
9014 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
|
|
|
9015 cport_mutex);
|
|
|
9016 SATA_LOG_D((sata_hba_inst, CE_WARN, "Port %d probing failed",
|
|
|
9017 saddr->cport));
|
|
|
9018 return;
|
|
|
9019 }
|
|
|
9020 if ((sata_device.satadev_scr.sstatus &
|
|
|
9021 SATA_PORT_DEVLINK_UP_MASK) !=
|
|
|
9022 SATA_PORT_DEVLINK_UP ||
|
|
|
9023 sata_device.satadev_type == SATA_DTYPE_NONE) {
|
|
|
9024 /*
|
|
|
9025 * No device to process, anymore. Some other event processing
|
|
|
9026 * would or have already performed port info cleanup.
|
|
|
9027 * To be safe (HBA may need it), request clearing device
|
|
|
9028 * reset condition.
|
|
|
9029 */
|
|
|
9030 sdinfo->satadrv_event_flags = 0;
|
|
|
9031 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET;
|
|
|
9032 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
|
|
|
9033 cport_mutex);
|
|
|
9034 return;
|
|
|
9035 }
|
|
|
9036
|
|
|
9037 /* Mark device reset processing as active */
|
|
|
9038 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET;
|
|
|
9039
|
|
|
9040 old_sdinfo = *sdinfo; /* local copy of the drive info */
|
|
|
9041 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
|
|
|
9042
|
|
|
9043 if (sata_restore_drive_settings(sata_hba_inst, &old_sdinfo) ==
|
|
|
9044 SATA_FAILURE) {
|
|
|
9045 /*
|
|
|
9046 * Restoring drive setting failed.
|
|
|
9047 * Probe the port first, to check if the port state has changed
|
|
|
9048 */
|
|
|
9049 sata_device.satadev_rev = SATA_DEVICE_REV;
|
|
|
9050 sata_device.satadev_addr = *saddr;
|
|
|
9051 sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
|
|
|
9052 /* probe port */
|
|
|
9053 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
|
|
|
9054 (SATA_DIP(sata_hba_inst), &sata_device);
|
|
|
9055 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
|
|
|
9056 cport_mutex);
|
|
|
9057 if (rval == SATA_SUCCESS &&
|
|
|
9058 (sata_device.satadev_state &
|
|
|
9059 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 &&
|
|
|
9060 (sata_device.satadev_scr.sstatus &
|
|
|
9061 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP &&
|
|
|
9062 (sata_device.satadev_type & SATA_DTYPE_ATADISK) != 0) {
|
|
|
9063 /*
|
|
|
9064 * We may retry this a bit later - reinstate reset
|
|
|
9065 * condition
|
|
|
9066 */
|
|
|
9067 if ((cportinfo->cport_dev_type &
|
|
|
9068 SATA_VALID_DEV_TYPE) != 0 &&
|
|
|
9069 SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
|
|
|
9070 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
|
|
|
9071 sdinfo->satadrv_event_flags |=
|
|
|
9072 SATA_EVNT_DEVICE_RESET;
|
|
|
9073 sdinfo->satadrv_event_flags &=
|
|
|
9074 ~SATA_EVNT_INPROC_DEVICE_RESET;
|
|
|
9075 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
|
|
|
9076 saddr->cport)->cport_mutex);
|
|
|
9077 mutex_enter(&sata_hba_inst->satahba_mutex);
|
|
|
9078 sata_hba_inst->satahba_event_flags |=
|
|
|
9079 SATA_EVNT_MAIN;
|
|
|
9080 mutex_exit(&sata_hba_inst->satahba_mutex);
|
|
|
9081 return;
|
|
|
9082 }
|
|
|
9083 } else {
|
|
|
9084 /*
|
|
|
9085 * No point of retrying - some other event processing
|
|
|
9086 * would or already did port info cleanup.
|
|
|
9087 * To be safe (HBA may need it),
|
|
|
9088 * request clearing device reset condition.
|
|
|
9089 */
|
|
|
9090 sdinfo->satadrv_event_flags = 0;
|
|
|
9091 sdinfo->satadrv_event_flags |=
|
|
|
9092 SATA_EVNT_CLEAR_DEVICE_RESET;
|
|
|
9093 }
|
|
|
9094 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
|
|
|
9095 cport_mutex);
|
|
|
9096 return;
|
|
|
9097 }
|
|
|
9098
|
|
|
9099 /*
|
|
|
9100 * Raise the flag indicating that the next sata command could
|
|
|
9101 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device
|
|
|
9102 * reset is reported.
|
|
|
9103 */
|
|
|
9104 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
|
|
|
9105 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) != 0 &&
|
|
|
9106 SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
|
|
|
9107 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
|
|
|
9108 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET;
|
|
|
9109 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET;
|
|
|
9110 }
|
|
|
9111 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
|
|
|
9112 }
|
|
|
9113
|
|
|
9114
|
|
|
9115 /*
|
|
|
9116 * Port Link Events processing.
|
|
|
9117 * Every link established event may involve device reset (due to
|
|
|
9118 * COMRESET signal, equivalent of the hard reset) so arbitrarily
|
|
|
9119 * set device reset event for an attached device (if any).
|
|
|
9120 * If the port is in SHUTDOWN or FAILED state, ignore link events.
|
|
|
9121 *
|
|
|
9122 * The link established event processing varies, depending on the state
|
|
|
9123 * of the target node, HBA hotplugging capabilities, state of the port.
|
|
|
9124 * If the link is not active, the link established event is ignored.
|
|
|
9125 * If HBA cannot detect device attachment and there is no target node,
|
|
|
9126 * the link established event triggers device attach event processing.
|
|
|
9127 * Else, link established event triggers device reset event processing.
|
|
|
9128 *
|
|
|
9129 * The link lost event processing varies, depending on a HBA hotplugging
|
|
|
9130 * capability and the state of the port (link active or not active).
|
|
|
9131 * If the link is active, the lost link event is ignored.
|
|
|
9132 * If HBA cannot detect device removal, the lost link event triggers
|
|
|
9133 * device detached event processing after link lost timeout.
|
|
|
9134 * Else, the event is ignored.
|
|
|
9135 *
|
|
|
9136 * NOTE: Only cports are processed for now, i.e. no port multiplier ports
|
|
|
9137 */
|
|
|
9138 static void
|
|
|
9139 sata_process_port_link_events(sata_hba_inst_t *sata_hba_inst,
|
|
|
9140 sata_address_t *saddr)
|
|
|
9141 {
|
|
|
9142 sata_device_t sata_device;
|
|
|
9143 sata_cport_info_t *cportinfo;
|
|
|
9144 sata_drive_info_t *sdinfo;
|
|
|
9145 int event_flags;
|
|
|
9146 int rval;
|
|
|
9147
|
|
|
9148 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
|
|
|
9149 "Processing port %d link event(s)", saddr->cport);
|
|
|
9150
|
|
|
9151 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
|
|
|
9152 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
|
|
|
9153 event_flags = cportinfo->cport_event_flags;
|
|
|
9154
|
|
|
9155 /* Reset event flags first */
|
|
|
9156 cportinfo->cport_event_flags &=
|
|
|
9157 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST);
|
|
|
9158
|
|
|
9159 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */
|
|
|
9160 if ((cportinfo->cport_state &
|
|
|
9161 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
|
|
|
9162 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
|
|
|
9163 cport_mutex);
|
|
|
9164 return;
|
|
|
9165 }
|
|
|
9166
|
|
|
9167 /*
|
|
|
9168 * For the sanity sake get current port state.
|
|
|
9169 * Set device address only. Other sata_device fields should be
|
|
|
9170 * set by HBA driver.
|
|
|
9171 */
|
|
|
9172 sata_device.satadev_rev = SATA_DEVICE_REV;
|
|
|
9173 sata_device.satadev_addr = *saddr;
|
|
|
9174 /*
|
|
|
9175 * We have to exit mutex, because the HBA probe port function may
|
|
|
9176 * block on its own mutex.
|
|
|
9177 */
|
|
|
9178 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
|
|
|
9179 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
|
|
|
9180 (SATA_DIP(sata_hba_inst), &sata_device);
|
|
|
9181 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
|
|
|
9182 sata_update_port_info(sata_hba_inst, &sata_device);
|
|
|
9183 if (rval != SATA_SUCCESS) {
|
|
|
9184 /* Something went wrong? Fail the port */
|
|
|
9185 cportinfo->cport_state = SATA_PSTATE_FAILED;
|
|
|
9186 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
|
|
|
9187 cport_mutex);
|
|
|
9188 SATA_LOG_D((sata_hba_inst, CE_WARN, "Port %d probing failed",
|
|
|
9189 saddr->cport));
|
|
|
9190 /*
|
|
|
9191 * We may want to release device info structure, but
|
|
|
9192 * it is not necessary.
|
|
|
9193 */
|
|
|
9194 return;
|
|
|
9195 } else {
|
|
|
9196 /* port probed successfully */
|
|
|
9197 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
|
|
|
9198 }
|
|
|
9199 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) {
|
|
|
9200
|
|
|
9201 if ((sata_device.satadev_scr.sstatus &
|
|
|
9202 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) {
|
|
|
9203 /* Ignore event */
|
|
|
9204 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
|
|
|
9205 "Ignoring port %d link established event - "
|
|
|
9206 "link down",
|
|
|
9207 saddr->cport);
|
|
|
9208 goto linklost;
|
|
|
9209 }
|
|
|
9210
|
|
|
9211 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
|
|
|
9212 "Processing port %d link established event",
|
|
|
9213 saddr->cport);
|
|
|
9214
|
|
|
9215 /*
|
|
|
9216 * For the sanity sake check if a device is attached - check
|
|
|
9217 * return state of a port probing.
|
|
|
9218 */
|
|
|
9219 if (sata_device.satadev_type != SATA_DTYPE_NONE &&
|
|
|
9220 sata_device.satadev_type != SATA_DTYPE_PMULT) {
|
|
|
9221 /*
|
|
|
9222 * HBA port probe indicated that there is a device
|
|
|
9223 * attached. Check if the framework had device info
|
|
|
9224 * structure attached for this device.
|
|
|
9225 */
|
|
|
9226 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
|
|
|
9227 ASSERT(SATA_CPORTINFO_DRV_INFO(cportinfo) !=
|
|
|
9228 NULL);
|
|
|
9229
|
|
|
9230 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
|
|
|
9231 if ((sdinfo->satadrv_type &
|
|
|
9232 SATA_VALID_DEV_TYPE) != 0) {
|
|
|
9233 /*
|
|
|
9234 * Dev info structure is present.
|
|
|
9235 * If dev_type is set to known type in
|
|
|
9236 * the framework's drive info struct
|
|
|
9237 * then the device existed before and
|
|
|
9238 * the link was probably lost
|
|
|
9239 * momentarily - in such case
|
|
|
9240 * we may want to check device
|
|
|
9241 * identity.
|
|
|
9242 * Identity check is not supported now.
|
|
|
9243 *
|
|
|
9244 * Link established event
|
|
|
9245 * triggers device reset event.
|
|
|
9246 */
|
|
|
9247 (SATA_CPORTINFO_DRV_INFO(cportinfo))->
|
|
|
9248 satadrv_event_flags |=
|
|
|
9249 SATA_EVNT_DEVICE_RESET;
|
|
|
9250 }
|
|
|
9251 } else if (cportinfo->cport_dev_type ==
|
|
|
9252 SATA_DTYPE_NONE) {
|
|
|
9253 /*
|
|
|
9254 * We got new device attached! If HBA does not
|
|
|
9255 * generate device attached events, trigger it
|
|
|
9256 * here.
|
|
|
9257 */
|
|
|
9258 if (!(SATA_FEATURES(sata_hba_inst) &
|
|
|
9259 SATA_CTLF_HOTPLUG)) {
|
|
|
9260 cportinfo->cport_event_flags |=
|
|
|
9261 SATA_EVNT_DEVICE_ATTACHED;
|
|
|
9262 }
|
|
|
9263 }
|
|
|
9264 /* Reset link lost timeout */
|
|
|
9265 cportinfo->cport_link_lost_time = 0;
|
|
|
9266 }
|
|
|
9267 }
|
|
|
9268 linklost:
|
|
|
9269 if (event_flags & SATA_EVNT_LINK_LOST) {
|
|
|
9270 if ((sata_device.satadev_scr.sstatus &
|
|
|
9271 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) {
|
|
|
9272 /* Ignore event */
|
|
|
9273 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
|
|
|
9274 "Ignoring port %d link lost event - link is up",
|
|
|
9275 saddr->cport);
|
|
|
9276 goto done;
|
|
|
9277 }
|
|
|
9278 #ifdef SATA_DEBUG
|
|
|
9279 if (cportinfo->cport_link_lost_time == 0) {
|
|
|
9280 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
|
|
|
9281 "Processing port %d link lost event",
|
|
|
9282 saddr->cport);
|
|
|
9283 }
|
|
|
9284 #endif
|
|
|
9285 /*
|
|
|
9286 * When HBA cannot generate device attached/detached events,
|
|
|
9287 * we need to track link lost time and eventually generate
|
|
|
9288 * device detach event.
|
|
|
9289 */
|
|
|
9290 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) {
|
|
|
9291 /* We are tracking link lost time */
|
|
|
9292 if (cportinfo->cport_link_lost_time == 0) {
|
|
|
9293 /* save current time (lbolt value) */
|
|
|
9294 cportinfo->cport_link_lost_time =
|
|
|
9295 ddi_get_lbolt();
|
|
|
9296 /* just keep link lost event */
|
|
|
9297 cportinfo->cport_event_flags |=
|
|
|
9298 SATA_EVNT_LINK_LOST;
|
|
|
9299 } else {
|
|
|
9300 clock_t cur_time = ddi_get_lbolt();
|
|
|
9301 if ((cur_time -
|
|
|
9302 cportinfo->cport_link_lost_time) >=
|
|
|
9303 drv_usectohz(
|
|
|
9304 SATA_EVNT_LINK_LOST_TIMEOUT)) {
|
|
|
9305 /* trigger device detach event */
|
|
|
9306 cportinfo->cport_event_flags |=
|
|
|
9307 SATA_EVNT_DEVICE_DETACHED;
|
|
|
9308 cportinfo->cport_link_lost_time = 0;
|
|
|
9309 SATADBG1(SATA_DBG_EVENTS,
|
|
|
9310 sata_hba_inst,
|
|
|
9311 "Triggering port %d "
|
|
|
9312 "device detached event",
|
|
|
9313 saddr->cport);
|
|
|
9314 } else {
|
|
|
9315 /* keep link lost event */
|
|
|
9316 cportinfo->cport_event_flags |=
|
|
|
9317 SATA_EVNT_LINK_LOST;
|
|
|
9318 }
|
|
|
9319 }
|
|
|
9320 }
|
|
|
9321 /*
|
|
|
9322 * We could change port state to disable/delay access to
|
|
|
9323 * the attached device until the link is recovered.
|
|
|
9324 */
|
|
|
9325 }
|
|
|
9326 done:
|
|
|
9327 event_flags = cportinfo->cport_event_flags;
|
|
|
9328 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
|
|
|
9329 if (event_flags != 0) {
|
|
|
9330 mutex_enter(&sata_hba_inst->satahba_mutex);
|
|
|
9331 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
|
|
|
9332 mutex_exit(&sata_hba_inst->satahba_mutex);
|
|
|
9333 mutex_enter(&sata_mutex);
|
|
|
9334 sata_event_pending |= SATA_EVNT_MAIN;
|
|
|
9335 mutex_exit(&sata_mutex);
|
|
|
9336 }
|
|
|
9337 }
|
|
|
9338
|
|
|
9339 /*
|
|
|
9340 * Device Detached Event processing.
|
|
|
9341 * Port is probed to find if a device is really gone. If so,
|
|
|
9342 * the device info structure is detached from the SATA port info structure
|
|
|
9343 * and released.
|
|
|
9344 * Port status is updated.
|
|
|
9345 *
|
|
|
9346 * NOTE: Process cports event only, no port multiplier ports.
|
|
|
9347 */
|
|
|
9348 static void
|
|
|
9349 sata_process_device_detached(sata_hba_inst_t *sata_hba_inst,
|
|
|
9350 sata_address_t *saddr)
|
|
|
9351 {
|
|
|
9352 sata_cport_info_t *cportinfo;
|
|
|
9353 sata_drive_info_t *sdevinfo;
|
|
|
9354 sata_device_t sata_device;
|
|
|
9355 dev_info_t *tdip;
|
|
|
9356 int rval;
|
|
|
9357
|
|
|
9358 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
|
|
|
9359 "Processing port %d device detached", saddr->cport);
|
|
|
9360
|
|
|
9361 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
|
|
|
9362 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
|
|
|
9363 /* Clear event flag */
|
|
|
9364 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED;
|
|
|
9365
|
|
|
9366 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */
|
|
|
9367 if ((cportinfo->cport_state &
|
|
|
9368 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
|
|
|
9369 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
|
|
|
9370 cport_mutex);
|
|
|
9371 return;
|
|
|
9372 }
|
|
|
9373 /* For sanity, re-probe the port */
|
|
|
9374 sata_device.satadev_rev = SATA_DEVICE_REV;
|
|
|
9375 sata_device.satadev_addr = *saddr;
|
|
|
9376
|
|
|
9377 /*
|
|
|
9378 * We have to exit mutex, because the HBA probe port function may
|
|
|
9379 * block on its own mutex.
|
|
|
9380 */
|
|
|
9381 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
|
|
|
9382 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
|
|
|
9383 (SATA_DIP(sata_hba_inst), &sata_device);
|
|
|
9384 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
|
|
|
9385 sata_update_port_info(sata_hba_inst, &sata_device);
|
|
|
9386 if (rval != SATA_SUCCESS) {
|
|
|
9387 /* Something went wrong? Fail the port */
|
|
|
9388 cportinfo->cport_state = SATA_PSTATE_FAILED;
|
|
|
9389 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
|
|
|
9390 cport_mutex);
|
|
|
9391 SATA_LOG_D((sata_hba_inst, CE_WARN, "Port %d probing failed",
|
|
|
9392 saddr->cport));
|
|
|
9393 /*
|
|
|
9394 * We may want to release device info structure, but
|
|
|
9395 * it is not necessary.
|
|
|
9396 */
|
|
|
9397 return;
|
|
|
9398 } else {
|
|
|
9399 /* port probed successfully */
|
|
|
9400 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
|
|
|
9401 }
|
|
|
9402 /*
|
|
|
9403 * Check if a device is still attached. For sanity, check also
|
|
|
9404 * link status - if no link, there is no device.
|
|
|
9405 */
|
|
|
9406 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) ==
|
|
|
9407 SATA_PORT_DEVLINK_UP && sata_device.satadev_type !=
|
|
|
9408 SATA_DTYPE_NONE) {
|
|
|
9409 /*
|
|
|
9410 * Device is still attached - ignore detach event.
|
|
|
9411 */
|
|
|
9412 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
|
|
|
9413 cport_mutex);
|
|
|
9414 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
|
|
|
9415 "Ignoring detach - device still attached to port %d",
|
|
|
9416 sata_device.satadev_addr.cport);
|
|
|
9417 return;
|
|
|
9418 }
|
|
|
9419 /*
|
|
|
9420 * We need to detach and release device info structure here
|
|
|
9421 */
|
|
|
9422 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
|
|
|
9423 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
|
|
|
9424 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
|
|
|
9425 (void) kmem_free((void *)sdevinfo,
|
|
|
9426 sizeof (sata_drive_info_t));
|
|
|
9427 }
|
|
|
9428 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
|
|
|
9429 /*
|
|
|
9430 * Device cannot be reached anymore, even if the target node may be
|
|
|
9431 * still present.
|
|
|
9432 */
|
|
|
9433
|
|
|
9434 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
|
|
|
9435 sata_log(sata_hba_inst, CE_WARN, "SATA device detached at port %d",
|
|
|
9436 sata_device.satadev_addr.cport);
|
|
|
9437
|
|
|
9438 /*
|
|
|
9439 * Try to offline a device and remove target node if it still exists
|
|
|
9440 */
|
|
|
9441 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport);
|
|
|
9442 if (tdip != NULL) {
|
|
|
9443 /*
|
|
|
9444 * target node exist - unconfigure device first, then remove
|
|
|
9445 * the node
|
|
|
9446 */
|
|
|
9447 if (ndi_devi_offline(tdip, NDI_UNCONFIG) != NDI_SUCCESS) {
|
|
|
9448 /*
|
|
|
9449 * PROBLEM - no device, but target node remained
|
|
|
9450 * This happens when the file was open or node was
|
|
|
9451 * waiting for resources.
|
|
|
9452 */
|
|
|
9453 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
9454 "sata_process_device_detached: "
|
|
|
9455 "Failed to unconfigure removed device."));
|
|
|
9456 }
|
|
|
9457 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != NDI_SUCCESS) {
|
|
|
9458 /*
|
|
|
9459 * PROBLEM - no device, but target node remained
|
|
|
9460 * This happens when the file was open or node was
|
|
|
9461 * waiting for resources.
|
|
|
9462 */
|
|
|
9463 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
9464 "sata_process_device_detached: "
|
|
|
9465 "Failed to remove target node for "
|
|
|
9466 "removed device."));
|
|
|
9467 }
|
|
|
9468 }
|
|
|
9469
|
|
|
9470 }
|
|
|
9471
|
|
|
9472
|
|
|
9473 /*
|
|
|
9474 * Device Attached Event processing.
|
|
|
9475 * Port state is checked to verify that a device is really attached. If so,
|
|
|
9476 * the device info structure is created and attached to the SATA port info
|
|
|
9477 * structure.
|
|
|
9478 *
|
|
|
9479 * This function cannot be called in interrupt context (it may sleep).
|
|
|
9480 *
|
|
|
9481 * NOTE: Process cports event only, no port multiplier ports.
|
|
|
9482 */
|
|
|
9483 static void
|
|
|
9484 sata_process_device_attached(sata_hba_inst_t *sata_hba_inst,
|
|
|
9485 sata_address_t *saddr)
|
|
|
9486 {
|
|
|
9487 sata_cport_info_t *cportinfo;
|
|
|
9488 sata_drive_info_t *sdevinfo;
|
|
|
9489 sata_device_t sata_device;
|
|
|
9490 dev_info_t *tdip;
|
|
|
9491
|
|
|
9492 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
|
|
|
9493 "Processing port %d device attached", saddr->cport);
|
|
|
9494
|
|
|
9495 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
|
|
|
9496 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
|
|
|
9497
|
|
|
9498 /* Clear event flag first */
|
|
|
9499 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED;
|
|
|
9500 /* If the port is in SHUTDOWN or FAILED state, ignore event. */
|
|
|
9501 if ((cportinfo->cport_state &
|
|
|
9502 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
|
|
|
9503 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
|
|
|
9504 cport_mutex);
|
|
|
9505 return;
|
|
|
9506 }
|
|
|
9507
|
|
|
9508 /*
|
|
|
9509 * If the sata_drive_info structure is found attached to the port info,
|
|
|
9510 * something went wrong in the event reporting and processing sequence.
|
|
|
9511 * To recover, arbitrarily release device info structure and issue
|
|
|
9512 * a warning.
|
|
|
9513 */
|
|
|
9514 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
|
|
|
9515 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
|
|
|
9516 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
|
|
|
9517 (void) kmem_free((void *)sdevinfo,
|
|
|
9518 sizeof (sata_drive_info_t));
|
|
|
9519 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
9520 "Arbitrarily detaching old device info."));
|
|
|
9521 }
|
|
|
9522 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
|
|
|
9523 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
|
|
|
9524 /*
|
|
|
9525 * Make sure that there is no target node for that device.
|
|
|
9526 * If so, release it. It should not happen, unless we had problem
|
|
|
9527 * removing the node when device was detached.
|
|
|
9528 */
|
|
|
9529 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport);
|
|
|
9530 if (tdip != NULL) {
|
|
|
9531
|
|
|
9532 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
9533 "sata_process_device_attached: "
|
|
|
9534 "old device target node exists!!!"));
|
|
|
9535 /*
|
|
|
9536 * target node exist - unconfigure device first, then remove
|
|
|
9537 * the node
|
|
|
9538 */
|
|
|
9539 if (ndi_devi_offline(tdip, NDI_UNCONFIG) != NDI_SUCCESS) {
|
|
|
9540 /*
|
|
|
9541 * PROBLEM - no device, but target node remained
|
|
|
9542 * This happens when the file was open or node was
|
|
|
9543 * waiting for resources.
|
|
|
9544 */
|
|
|
9545 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
9546 "sata_process_device_attached: "
|
|
|
9547 "Failed to unconfigure old target node!"));
|
|
|
9548 }
|
|
|
9549 /* Following call will retry node offlining and removing it */
|
|
|
9550 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != NDI_SUCCESS) {
|
|
|
9551 /* PROBLEM - no device, but target node remained */
|
|
|
9552 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
9553 "sata_process_device_attached: "
|
|
|
9554 "Failed to remove old target node!"));
|
|
|
9555 /*
|
|
|
9556 * It is not clear, what should be done here.
|
|
|
9557 * For now, we will not attach a new device
|
|
|
9558 */
|
|
|
9559 return;
|
|
|
9560 }
|
|
|
9561 }
|
|
|
9562
|
|
|
9563 /*
|
|
|
9564 * Reprobing port will take care of detecting device presence,
|
|
|
9565 * creation of the device info structure and determination of the
|
|
|
9566 * device type.
|
|
|
9567 */
|
|
|
9568 sata_device.satadev_addr = *saddr;
|
|
|
9569 (void) sata_reprobe_port(sata_hba_inst, &sata_device);
|
|
|
9570 /*
|
|
|
9571 * If device was successfully attached, an explicit
|
|
|
9572 * 'configure' command is needed to configure it.
|
|
|
9573 */
|
|
|
9574 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
|
|
|
9575 if ((cportinfo->cport_state & SATA_STATE_READY) &&
|
|
|
9576 cportinfo->cport_dev_type != SATA_DTYPE_NONE &&
|
|
|
9577 SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
|
|
|
9578 sata_drive_info_t new_sdinfo;
|
|
|
9579
|
|
|
9580 /* Log device info data */
|
|
|
9581 new_sdinfo = *(SATA_CPORTINFO_DRV_INFO(cportinfo));
|
|
|
9582 sata_show_drive_info(sata_hba_inst, &new_sdinfo);
|
|
|
9583 }
|
|
|
9584 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
|
|
|
9585 }
|
|
|
9586
|
|
|
9587
|
|
|
9588 /*
|
|
|
9589 * sata_restore_drive_settings function compares current device setting
|
|
|
9590 * with the saved device setting and, if there is a difference, restores
|
|
|
9591 * device setting to the stored state.
|
|
|
9592 * Device Identify data has to be current.
|
|
|
9593 * At the moment only read ahead and write cache settings are considered.
|
|
|
9594 *
|
|
|
9595 * This function cannot be called in the interrupt context (it may sleep).
|
|
|
9596 *
|
|
|
9597 * Returns TRUE if successful or there was nothing to do.
|
|
|
9598 * Returns FALSE if device setting could not be restored.
|
|
|
9599 *
|
|
|
9600 * Note: This function may fail the port, making it inaccessible.
|
|
|
9601 * Explicit port disconnect/connect or physical device
|
|
|
9602 * detach/attach is required to re-evaluate it's state afterwards
|
|
|
9603 */
|
|
|
9604 static int
|
|
|
9605 sata_restore_drive_settings(sata_hba_inst_t *sata_hba_inst,
|
|
|
9606 sata_drive_info_t *sdinfo)
|
|
|
9607 {
|
|
|
9608 sata_pkt_t *spkt;
|
|
|
9609 sata_cmd_t *scmd;
|
|
|
9610 sata_pkt_txlate_t *spx;
|
|
|
9611 int rval = SATA_SUCCESS;
|
|
|
9612 sata_drive_info_t new_sdinfo;
|
|
|
9613
|
|
|
9614 bzero(&new_sdinfo, sizeof (sata_drive_info_t));
|
|
|
9615 new_sdinfo.satadrv_addr = sdinfo->satadrv_addr;
|
|
|
9616 new_sdinfo.satadrv_type = sdinfo->satadrv_type;
|
|
|
9617 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) {
|
|
|
9618 /*
|
|
|
9619 * Cannot get device identification - retry later
|
|
|
9620 */
|
|
|
9621 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
9622 "sata_restore_drive_settings: "
|
|
|
9623 "cannot fetch device identify data\n"));
|
|
|
9624 return (SATA_FAILURE);
|
|
|
9625 }
|
|
|
9626 /* Arbitrarily set UDMA mode */
|
|
|
9627 if (sata_set_udma_mode(sata_hba_inst, &new_sdinfo) != SATA_SUCCESS) {
|
|
|
9628 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
9629 "sata_restore_drive_settings: cannot set UDMA mode\n"));
|
|
|
9630 return (SATA_FAILURE);
|
|
|
9631 }
|
|
|
9632
|
|
|
9633 if (!(new_sdinfo.satadrv_id.ai_cmdset82 & SATA_LOOK_AHEAD) &&
|
|
|
9634 !(new_sdinfo.satadrv_id.ai_cmdset82 & SATA_WRITE_CACHE)) {
|
|
|
9635 /* None of the features is supported - do nothing */
|
|
|
9636 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
|
|
|
9637 "restorable features not supported\n", NULL);
|
|
|
9638 return (SATA_SUCCESS);
|
|
|
9639 }
|
|
|
9640
|
|
|
9641 if (((new_sdinfo.satadrv_id.ai_features85 & SATA_LOOK_AHEAD) &&
|
|
|
9642 (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD)) &&
|
|
|
9643 ((new_sdinfo.satadrv_id.ai_features85 & SATA_WRITE_CACHE) &&
|
|
|
9644 (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) {
|
|
|
9645 /* Nothing to do */
|
|
|
9646 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
|
|
|
9647 "nothing to restore\n", NULL);
|
|
|
9648 return (SATA_SUCCESS);
|
|
|
9649 }
|
|
|
9650
|
|
|
9651 /* Prepare packet for SET FEATURES COMMAND */
|
|
|
9652 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
|
|
|
9653 spx->txlt_sata_hba_inst = sata_hba_inst;
|
|
|
9654 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
|
|
|
9655 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
|
|
|
9656 if (spkt == NULL) {
|
|
|
9657 kmem_free(spx, sizeof (sata_pkt_txlate_t));
|
|
|
9658 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
9659 "sata_restore_drive_settings: could not "
|
|
|
9660 "restore device settings\n"));
|
|
|
9661 return (SATA_FAILURE);
|
|
|
9662 }
|
|
|
9663
|
|
|
9664 /* Fill sata_pkt */
|
|
|
9665 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
|
|
|
9666 /* Timeout 30s */
|
|
|
9667 spkt->satapkt_time = sata_default_pkt_time;
|
|
|
9668 /* Synchronous mode, no callback */
|
|
|
9669 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
|
|
|
9670 spkt->satapkt_comp = NULL;
|
|
|
9671 scmd = &spkt->satapkt_cmd;
|
|
|
9672 scmd->satacmd_flags =
|
|
|
9673 SATA_DIR_NODATA_XFER | SATA_IGNORE_DEV_RESET_STATE;
|
|
|
9674 scmd->satacmd_addr_type = 0;
|
|
|
9675 scmd->satacmd_device_reg = 0;
|
|
|
9676 scmd->satacmd_status_reg = 0;
|
|
|
9677 scmd->satacmd_error_reg = 0;
|
|
|
9678 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
|
|
|
9679
|
|
|
9680 if (!((new_sdinfo.satadrv_id.ai_features85 & SATA_LOOK_AHEAD) &&
|
|
|
9681 (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD))) {
|
|
|
9682 if (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD)
|
|
|
9683 /* Enable read ahead / read cache */
|
|
|
9684 scmd->satacmd_features_reg =
|
|
|
9685 SATAC_SF_ENABLE_READ_AHEAD;
|
|
|
9686 else
|
|
|
9687 /* Disable read ahead / read cache */
|
|
|
9688 scmd->satacmd_features_reg =
|
|
|
9689 SATAC_SF_DISABLE_READ_AHEAD;
|
|
|
9690
|
|
|
9691 /* Transfer command to HBA */
|
|
|
9692 if (((*SATA_START_FUNC(sata_hba_inst))
|
|
|
9693 (SATA_DIP(sata_hba_inst), spkt) != 0) ||
|
|
|
9694 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) {
|
|
|
9695 /* Pkt execution failed */
|
|
|
9696 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
9697 "sata_restore_drive_settings: could not "
|
|
|
9698 "restore device settings\n"));
|
|
|
9699 rval = SATA_FAILURE;
|
|
|
9700 }
|
|
|
9701 }
|
|
|
9702 /* Note that the sata packet is not removed, so it could be re-used */
|
|
|
9703
|
|
|
9704 if (!((new_sdinfo.satadrv_id.ai_features85 & SATA_WRITE_CACHE) &&
|
|
|
9705 (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) {
|
|
|
9706 if (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE)
|
|
|
9707 /* Enable write cache */
|
|
|
9708 scmd->satacmd_features_reg =
|
|
|
9709 SATAC_SF_ENABLE_WRITE_CACHE;
|
|
|
9710 else
|
|
|
9711 /* Disable write cache */
|
|
|
9712 scmd->satacmd_features_reg =
|
|
|
9713 SATAC_SF_DISABLE_WRITE_CACHE;
|
|
|
9714
|
|
|
9715 /* Transfer command to HBA */
|
|
|
9716 if (((*SATA_START_FUNC(sata_hba_inst))(
|
|
|
9717 SATA_DIP(sata_hba_inst), spkt) != 0) ||
|
|
|
9718 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) {
|
|
|
9719 /* Pkt execution failed */
|
|
|
9720 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
9721 "sata_restore_drive_settings: could not "
|
|
|
9722 "restore device settings\n"));
|
|
|
9723 rval = SATA_FAILURE;
|
|
|
9724 }
|
|
|
9725 }
|
|
|
9726
|
|
|
9727 /* Free allocated resources */
|
|
|
9728 sata_pkt_free(spx);
|
|
|
9729 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
|
|
|
9730
|
|
|
9731 /*
|
|
|
9732 * We need to fetch Device Identify data again
|
|
|
9733 */
|
|
|
9734 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) {
|
|
|
9735 /*
|
|
|
9736 * Cannot get device identification - retry later
|
|
|
9737 */
|
|
|
9738 SATA_LOG_D((sata_hba_inst, CE_WARN,
|
|
|
9739 "sata_restore_drive_settings: "
|
|
|
9740 "cannot re-fetch device identify data\n"));
|
|
|
9741 rval = SATA_FAILURE;
|
|
|
9742 }
|
|
|
9743 /* Copy device sata info. */
|
|
|
9744 sdinfo->satadrv_id = new_sdinfo.satadrv_id;
|
|
|
9745
|
|
|
9746 return (rval);
|
|
|
9747 }
|
