1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * BSD LICENSE
5 *
6 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 *
13 * * Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * * Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in
17 * the documentation and/or other materials provided with the
18 * distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 */
32
33 #include <sys/cdefs.h>
34 #include <dev/isci/isci.h>
35
36 #include <cam/cam_periph.h>
37 #include <cam/cam_xpt_periph.h>
38
39 #include <dev/isci/scil/scif_domain.h>
40 #include <dev/isci/scil/scif_remote_device.h>
41 #include <dev/isci/scil/scif_controller.h>
42 #include <dev/isci/scil/scif_user_callback.h>
43
44 /**
45 * @brief This callback method informs the framework user that something
46 * in the supplied domain has changed (e.g. a device was added or
47 * removed).
48 *
49 * This callback is called by the framework outside of discovery or
50 * target reset processes. Specifically, domain changes occurring
51 * during these processes are handled by the framework. For example,
52 * in the case of Serial Attached SCSI, reception of a BROADCAST (CHANGE)
53 * during discovery will cause discovery to restart. Thus, discovery
54 * does not complete until all BCNs are processed. Note, during controller
55 * stopping/reset process, the framework user should not expect this call
56 * back.
57 *
58 * @param[in] controller This parameter specifies the controller object
59 * with which this callback is associated.
60 * @param[in] domain This parameter specifies the domain object with
61 * which this callback is associated.
62 *
63 * @return none
64 */
65 void
scif_cb_domain_change_notification(SCI_CONTROLLER_HANDLE_T controller,SCI_DOMAIN_HANDLE_T domain)66 scif_cb_domain_change_notification(SCI_CONTROLLER_HANDLE_T controller,
67 SCI_DOMAIN_HANDLE_T domain)
68 {
69 struct ISCI_CONTROLLER *isci_controller =
70 (struct ISCI_CONTROLLER *)sci_object_get_association(controller);
71
72 /* When the controller start is complete, we will explicitly discover
73 * all of the domains then. This is because SCIF will not allow
74 * any I/O to start until the controller is ready, meaning internal SMP
75 * requests triggered by domain discovery won't work until the controller
76 * is ready.
77 */
78 if (isci_controller->is_started == TRUE)
79 scif_domain_discover(domain,
80 scif_domain_get_suggested_discover_timeout(domain),
81 DEVICE_TIMEOUT);
82 }
83
84 /**
85 * @brief This callback method informs the framework user that a previously
86 * requested discovery operation on the domain has completed.
87 *
88 * @param[in] controller This parameter specifies the controller object
89 * with which this callback is associated.
90 * @param[in] domain This parameter specifies the domain object with
91 * which this callback is associated.
92 * @param[in] completion_status This parameter indicates the results of the
93 * discovery operation.
94 *
95 * @return none
96 */
97 void
scif_cb_domain_discovery_complete(SCI_CONTROLLER_HANDLE_T controller,SCI_DOMAIN_HANDLE_T domain,SCI_STATUS completion_status)98 scif_cb_domain_discovery_complete(SCI_CONTROLLER_HANDLE_T controller,
99 SCI_DOMAIN_HANDLE_T domain, SCI_STATUS completion_status)
100 {
101
102 if(completion_status != SCI_SUCCESS)
103 isci_log_message(0, "ISCI",
104 "scif_cb_domain_discovery_complete status = 0x%x\n",
105 completion_status);
106
107 isci_controller_domain_discovery_complete(
108 (struct ISCI_CONTROLLER *)sci_object_get_association(controller),
109 (struct ISCI_DOMAIN *) sci_object_get_association(domain));
110 }
111
112 /**
113 * @brief This callback method informs the framework user that a previously
114 * requested reset operation on the domain has completed.
115 *
116 * @param[in] controller This parameter specifies the controller object
117 * with which this callback is associated.
118 * @param[in] domain This parameter specifies the domain object with
119 * which this callback is associated.
120 * @param[in] completion_status This parameter indicates the results of the
121 * reset operation.
122 *
123 * @return none
124 */
125 void
scif_cb_domain_reset_complete(SCI_CONTROLLER_HANDLE_T controller,SCI_DOMAIN_HANDLE_T domain,SCI_STATUS completion_status)126 scif_cb_domain_reset_complete(SCI_CONTROLLER_HANDLE_T controller,
127 SCI_DOMAIN_HANDLE_T domain, SCI_STATUS completion_status)
128 {
129
130 }
131
132 /**
133 * @brief This callback method informs the framework user that the domain
134 * is ready and capable of processing IO requests for devices found
135 * inside it.
136 *
137 * @param[in] controller This parameter specifies the controller object
138 * with which this callback is associated.
139 * @param[in] domain This parameter specifies the domain object with
140 * which this callback is associated.
141 *
142 * @return none
143 */
144 void
scif_cb_domain_ready(SCI_CONTROLLER_HANDLE_T controller,SCI_DOMAIN_HANDLE_T domain)145 scif_cb_domain_ready(SCI_CONTROLLER_HANDLE_T controller,
146 SCI_DOMAIN_HANDLE_T domain)
147 {
148 uint32_t i;
149 struct ISCI_DOMAIN *isci_domain = sci_object_get_association(domain);
150 struct ISCI_CONTROLLER *isci_controller =
151 sci_object_get_association(controller);
152
153 for (i = 0; i < SCI_MAX_REMOTE_DEVICES; i++) {
154 struct ISCI_REMOTE_DEVICE *remote_device =
155 isci_controller->remote_device[i];
156
157 if (remote_device != NULL &&
158 remote_device->domain == isci_domain)
159 isci_remote_device_release_device_queue(remote_device);
160 }
161 }
162
163 /**
164 * @brief This callback method informs the framework user that the domain
165 * is no longer ready. Thus, it is incapable of processing IO
166 * requests for devices found inside it.
167 *
168 * @param[in] controller This parameter specifies the controller object
169 * with which this callback is associated.
170 * @param[in] domain This parameter specifies the domain object with
171 * which this callback is associated.
172 *
173 * @return none
174 */
175 void
scif_cb_domain_not_ready(SCI_CONTROLLER_HANDLE_T controller,SCI_DOMAIN_HANDLE_T domain)176 scif_cb_domain_not_ready(SCI_CONTROLLER_HANDLE_T controller,
177 SCI_DOMAIN_HANDLE_T domain)
178 {
179
180 }
181
182 /**
183 * @brief This callback method informs the framework user that a new
184 * direct attached device was found in the domain.
185 *
186 * @param[in] controller This parameter specifies the controller object
187 * with which this callback is associated.
188 * @param[in] domain This parameter specifies the domain object with
189 * which this callback is associated.
190 * @param[in] sas_address This parameter specifies the SAS address of
191 * the new device.
192 * @param[in] protocols This parameter specifies the protocols
193 * supported by the newly discovered device.
194 *
195 * @return none
196 */
197 void
scif_cb_domain_da_device_added(SCI_CONTROLLER_HANDLE_T controller,SCI_DOMAIN_HANDLE_T domain,SCI_SAS_ADDRESS_T * sas_address,SCI_SAS_IDENTIFY_ADDRESS_FRAME_PROTOCOLS_T * protocols)198 scif_cb_domain_da_device_added(SCI_CONTROLLER_HANDLE_T controller,
199 SCI_DOMAIN_HANDLE_T domain, SCI_SAS_ADDRESS_T *sas_address,
200 SCI_SAS_IDENTIFY_ADDRESS_FRAME_PROTOCOLS_T *protocols)
201 {
202 struct ISCI_REMOTE_DEVICE *remote_device;
203 struct ISCI_DOMAIN *isci_domain =
204 (struct ISCI_DOMAIN *)sci_object_get_association(domain);
205
206 /*
207 * For direct-attached devices, do not pull the device object from
208 * the pool. Rather, use the one stored in the domain object which
209 * will ensure that we always get consistent target ids for direct
210 * attached devices.
211 */
212 remote_device = isci_domain->da_remote_device;
213
214 scif_remote_device_construct(domain,
215 (uint8_t*)remote_device + sizeof(struct ISCI_REMOTE_DEVICE),
216 &(remote_device->sci_object));
217
218 sci_object_set_association(remote_device->sci_object, remote_device);
219
220 scif_remote_device_da_construct(remote_device->sci_object, sas_address,
221 protocols);
222
223 /* We do not put the device in the ISCI_CONTROLLER's device array yet.
224 * That will happen once the device becomes ready (see
225 * scif_cb_remote_device_ready).
226 */
227
228 remote_device->domain = isci_domain;
229 }
230
231 /**
232 * @brief This callback method informs the framework user that a new
233 * expander attached device was found in the domain.
234 *
235 * @param[in] controller This parameter specifies the controller object
236 * with which this callback is associated.
237 * @param[in] domain This parameter specifies the domain object with
238 * which this callback is associated.
239 * @param[in] containing_device This parameter specifies the remote
240 * device that contains the device that was added.
241 * @param[in] smp_response This parameter specifies the SMP response
242 * data associated with the newly discovered device.
243 *
244 * @return none
245 */
246 void
scif_cb_domain_ea_device_added(SCI_CONTROLLER_HANDLE_T controller,SCI_DOMAIN_HANDLE_T domain,SCI_REMOTE_DEVICE_HANDLE_T containing_device,SMP_RESPONSE_DISCOVER_T * smp_response)247 scif_cb_domain_ea_device_added(SCI_CONTROLLER_HANDLE_T controller,
248 SCI_DOMAIN_HANDLE_T domain, SCI_REMOTE_DEVICE_HANDLE_T containing_device,
249 SMP_RESPONSE_DISCOVER_T *smp_response)
250 {
251 struct ISCI_REMOTE_DEVICE *remote_device;
252 struct ISCI_DOMAIN *isci_domain =
253 (struct ISCI_DOMAIN *)sci_object_get_association(domain);
254 struct ISCI_CONTROLLER *isci_controller =
255 (struct ISCI_CONTROLLER *)sci_object_get_association(controller);
256
257 sci_pool_get(isci_controller->remote_device_pool, remote_device);
258
259 scif_remote_device_construct( domain,
260 (uint8_t*)remote_device + sizeof(struct ISCI_REMOTE_DEVICE),
261 &(remote_device->sci_object));
262
263 sci_object_set_association(remote_device->sci_object, remote_device);
264
265 scif_remote_device_ea_construct(remote_device->sci_object,
266 containing_device, smp_response);
267
268 /* We do not put the device in the ISCI_CONTROLLER's device array yet.
269 * That will happen once the device becomes ready (see
270 * scif_cb_remote_device_ready).
271 */
272 remote_device->domain = isci_domain;
273 }
274
275 /**
276 * @brief This callback method informs the framework user that a device
277 * has been removed from the domain.
278 *
279 * @param[in] controller This parameter specifies the controller object
280 * with which this callback is associated.
281 * @param[in] domain This parameter specifies the domain object with
282 * which this callback is associated.
283 * @param[in] remote_device This parameter specifies the device object with
284 * which this callback is associated.
285 *
286 * @return none
287 */
288 void
scif_cb_domain_device_removed(SCI_CONTROLLER_HANDLE_T controller,SCI_DOMAIN_HANDLE_T domain,SCI_REMOTE_DEVICE_HANDLE_T remote_device)289 scif_cb_domain_device_removed(SCI_CONTROLLER_HANDLE_T controller,
290 SCI_DOMAIN_HANDLE_T domain, SCI_REMOTE_DEVICE_HANDLE_T remote_device)
291 {
292 struct ISCI_REMOTE_DEVICE *isci_remote_device =
293 (struct ISCI_REMOTE_DEVICE *)sci_object_get_association(remote_device);
294 struct ISCI_DOMAIN *isci_domain =
295 (struct ISCI_DOMAIN *)sci_object_get_association(domain);
296 struct ISCI_CONTROLLER *isci_controller =
297 (struct ISCI_CONTROLLER *)sci_object_get_association(controller);
298 uint32_t path = cam_sim_path(isci_controller->sim);
299 union ccb *ccb = xpt_alloc_ccb_nowait();
300
301 isci_controller->remote_device[isci_remote_device->index] = NULL;
302
303 xpt_create_path(&ccb->ccb_h.path, NULL, path,
304 isci_remote_device->index, CAM_LUN_WILDCARD);
305
306 xpt_rescan(ccb);
307
308 scif_remote_device_destruct(remote_device);
309
310 /*
311 * Only put the remote device back into the pool if it was an
312 * expander-attached device.
313 */
314 if (isci_remote_device != isci_domain->da_remote_device)
315 sci_pool_put(isci_controller->remote_device_pool,
316 isci_remote_device);
317 }
318
319 void
isci_domain_construct(struct ISCI_DOMAIN * domain,uint32_t domain_index,struct ISCI_CONTROLLER * controller)320 isci_domain_construct(struct ISCI_DOMAIN *domain, uint32_t domain_index,
321 struct ISCI_CONTROLLER *controller)
322 {
323
324 scif_controller_get_domain_handle( controller->scif_controller_handle,
325 domain_index, &domain->sci_object);
326
327 domain->index = domain_index;
328 domain->controller = controller;
329 sci_object_set_association(domain->sci_object, (void *)domain);
330 }
331