Commit | Line | Data |
---|---|---|
86b89cb0 | 1 | // SPDX-License-Identifier: GPL-2.0 |
2908d778 JB |
2 | /* |
3 | * Serial Attached SCSI (SAS) Discover process | |
4 | * | |
5 | * Copyright (C) 2005 Adaptec, Inc. All rights reserved. | |
6 | * Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com> | |
2908d778 JB |
7 | */ |
8 | ||
2908d778 | 9 | #include <linux/scatterlist.h> |
5a0e3ad6 | 10 | #include <linux/slab.h> |
2908d778 JB |
11 | #include <scsi/scsi_host.h> |
12 | #include <scsi/scsi_eh.h> | |
13 | #include "sas_internal.h" | |
14 | ||
15 | #include <scsi/scsi_transport.h> | |
16 | #include <scsi/scsi_transport_sas.h> | |
756f173f | 17 | #include <scsi/sas_ata.h> |
e15f669c | 18 | #include "scsi_sas_internal.h" |
2908d778 JB |
19 | |
20 | /* ---------- Basic task processing for discovery purposes ---------- */ | |
21 | ||
22 | void sas_init_dev(struct domain_device *dev) | |
23 | { | |
89d3cf6a | 24 | switch (dev->dev_type) { |
aa9f8328 | 25 | case SAS_END_DEVICE: |
5db45bdc | 26 | INIT_LIST_HEAD(&dev->ssp_dev.eh_list_node); |
89d3cf6a | 27 | break; |
aa9f8328 JB |
28 | case SAS_EDGE_EXPANDER_DEVICE: |
29 | case SAS_FANOUT_EXPANDER_DEVICE: | |
89d3cf6a JS |
30 | INIT_LIST_HEAD(&dev->ex_dev.children); |
31 | mutex_init(&dev->ex_dev.cmd_mutex); | |
32 | break; | |
89d3cf6a JS |
33 | default: |
34 | break; | |
35 | } | |
2908d778 JB |
36 | } |
37 | ||
2908d778 JB |
38 | /* ---------- Domain device discovery ---------- */ |
39 | ||
40 | /** | |
121246ae | 41 | * sas_get_port_device - Discover devices which caused port creation |
2908d778 JB |
42 | * @port: pointer to struct sas_port of interest |
43 | * | |
44 | * Devices directly attached to a HA port, have no parent. This is | |
45 | * how we know they are (domain) "root" devices. All other devices | |
46 | * do, and should have their "parent" pointer set appropriately as | |
47 | * soon as a child device is discovered. | |
48 | */ | |
49 | static int sas_get_port_device(struct asd_sas_port *port) | |
50 | { | |
2908d778 JB |
51 | struct asd_sas_phy *phy; |
52 | struct sas_rphy *rphy; | |
53 | struct domain_device *dev; | |
b2024459 | 54 | int rc = -ENODEV; |
2908d778 | 55 | |
735f7d2f | 56 | dev = sas_alloc_device(); |
2908d778 JB |
57 | if (!dev) |
58 | return -ENOMEM; | |
59 | ||
899fcf40 | 60 | spin_lock_irq(&port->phy_list_lock); |
2908d778 | 61 | if (list_empty(&port->phy_list)) { |
899fcf40 | 62 | spin_unlock_irq(&port->phy_list_lock); |
735f7d2f | 63 | sas_put_device(dev); |
2908d778 JB |
64 | return -ENODEV; |
65 | } | |
66 | phy = container_of(port->phy_list.next, struct asd_sas_phy, port_phy_el); | |
67 | spin_lock(&phy->frame_rcvd_lock); | |
68 | memcpy(dev->frame_rcvd, phy->frame_rcvd, min(sizeof(dev->frame_rcvd), | |
69 | (size_t)phy->frame_rcvd_size)); | |
70 | spin_unlock(&phy->frame_rcvd_lock); | |
899fcf40 | 71 | spin_unlock_irq(&port->phy_list_lock); |
2908d778 JB |
72 | |
73 | if (dev->frame_rcvd[0] == 0x34 && port->oob_mode == SATA_OOB_MODE) { | |
74 | struct dev_to_host_fis *fis = | |
75 | (struct dev_to_host_fis *) dev->frame_rcvd; | |
76 | if (fis->interrupt_reason == 1 && fis->lbal == 1 && | |
857a80bb | 77 | fis->byte_count_low == 0x69 && fis->byte_count_high == 0x96 |
2908d778 | 78 | && (fis->device & ~0x10) == 0) |
aa9f8328 | 79 | dev->dev_type = SAS_SATA_PM; |
2908d778 | 80 | else |
aa9f8328 | 81 | dev->dev_type = SAS_SATA_DEV; |
5929faf3 | 82 | dev->tproto = SAS_PROTOCOL_SATA; |
f70267f3 | 83 | } else if (port->oob_mode == SAS_OOB_MODE) { |
2908d778 JB |
84 | struct sas_identify_frame *id = |
85 | (struct sas_identify_frame *) dev->frame_rcvd; | |
86 | dev->dev_type = id->dev_type; | |
87 | dev->iproto = id->initiator_bits; | |
88 | dev->tproto = id->target_bits; | |
f70267f3 JY |
89 | } else { |
90 | /* If the oob mode is OOB_NOT_CONNECTED, the port is | |
91 | * disconnected due to race with PHY down. We cannot | |
92 | * continue to discover this port | |
93 | */ | |
94 | sas_put_device(dev); | |
95 | pr_warn("Port %016llx is disconnected when discovering\n", | |
96 | SAS_ADDR(port->attached_sas_addr)); | |
97 | return -ENODEV; | |
2908d778 JB |
98 | } |
99 | ||
100 | sas_init_dev(dev); | |
101 | ||
b2024459 | 102 | dev->port = port; |
2908d778 | 103 | switch (dev->dev_type) { |
aa9f8328 | 104 | case SAS_SATA_DEV: |
b2024459 DW |
105 | rc = sas_ata_init(dev); |
106 | if (rc) { | |
107 | rphy = NULL; | |
108 | break; | |
109 | } | |
df561f66 | 110 | fallthrough; |
aa9f8328 | 111 | case SAS_END_DEVICE: |
2908d778 JB |
112 | rphy = sas_end_device_alloc(port->port); |
113 | break; | |
aa9f8328 | 114 | case SAS_EDGE_EXPANDER_DEVICE: |
2908d778 JB |
115 | rphy = sas_expander_alloc(port->port, |
116 | SAS_EDGE_EXPANDER_DEVICE); | |
117 | break; | |
aa9f8328 | 118 | case SAS_FANOUT_EXPANDER_DEVICE: |
2908d778 JB |
119 | rphy = sas_expander_alloc(port->port, |
120 | SAS_FANOUT_EXPANDER_DEVICE); | |
121 | break; | |
2908d778 | 122 | default: |
15ba7806 | 123 | pr_warn("ERROR: Unidentified device type %d\n", dev->dev_type); |
2908d778 JB |
124 | rphy = NULL; |
125 | break; | |
126 | } | |
127 | ||
128 | if (!rphy) { | |
735f7d2f | 129 | sas_put_device(dev); |
b2024459 | 130 | return rc; |
2908d778 | 131 | } |
899fcf40 | 132 | |
2908d778 JB |
133 | rphy->identify.phy_identifier = phy->phy->identify.phy_identifier; |
134 | memcpy(dev->sas_addr, port->attached_sas_addr, SAS_ADDR_SIZE); | |
135 | sas_fill_in_rphy(dev, rphy); | |
136 | sas_hash_addr(dev->hashed_sas_addr, dev->sas_addr); | |
137 | port->port_dev = dev; | |
2908d778 JB |
138 | dev->linkrate = port->linkrate; |
139 | dev->min_linkrate = port->linkrate; | |
140 | dev->max_linkrate = port->linkrate; | |
141 | dev->pathways = port->num_phys; | |
142 | memset(port->disc.fanout_sas_addr, 0, SAS_ADDR_SIZE); | |
143 | memset(port->disc.eeds_a, 0, SAS_ADDR_SIZE); | |
144 | memset(port->disc.eeds_b, 0, SAS_ADDR_SIZE); | |
145 | port->disc.max_level = 0; | |
f41a0c44 | 146 | sas_device_set_phy(dev, port->port); |
2908d778 JB |
147 | |
148 | dev->rphy = rphy; | |
9487669f | 149 | get_device(&dev->rphy->dev); |
87c8331f | 150 | |
aa9f8328 | 151 | if (dev_is_sata(dev) || dev->dev_type == SAS_END_DEVICE) |
87c8331f DW |
152 | list_add_tail(&dev->disco_list_node, &port->disco_list); |
153 | else { | |
154 | spin_lock_irq(&port->dev_list_lock); | |
155 | list_add_tail(&dev->dev_list_node, &port->dev_list); | |
156 | spin_unlock_irq(&port->dev_list_lock); | |
157 | } | |
2908d778 | 158 | |
ec236e52 DW |
159 | spin_lock_irq(&port->phy_list_lock); |
160 | list_for_each_entry(phy, &port->phy_list, port_phy_el) | |
161 | sas_phy_set_target(phy, dev); | |
162 | spin_unlock_irq(&port->phy_list_lock); | |
163 | ||
2908d778 JB |
164 | return 0; |
165 | } | |
166 | ||
167 | /* ---------- Discover and Revalidate ---------- */ | |
168 | ||
2908d778 JB |
169 | int sas_notify_lldd_dev_found(struct domain_device *dev) |
170 | { | |
171 | int res = 0; | |
172 | struct sas_ha_struct *sas_ha = dev->port->ha; | |
173 | struct Scsi_Host *shost = sas_ha->core.shost; | |
174 | struct sas_internal *i = to_sas_internal(shost->transportt); | |
175 | ||
303694ee DW |
176 | if (!i->dft->lldd_dev_found) |
177 | return 0; | |
178 | ||
179 | res = i->dft->lldd_dev_found(dev); | |
180 | if (res) { | |
b3e3d4c6 | 181 | pr_warn("driver on host %s cannot handle device %016llx, error:%d\n", |
15ba7806 JG |
182 | dev_name(sas_ha->dev), |
183 | SAS_ADDR(dev->sas_addr), res); | |
244359c9 | 184 | return res; |
2908d778 | 185 | } |
303694ee DW |
186 | set_bit(SAS_DEV_FOUND, &dev->state); |
187 | kref_get(&dev->kref); | |
244359c9 | 188 | return 0; |
2908d778 JB |
189 | } |
190 | ||
191 | ||
192 | void sas_notify_lldd_dev_gone(struct domain_device *dev) | |
193 | { | |
194 | struct sas_ha_struct *sas_ha = dev->port->ha; | |
195 | struct Scsi_Host *shost = sas_ha->core.shost; | |
196 | struct sas_internal *i = to_sas_internal(shost->transportt); | |
197 | ||
303694ee DW |
198 | if (!i->dft->lldd_dev_gone) |
199 | return; | |
200 | ||
201 | if (test_and_clear_bit(SAS_DEV_FOUND, &dev->state)) { | |
2908d778 | 202 | i->dft->lldd_dev_gone(dev); |
735f7d2f DW |
203 | sas_put_device(dev); |
204 | } | |
2908d778 JB |
205 | } |
206 | ||
0558f33c | 207 | static void sas_probe_devices(struct asd_sas_port *port) |
92625f9b DW |
208 | { |
209 | struct domain_device *dev, *n; | |
92625f9b | 210 | |
9508a66f DW |
211 | /* devices must be domain members before link recovery and probe */ |
212 | list_for_each_entry(dev, &port->disco_list, disco_list_node) { | |
92625f9b DW |
213 | spin_lock_irq(&port->dev_list_lock); |
214 | list_add_tail(&dev->dev_list_node, &port->dev_list); | |
215 | spin_unlock_irq(&port->dev_list_lock); | |
9508a66f | 216 | } |
92625f9b | 217 | |
9508a66f | 218 | sas_probe_sata(port); |
92625f9b | 219 | |
9508a66f DW |
220 | list_for_each_entry_safe(dev, n, &port->disco_list, disco_list_node) { |
221 | int err; | |
222 | ||
223 | err = sas_rphy_add(dev->rphy); | |
224 | if (err) | |
225 | sas_fail_probe(dev, __func__, err); | |
226 | else | |
92625f9b DW |
227 | list_del_init(&dev->disco_list_node); |
228 | } | |
229 | } | |
2908d778 | 230 | |
303694ee DW |
231 | static void sas_suspend_devices(struct work_struct *work) |
232 | { | |
233 | struct asd_sas_phy *phy; | |
234 | struct domain_device *dev; | |
235 | struct sas_discovery_event *ev = to_sas_discovery_event(work); | |
236 | struct asd_sas_port *port = ev->port; | |
237 | struct Scsi_Host *shost = port->ha->core.shost; | |
238 | struct sas_internal *si = to_sas_internal(shost->transportt); | |
239 | ||
240 | clear_bit(DISCE_SUSPEND, &port->disc.pending); | |
241 | ||
242 | sas_suspend_sata(port); | |
243 | ||
244 | /* lldd is free to forget the domain_device across the | |
245 | * suspension, we force the issue here to keep the reference | |
246 | * counts aligned | |
247 | */ | |
248 | list_for_each_entry(dev, &port->dev_list, dev_list_node) | |
249 | sas_notify_lldd_dev_gone(dev); | |
250 | ||
251 | /* we are suspending, so we know events are disabled and | |
252 | * phy_list is not being mutated | |
253 | */ | |
254 | list_for_each_entry(phy, &port->phy_list, port_phy_el) { | |
640208a1 | 255 | if (si->dft->lldd_port_deformed) |
303694ee DW |
256 | si->dft->lldd_port_deformed(phy); |
257 | phy->suspended = 1; | |
258 | port->suspended = 1; | |
259 | } | |
260 | } | |
261 | ||
262 | static void sas_resume_devices(struct work_struct *work) | |
263 | { | |
264 | struct sas_discovery_event *ev = to_sas_discovery_event(work); | |
265 | struct asd_sas_port *port = ev->port; | |
266 | ||
267 | clear_bit(DISCE_RESUME, &port->disc.pending); | |
268 | ||
269 | sas_resume_sata(port); | |
270 | } | |
271 | ||
2908d778 | 272 | /** |
121246ae BVA |
273 | * sas_discover_end_dev - discover an end device (SSP, etc) |
274 | * @dev: pointer to domain device of interest | |
2908d778 JB |
275 | * |
276 | * See comment in sas_discover_sata(). | |
277 | */ | |
278 | int sas_discover_end_dev(struct domain_device *dev) | |
279 | { | |
3d1a99e2 | 280 | return sas_notify_lldd_dev_found(dev); |
2908d778 JB |
281 | } |
282 | ||
283 | /* ---------- Device registration and unregistration ---------- */ | |
284 | ||
735f7d2f DW |
285 | void sas_free_device(struct kref *kref) |
286 | { | |
287 | struct domain_device *dev = container_of(kref, typeof(*dev), kref); | |
288 | ||
9487669f DW |
289 | put_device(&dev->rphy->dev); |
290 | dev->rphy = NULL; | |
291 | ||
735f7d2f DW |
292 | if (dev->parent) |
293 | sas_put_device(dev->parent); | |
294 | ||
f41a0c44 DW |
295 | sas_port_put_phy(dev->phy); |
296 | dev->phy = NULL; | |
297 | ||
735f7d2f | 298 | /* remove the phys and ports, everything else should be gone */ |
924a3541 | 299 | if (dev_is_expander(dev->dev_type)) |
735f7d2f DW |
300 | kfree(dev->ex_dev.ex_phy); |
301 | ||
8abda4d2 | 302 | if (dev_is_sata(dev) && dev->sata_dev.ap) { |
b6240a4d | 303 | ata_sas_tport_delete(dev->sata_dev.ap); |
8abda4d2 | 304 | ata_sas_port_destroy(dev->sata_dev.ap); |
2fa4a326 JY |
305 | ata_host_put(dev->sata_dev.ata_host); |
306 | dev->sata_dev.ata_host = NULL; | |
8abda4d2 DW |
307 | dev->sata_dev.ap = NULL; |
308 | } | |
309 | ||
735f7d2f DW |
310 | kfree(dev); |
311 | } | |
312 | ||
1a34c064 | 313 | static void sas_unregister_common_dev(struct asd_sas_port *port, struct domain_device *dev) |
2908d778 | 314 | { |
5db45bdc DW |
315 | struct sas_ha_struct *ha = port->ha; |
316 | ||
2908d778 JB |
317 | sas_notify_lldd_dev_gone(dev); |
318 | if (!dev->parent) | |
319 | dev->port->port_dev = NULL; | |
320 | else | |
321 | list_del_init(&dev->siblings); | |
1a34c064 DW |
322 | |
323 | spin_lock_irq(&port->dev_list_lock); | |
2908d778 | 324 | list_del_init(&dev->dev_list_node); |
e4a9c373 DW |
325 | if (dev_is_sata(dev)) |
326 | sas_ata_end_eh(dev->sata_dev.ap); | |
1a34c064 | 327 | spin_unlock_irq(&port->dev_list_lock); |
735f7d2f | 328 | |
5db45bdc | 329 | spin_lock_irq(&ha->lock); |
aa9f8328 | 330 | if (dev->dev_type == SAS_END_DEVICE && |
5db45bdc DW |
331 | !list_empty(&dev->ssp_dev.eh_list_node)) { |
332 | list_del_init(&dev->ssp_dev.eh_list_node); | |
333 | ha->eh_active--; | |
334 | } | |
335 | spin_unlock_irq(&ha->lock); | |
336 | ||
735f7d2f | 337 | sas_put_device(dev); |
2908d778 JB |
338 | } |
339 | ||
0558f33c | 340 | void sas_destruct_devices(struct asd_sas_port *port) |
2908d778 | 341 | { |
87c8331f | 342 | struct domain_device *dev, *n; |
87c8331f DW |
343 | |
344 | list_for_each_entry_safe(dev, n, &port->destroy_list, disco_list_node) { | |
345 | list_del_init(&dev->disco_list_node); | |
346 | ||
2908d778 JB |
347 | sas_remove_children(&dev->rphy->dev); |
348 | sas_rphy_delete(dev->rphy); | |
87c8331f | 349 | sas_unregister_common_dev(port, dev); |
87c8331f DW |
350 | } |
351 | } | |
352 | ||
0558f33c JY |
353 | static void sas_destruct_ports(struct asd_sas_port *port) |
354 | { | |
355 | struct sas_port *sas_port, *p; | |
356 | ||
357 | list_for_each_entry_safe(sas_port, p, &port->sas_port_del_list, del_list) { | |
358 | list_del_init(&sas_port->del_list); | |
359 | sas_port_delete(sas_port); | |
360 | } | |
361 | } | |
362 | ||
0e4b1791 JY |
363 | static bool sas_abort_cmd(struct request *req, void *data) |
364 | { | |
365 | struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req); | |
366 | struct domain_device *dev = data; | |
367 | ||
368 | if (dev == cmd_to_domain_dev(cmd)) | |
369 | blk_abort_request(req); | |
370 | return true; | |
371 | } | |
372 | ||
373 | static void sas_abort_device_scsi_cmds(struct domain_device *dev) | |
374 | { | |
375 | struct sas_ha_struct *sas_ha = dev->port->ha; | |
376 | struct Scsi_Host *shost = sas_ha->core.shost; | |
377 | ||
378 | if (dev_is_expander(dev->dev_type)) | |
379 | return; | |
380 | ||
381 | /* | |
382 | * For removed device with active IOs, the user space applications have | |
383 | * to spend very long time waiting for the timeout. This is not | |
384 | * necessary because a removed device will not return the IOs. | |
385 | * Abort the inflight IOs here so that EH can be quickly kicked in. | |
386 | */ | |
387 | blk_mq_tagset_busy_iter(&shost->tag_set, sas_abort_cmd, dev); | |
388 | } | |
389 | ||
87c8331f DW |
390 | void sas_unregister_dev(struct asd_sas_port *port, struct domain_device *dev) |
391 | { | |
392 | if (!test_bit(SAS_DEV_DESTROY, &dev->state) && | |
393 | !list_empty(&dev->disco_list_node)) { | |
394 | /* this rphy never saw sas_rphy_add */ | |
395 | list_del_init(&dev->disco_list_node); | |
396 | sas_rphy_free(dev->rphy); | |
87c8331f | 397 | sas_unregister_common_dev(port, dev); |
9487669f | 398 | return; |
87c8331f DW |
399 | } |
400 | ||
9487669f | 401 | if (!test_and_set_bit(SAS_DEV_DESTROY, &dev->state)) { |
0e4b1791 JY |
402 | if (test_bit(SAS_DEV_GONE, &dev->state)) |
403 | sas_abort_device_scsi_cmds(dev); | |
87c8331f DW |
404 | sas_rphy_unlink(dev->rphy); |
405 | list_move_tail(&dev->disco_list_node, &port->destroy_list); | |
2908d778 | 406 | } |
2908d778 JB |
407 | } |
408 | ||
7d05919a | 409 | void sas_unregister_domain_devices(struct asd_sas_port *port, int gone) |
2908d778 JB |
410 | { |
411 | struct domain_device *dev, *n; | |
412 | ||
7d05919a DW |
413 | list_for_each_entry_safe_reverse(dev, n, &port->dev_list, dev_list_node) { |
414 | if (gone) | |
415 | set_bit(SAS_DEV_GONE, &dev->state); | |
1a34c064 | 416 | sas_unregister_dev(port, dev); |
7d05919a DW |
417 | } |
418 | ||
87c8331f DW |
419 | list_for_each_entry_safe(dev, n, &port->disco_list, disco_list_node) |
420 | sas_unregister_dev(port, dev); | |
2908d778 JB |
421 | |
422 | port->port->rphy = NULL; | |
423 | ||
424 | } | |
425 | ||
f41a0c44 DW |
426 | void sas_device_set_phy(struct domain_device *dev, struct sas_port *port) |
427 | { | |
428 | struct sas_ha_struct *ha; | |
429 | struct sas_phy *new_phy; | |
430 | ||
431 | if (!dev) | |
432 | return; | |
433 | ||
434 | ha = dev->port->ha; | |
435 | new_phy = sas_port_get_phy(port); | |
436 | ||
437 | /* pin and record last seen phy */ | |
438 | spin_lock_irq(&ha->phy_port_lock); | |
439 | if (new_phy) { | |
440 | sas_port_put_phy(dev->phy); | |
441 | dev->phy = new_phy; | |
442 | } | |
443 | spin_unlock_irq(&ha->phy_port_lock); | |
444 | } | |
445 | ||
2908d778 JB |
446 | /* ---------- Discovery and Revalidation ---------- */ |
447 | ||
448 | /** | |
121246ae BVA |
449 | * sas_discover_domain - discover the domain |
450 | * @work: work structure embedded in port domain device. | |
2908d778 JB |
451 | * |
452 | * NOTE: this process _must_ quit (return) as soon as any connection | |
453 | * errors are encountered. Connection recovery is done elsewhere. | |
454 | * Discover process only interrogates devices in order to discover the | |
455 | * domain. | |
456 | */ | |
c4028958 | 457 | static void sas_discover_domain(struct work_struct *work) |
2908d778 | 458 | { |
6f63caae | 459 | struct domain_device *dev; |
2908d778 | 460 | int error = 0; |
22b9153f | 461 | struct sas_discovery_event *ev = to_sas_discovery_event(work); |
c4028958 | 462 | struct asd_sas_port *port = ev->port; |
2908d778 | 463 | |
b15ebe0b | 464 | clear_bit(DISCE_DISCOVER_DOMAIN, &port->disc.pending); |
2908d778 JB |
465 | |
466 | if (port->port_dev) | |
6f63caae DW |
467 | return; |
468 | ||
469 | error = sas_get_port_device(port); | |
470 | if (error) | |
471 | return; | |
472 | dev = port->port_dev; | |
2908d778 | 473 | |
15ba7806 JG |
474 | pr_debug("DOING DISCOVERY on port %d, pid:%d\n", port->id, |
475 | task_pid_nr(current)); | |
2908d778 | 476 | |
6f63caae | 477 | switch (dev->dev_type) { |
aa9f8328 | 478 | case SAS_END_DEVICE: |
6f63caae | 479 | error = sas_discover_end_dev(dev); |
2908d778 | 480 | break; |
aa9f8328 JB |
481 | case SAS_EDGE_EXPANDER_DEVICE: |
482 | case SAS_FANOUT_EXPANDER_DEVICE: | |
6f63caae | 483 | error = sas_discover_root_expander(dev); |
2908d778 | 484 | break; |
aa9f8328 JB |
485 | case SAS_SATA_DEV: |
486 | case SAS_SATA_PM: | |
6f63caae | 487 | error = sas_discover_sata(dev); |
2908d778 JB |
488 | break; |
489 | default: | |
b9142174 | 490 | error = -ENXIO; |
15ba7806 | 491 | pr_err("unhandled device %d\n", dev->dev_type); |
2908d778 JB |
492 | break; |
493 | } | |
494 | ||
495 | if (error) { | |
6f63caae | 496 | sas_rphy_free(dev->rphy); |
87c8331f | 497 | list_del_init(&dev->disco_list_node); |
9d720d82 | 498 | spin_lock_irq(&port->dev_list_lock); |
6f63caae | 499 | list_del_init(&dev->dev_list_node); |
9d720d82 | 500 | spin_unlock_irq(&port->dev_list_lock); |
88808398 | 501 | |
735f7d2f | 502 | sas_put_device(dev); |
2908d778 JB |
503 | port->port_dev = NULL; |
504 | } | |
505 | ||
0558f33c JY |
506 | sas_probe_devices(port); |
507 | ||
15ba7806 JG |
508 | pr_debug("DONE DISCOVERY on port %d, pid:%d, result:%d\n", port->id, |
509 | task_pid_nr(current), error); | |
2908d778 JB |
510 | } |
511 | ||
c4028958 | 512 | static void sas_revalidate_domain(struct work_struct *work) |
2908d778 JB |
513 | { |
514 | int res = 0; | |
22b9153f | 515 | struct sas_discovery_event *ev = to_sas_discovery_event(work); |
c4028958 | 516 | struct asd_sas_port *port = ev->port; |
87c8331f | 517 | struct sas_ha_struct *ha = port->ha; |
6302ce4d | 518 | struct domain_device *ddev = port->port_dev; |
87c8331f DW |
519 | |
520 | /* prevent revalidation from finding sata links in recovery */ | |
521 | mutex_lock(&ha->disco_mutex); | |
522 | if (test_bit(SAS_HA_ATA_EH_ACTIVE, &ha->state)) { | |
15ba7806 JG |
523 | pr_debug("REVALIDATION DEFERRED on port %d, pid:%d\n", |
524 | port->id, task_pid_nr(current)); | |
87c8331f DW |
525 | goto out; |
526 | } | |
2908d778 | 527 | |
b15ebe0b | 528 | clear_bit(DISCE_REVALIDATE_DOMAIN, &port->disc.pending); |
2908d778 | 529 | |
15ba7806 JG |
530 | pr_debug("REVALIDATING DOMAIN on port %d, pid:%d\n", port->id, |
531 | task_pid_nr(current)); | |
87c8331f | 532 | |
924a3541 | 533 | if (ddev && dev_is_expander(ddev->dev_type)) |
6302ce4d | 534 | res = sas_ex_revalidate_domain(ddev); |
2908d778 | 535 | |
15ba7806 JG |
536 | pr_debug("done REVALIDATING DOMAIN on port %d, pid:%d, res 0x%x\n", |
537 | port->id, task_pid_nr(current), res); | |
87c8331f DW |
538 | out: |
539 | mutex_unlock(&ha->disco_mutex); | |
0558f33c JY |
540 | |
541 | sas_destruct_devices(port); | |
542 | sas_destruct_ports(port); | |
543 | sas_probe_devices(port); | |
2908d778 JB |
544 | } |
545 | ||
546 | /* ---------- Events ---------- */ | |
547 | ||
22b9153f | 548 | static void sas_chain_work(struct sas_ha_struct *ha, struct sas_work *sw) |
b1124cd3 | 549 | { |
22b9153f DW |
550 | /* chained work is not subject to SA_HA_DRAINING or |
551 | * SAS_HA_REGISTERED, because it is either submitted in the | |
552 | * workqueue, or known to be submitted from a context that is | |
553 | * not racing against draining | |
554 | */ | |
93bdbd06 | 555 | queue_work(ha->disco_q, &sw->work); |
b1124cd3 DW |
556 | } |
557 | ||
558 | static void sas_chain_event(int event, unsigned long *pending, | |
22b9153f | 559 | struct sas_work *sw, |
b1124cd3 DW |
560 | struct sas_ha_struct *ha) |
561 | { | |
562 | if (!test_and_set_bit(event, pending)) { | |
563 | unsigned long flags; | |
564 | ||
e4a9c373 | 565 | spin_lock_irqsave(&ha->lock, flags); |
22b9153f | 566 | sas_chain_work(ha, sw); |
e4a9c373 | 567 | spin_unlock_irqrestore(&ha->lock, flags); |
b1124cd3 DW |
568 | } |
569 | } | |
570 | ||
26d4a969 | 571 | void sas_discover_event(struct asd_sas_port *port, enum discover_event ev) |
2908d778 JB |
572 | { |
573 | struct sas_discovery *disc; | |
574 | ||
575 | if (!port) | |
26d4a969 | 576 | return; |
2908d778 JB |
577 | disc = &port->disc; |
578 | ||
579 | BUG_ON(ev >= DISC_NUM_EVENTS); | |
580 | ||
b1124cd3 | 581 | sas_chain_event(ev, &disc->pending, &disc->disc_work[ev].work, port->ha); |
2908d778 JB |
582 | } |
583 | ||
584 | /** | |
121246ae BVA |
585 | * sas_init_disc - initialize the discovery struct in the port |
586 | * @disc: port discovery structure | |
2908d778 JB |
587 | * @port: pointer to struct port |
588 | * | |
589 | * Called when the ports are being initialized. | |
590 | */ | |
591 | void sas_init_disc(struct sas_discovery *disc, struct asd_sas_port *port) | |
592 | { | |
593 | int i; | |
594 | ||
c4028958 | 595 | static const work_func_t sas_event_fns[DISC_NUM_EVENTS] = { |
2908d778 JB |
596 | [DISCE_DISCOVER_DOMAIN] = sas_discover_domain, |
597 | [DISCE_REVALIDATE_DOMAIN] = sas_revalidate_domain, | |
303694ee DW |
598 | [DISCE_SUSPEND] = sas_suspend_devices, |
599 | [DISCE_RESUME] = sas_resume_devices, | |
2908d778 JB |
600 | }; |
601 | ||
2908d778 | 602 | disc->pending = 0; |
c4028958 | 603 | for (i = 0; i < DISC_NUM_EVENTS; i++) { |
22b9153f | 604 | INIT_SAS_WORK(&disc->disc_work[i].work, sas_event_fns[i]); |
c4028958 DH |
605 | disc->disc_work[i].port = port; |
606 | } | |
2908d778 | 607 | } |