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