1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#include <linux/scatterlist.h>
26#include <linux/blkdev.h>
27#include <linux/slab.h>
28#include <asm/unaligned.h>
29
30#include "sas_internal.h"
31
32#include <scsi/sas_ata.h>
33#include <scsi/scsi_transport.h>
34#include <scsi/scsi_transport_sas.h>
35#include "../scsi_sas_internal.h"
36
37static int sas_discover_expander(struct domain_device *dev);
38static int sas_configure_routing(struct domain_device *dev, u8 *sas_addr);
39static int sas_configure_phy(struct domain_device *dev, int phy_id,
40 u8 *sas_addr, int include);
41static int sas_disable_routing(struct domain_device *dev, u8 *sas_addr);
42
43
44
45static void smp_task_timedout(struct timer_list *t)
46{
47 struct sas_task_slow *slow = from_timer(slow, t, timer);
48 struct sas_task *task = slow->task;
49 unsigned long flags;
50
51 spin_lock_irqsave(&task->task_state_lock, flags);
52 if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
53 task->task_state_flags |= SAS_TASK_STATE_ABORTED;
54 complete(&task->slow_task->completion);
55 }
56 spin_unlock_irqrestore(&task->task_state_lock, flags);
57}
58
59static void smp_task_done(struct sas_task *task)
60{
61 del_timer(&task->slow_task->timer);
62 complete(&task->slow_task->completion);
63}
64
65
66#define SMP_TIMEOUT 10
67
68static int smp_execute_task_sg(struct domain_device *dev,
69 struct scatterlist *req, struct scatterlist *resp)
70{
71 int res, retry;
72 struct sas_task *task = NULL;
73 struct sas_internal *i =
74 to_sas_internal(dev->port->ha->core.shost->transportt);
75
76 mutex_lock(&dev->ex_dev.cmd_mutex);
77 for (retry = 0; retry < 3; retry++) {
78 if (test_bit(SAS_DEV_GONE, &dev->state)) {
79 res = -ECOMM;
80 break;
81 }
82
83 task = sas_alloc_slow_task(GFP_KERNEL);
84 if (!task) {
85 res = -ENOMEM;
86 break;
87 }
88 task->dev = dev;
89 task->task_proto = dev->tproto;
90 task->smp_task.smp_req = *req;
91 task->smp_task.smp_resp = *resp;
92
93 task->task_done = smp_task_done;
94
95 task->slow_task->timer.function = smp_task_timedout;
96 task->slow_task->timer.expires = jiffies + SMP_TIMEOUT*HZ;
97 add_timer(&task->slow_task->timer);
98
99 res = i->dft->lldd_execute_task(task, GFP_KERNEL);
100
101 if (res) {
102 del_timer(&task->slow_task->timer);
103 pr_notice("executing SMP task failed:%d\n", res);
104 break;
105 }
106
107 wait_for_completion(&task->slow_task->completion);
108 res = -ECOMM;
109 if ((task->task_state_flags & SAS_TASK_STATE_ABORTED)) {
110 pr_notice("smp task timed out or aborted\n");
111 i->dft->lldd_abort_task(task);
112 if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
113 pr_notice("SMP task aborted and not done\n");
114 break;
115 }
116 }
117 if (task->task_status.resp == SAS_TASK_COMPLETE &&
118 task->task_status.stat == SAM_STAT_GOOD) {
119 res = 0;
120 break;
121 }
122 if (task->task_status.resp == SAS_TASK_COMPLETE &&
123 task->task_status.stat == SAS_DATA_UNDERRUN) {
124
125
126 res = task->task_status.residual;
127 break;
128 }
129 if (task->task_status.resp == SAS_TASK_COMPLETE &&
130 task->task_status.stat == SAS_DATA_OVERRUN) {
131 res = -EMSGSIZE;
132 break;
133 }
134 if (task->task_status.resp == SAS_TASK_UNDELIVERED &&
135 task->task_status.stat == SAS_DEVICE_UNKNOWN)
136 break;
137 else {
138 pr_notice("%s: task to dev %016llx response: 0x%x status 0x%x\n",
139 __func__,
140 SAS_ADDR(dev->sas_addr),
141 task->task_status.resp,
142 task->task_status.stat);
143 sas_free_task(task);
144 task = NULL;
145 }
146 }
147 mutex_unlock(&dev->ex_dev.cmd_mutex);
148
149 BUG_ON(retry == 3 && task != NULL);
150 sas_free_task(task);
151 return res;
152}
153
154static int smp_execute_task(struct domain_device *dev, void *req, int req_size,
155 void *resp, int resp_size)
156{
157 struct scatterlist req_sg;
158 struct scatterlist resp_sg;
159
160 sg_init_one(&req_sg, req, req_size);
161 sg_init_one(&resp_sg, resp, resp_size);
162 return smp_execute_task_sg(dev, &req_sg, &resp_sg);
163}
164
165
166
167static inline void *alloc_smp_req(int size)
168{
169 u8 *p = kzalloc(size, GFP_KERNEL);
170 if (p)
171 p[0] = SMP_REQUEST;
172 return p;
173}
174
175static inline void *alloc_smp_resp(int size)
176{
177 return kzalloc(size, GFP_KERNEL);
178}
179
180static char sas_route_char(struct domain_device *dev, struct ex_phy *phy)
181{
182 switch (phy->routing_attr) {
183 case TABLE_ROUTING:
184 if (dev->ex_dev.t2t_supp)
185 return 'U';
186 else
187 return 'T';
188 case DIRECT_ROUTING:
189 return 'D';
190 case SUBTRACTIVE_ROUTING:
191 return 'S';
192 default:
193 return '?';
194 }
195}
196
197static enum sas_device_type to_dev_type(struct discover_resp *dr)
198{
199
200
201
202 if (dr->attached_dev_type == SAS_PHY_UNUSED && dr->attached_sata_dev &&
203 dr->linkrate >= SAS_LINK_RATE_1_5_GBPS)
204 return SAS_SATA_PENDING;
205 else
206 return dr->attached_dev_type;
207}
208
209static void sas_set_ex_phy(struct domain_device *dev, int phy_id, void *rsp)
210{
211 enum sas_device_type dev_type;
212 enum sas_linkrate linkrate;
213 u8 sas_addr[SAS_ADDR_SIZE];
214 struct smp_resp *resp = rsp;
215 struct discover_resp *dr = &resp->disc;
216 struct sas_ha_struct *ha = dev->port->ha;
217 struct expander_device *ex = &dev->ex_dev;
218 struct ex_phy *phy = &ex->ex_phy[phy_id];
219 struct sas_rphy *rphy = dev->rphy;
220 bool new_phy = !phy->phy;
221 char *type;
222
223 if (new_phy) {
224 if (WARN_ON_ONCE(test_bit(SAS_HA_ATA_EH_ACTIVE, &ha->state)))
225 return;
226 phy->phy = sas_phy_alloc(&rphy->dev, phy_id);
227
228
229 BUG_ON(!phy->phy);
230 }
231
232 switch (resp->result) {
233 case SMP_RESP_PHY_VACANT:
234 phy->phy_state = PHY_VACANT;
235 break;
236 default:
237 phy->phy_state = PHY_NOT_PRESENT;
238 break;
239 case SMP_RESP_FUNC_ACC:
240 phy->phy_state = PHY_EMPTY;
241 break;
242 }
243
244
245 dev_type = phy->attached_dev_type;
246 linkrate = phy->linkrate;
247 memcpy(sas_addr, phy->attached_sas_addr, SAS_ADDR_SIZE);
248
249
250 if (phy->phy_state == PHY_VACANT) {
251 memset(phy->attached_sas_addr, 0, SAS_ADDR_SIZE);
252 phy->attached_dev_type = SAS_PHY_UNUSED;
253 if (!test_bit(SAS_HA_ATA_EH_ACTIVE, &ha->state)) {
254 phy->phy_id = phy_id;
255 goto skip;
256 } else
257 goto out;
258 }
259
260 phy->attached_dev_type = to_dev_type(dr);
261 if (test_bit(SAS_HA_ATA_EH_ACTIVE, &ha->state))
262 goto out;
263 phy->phy_id = phy_id;
264 phy->linkrate = dr->linkrate;
265 phy->attached_sata_host = dr->attached_sata_host;
266 phy->attached_sata_dev = dr->attached_sata_dev;
267 phy->attached_sata_ps = dr->attached_sata_ps;
268 phy->attached_iproto = dr->iproto << 1;
269 phy->attached_tproto = dr->tproto << 1;
270
271
272
273 if (phy->attached_dev_type == SAS_PHY_UNUSED ||
274 phy->linkrate < SAS_LINK_RATE_1_5_GBPS)
275 memset(phy->attached_sas_addr, 0, SAS_ADDR_SIZE);
276 else
277 memcpy(phy->attached_sas_addr, dr->attached_sas_addr, SAS_ADDR_SIZE);
278 phy->attached_phy_id = dr->attached_phy_id;
279 phy->phy_change_count = dr->change_count;
280 phy->routing_attr = dr->routing_attr;
281 phy->virtual = dr->virtual;
282 phy->last_da_index = -1;
283
284 phy->phy->identify.sas_address = SAS_ADDR(phy->attached_sas_addr);
285 phy->phy->identify.device_type = dr->attached_dev_type;
286 phy->phy->identify.initiator_port_protocols = phy->attached_iproto;
287 phy->phy->identify.target_port_protocols = phy->attached_tproto;
288 if (!phy->attached_tproto && dr->attached_sata_dev)
289 phy->phy->identify.target_port_protocols = SAS_PROTOCOL_SATA;
290 phy->phy->identify.phy_identifier = phy_id;
291 phy->phy->minimum_linkrate_hw = dr->hmin_linkrate;
292 phy->phy->maximum_linkrate_hw = dr->hmax_linkrate;
293 phy->phy->minimum_linkrate = dr->pmin_linkrate;
294 phy->phy->maximum_linkrate = dr->pmax_linkrate;
295 phy->phy->negotiated_linkrate = phy->linkrate;
296 phy->phy->enabled = (phy->linkrate != SAS_PHY_DISABLED);
297
298 skip:
299 if (new_phy)
300 if (sas_phy_add(phy->phy)) {
301 sas_phy_free(phy->phy);
302 return;
303 }
304
305 out:
306 switch (phy->attached_dev_type) {
307 case SAS_SATA_PENDING:
308 type = "stp pending";
309 break;
310 case SAS_PHY_UNUSED:
311 type = "no device";
312 break;
313 case SAS_END_DEVICE:
314 if (phy->attached_iproto) {
315 if (phy->attached_tproto)
316 type = "host+target";
317 else
318 type = "host";
319 } else {
320 if (dr->attached_sata_dev)
321 type = "stp";
322 else
323 type = "ssp";
324 }
325 break;
326 case SAS_EDGE_EXPANDER_DEVICE:
327 case SAS_FANOUT_EXPANDER_DEVICE:
328 type = "smp";
329 break;
330 default:
331 type = "unknown";
332 }
333
334
335
336
337 if (new_phy || phy->attached_dev_type != dev_type ||
338 phy->linkrate != linkrate ||
339 SAS_ADDR(phy->attached_sas_addr) != SAS_ADDR(sas_addr))
340 ;
341 else
342 return;
343
344
345
346
347
348 if (test_bit(SAS_HA_ATA_EH_ACTIVE, &ha->state))
349 set_bit(DISCE_REVALIDATE_DOMAIN, &dev->port->disc.pending);
350
351 pr_debug("%sex %016llx phy%02d:%c:%X attached: %016llx (%s)\n",
352 test_bit(SAS_HA_ATA_EH_ACTIVE, &ha->state) ? "ata: " : "",
353 SAS_ADDR(dev->sas_addr), phy->phy_id,
354 sas_route_char(dev, phy), phy->linkrate,
355 SAS_ADDR(phy->attached_sas_addr), type);
356}
357
358
359struct domain_device *sas_ex_to_ata(struct domain_device *ex_dev, int phy_id)
360{
361 struct ex_phy *ex_phy = &ex_dev->ex_dev.ex_phy[phy_id];
362 struct domain_device *dev;
363 struct sas_rphy *rphy;
364
365 if (!ex_phy->port)
366 return NULL;
367
368 rphy = ex_phy->port->rphy;
369 if (!rphy)
370 return NULL;
371
372 dev = sas_find_dev_by_rphy(rphy);
373
374 if (dev && dev_is_sata(dev))
375 return dev;
376
377 return NULL;
378}
379
380#define DISCOVER_REQ_SIZE 16
381#define DISCOVER_RESP_SIZE 56
382
383static int sas_ex_phy_discover_helper(struct domain_device *dev, u8 *disc_req,
384 u8 *disc_resp, int single)
385{
386 struct discover_resp *dr;
387 int res;
388
389 disc_req[9] = single;
390
391 res = smp_execute_task(dev, disc_req, DISCOVER_REQ_SIZE,
392 disc_resp, DISCOVER_RESP_SIZE);
393 if (res)
394 return res;
395 dr = &((struct smp_resp *)disc_resp)->disc;
396 if (memcmp(dev->sas_addr, dr->attached_sas_addr, SAS_ADDR_SIZE) == 0) {
397 pr_notice("Found loopback topology, just ignore it!\n");
398 return 0;
399 }
400 sas_set_ex_phy(dev, single, disc_resp);
401 return 0;
402}
403
404int sas_ex_phy_discover(struct domain_device *dev, int single)
405{
406 struct expander_device *ex = &dev->ex_dev;
407 int res = 0;
408 u8 *disc_req;
409 u8 *disc_resp;
410
411 disc_req = alloc_smp_req(DISCOVER_REQ_SIZE);
412 if (!disc_req)
413 return -ENOMEM;
414
415 disc_resp = alloc_smp_resp(DISCOVER_RESP_SIZE);
416 if (!disc_resp) {
417 kfree(disc_req);
418 return -ENOMEM;
419 }
420
421 disc_req[1] = SMP_DISCOVER;
422
423 if (0 <= single && single < ex->num_phys) {
424 res = sas_ex_phy_discover_helper(dev, disc_req, disc_resp, single);
425 } else {
426 int i;
427
428 for (i = 0; i < ex->num_phys; i++) {
429 res = sas_ex_phy_discover_helper(dev, disc_req,
430 disc_resp, i);
431 if (res)
432 goto out_err;
433 }
434 }
435out_err:
436 kfree(disc_resp);
437 kfree(disc_req);
438 return res;
439}
440
441static int sas_expander_discover(struct domain_device *dev)
442{
443 struct expander_device *ex = &dev->ex_dev;
444 int res = -ENOMEM;
445
446 ex->ex_phy = kcalloc(ex->num_phys, sizeof(*ex->ex_phy), GFP_KERNEL);
447 if (!ex->ex_phy)
448 return -ENOMEM;
449
450 res = sas_ex_phy_discover(dev, -1);
451 if (res)
452 goto out_err;
453
454 return 0;
455 out_err:
456 kfree(ex->ex_phy);
457 ex->ex_phy = NULL;
458 return res;
459}
460
461#define MAX_EXPANDER_PHYS 128
462
463static void ex_assign_report_general(struct domain_device *dev,
464 struct smp_resp *resp)
465{
466 struct report_general_resp *rg = &resp->rg;
467
468 dev->ex_dev.ex_change_count = be16_to_cpu(rg->change_count);
469 dev->ex_dev.max_route_indexes = be16_to_cpu(rg->route_indexes);
470 dev->ex_dev.num_phys = min(rg->num_phys, (u8)MAX_EXPANDER_PHYS);
471 dev->ex_dev.t2t_supp = rg->t2t_supp;
472 dev->ex_dev.conf_route_table = rg->conf_route_table;
473 dev->ex_dev.configuring = rg->configuring;
474 memcpy(dev->ex_dev.enclosure_logical_id, rg->enclosure_logical_id, 8);
475}
476
477#define RG_REQ_SIZE 8
478#define RG_RESP_SIZE 32
479
480static int sas_ex_general(struct domain_device *dev)
481{
482 u8 *rg_req;
483 struct smp_resp *rg_resp;
484 int res;
485 int i;
486
487 rg_req = alloc_smp_req(RG_REQ_SIZE);
488 if (!rg_req)
489 return -ENOMEM;
490
491 rg_resp = alloc_smp_resp(RG_RESP_SIZE);
492 if (!rg_resp) {
493 kfree(rg_req);
494 return -ENOMEM;
495 }
496
497 rg_req[1] = SMP_REPORT_GENERAL;
498
499 for (i = 0; i < 5; i++) {
500 res = smp_execute_task(dev, rg_req, RG_REQ_SIZE, rg_resp,
501 RG_RESP_SIZE);
502
503 if (res) {
504 pr_notice("RG to ex %016llx failed:0x%x\n",
505 SAS_ADDR(dev->sas_addr), res);
506 goto out;
507 } else if (rg_resp->result != SMP_RESP_FUNC_ACC) {
508 pr_debug("RG:ex %016llx returned SMP result:0x%x\n",
509 SAS_ADDR(dev->sas_addr), rg_resp->result);
510 res = rg_resp->result;
511 goto out;
512 }
513
514 ex_assign_report_general(dev, rg_resp);
515
516 if (dev->ex_dev.configuring) {
517 pr_debug("RG: ex %llx self-configuring...\n",
518 SAS_ADDR(dev->sas_addr));
519 schedule_timeout_interruptible(5*HZ);
520 } else
521 break;
522 }
523out:
524 kfree(rg_req);
525 kfree(rg_resp);
526 return res;
527}
528
529static void ex_assign_manuf_info(struct domain_device *dev, void
530 *_mi_resp)
531{
532 u8 *mi_resp = _mi_resp;
533 struct sas_rphy *rphy = dev->rphy;
534 struct sas_expander_device *edev = rphy_to_expander_device(rphy);
535
536 memcpy(edev->vendor_id, mi_resp + 12, SAS_EXPANDER_VENDOR_ID_LEN);
537 memcpy(edev->product_id, mi_resp + 20, SAS_EXPANDER_PRODUCT_ID_LEN);
538 memcpy(edev->product_rev, mi_resp + 36,
539 SAS_EXPANDER_PRODUCT_REV_LEN);
540
541 if (mi_resp[8] & 1) {
542 memcpy(edev->component_vendor_id, mi_resp + 40,
543 SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN);
544 edev->component_id = mi_resp[48] << 8 | mi_resp[49];
545 edev->component_revision_id = mi_resp[50];
546 }
547}
548
549#define MI_REQ_SIZE 8
550#define MI_RESP_SIZE 64
551
552static int sas_ex_manuf_info(struct domain_device *dev)
553{
554 u8 *mi_req;
555 u8 *mi_resp;
556 int res;
557
558 mi_req = alloc_smp_req(MI_REQ_SIZE);
559 if (!mi_req)
560 return -ENOMEM;
561
562 mi_resp = alloc_smp_resp(MI_RESP_SIZE);
563 if (!mi_resp) {
564 kfree(mi_req);
565 return -ENOMEM;
566 }
567
568 mi_req[1] = SMP_REPORT_MANUF_INFO;
569
570 res = smp_execute_task(dev, mi_req, MI_REQ_SIZE, mi_resp,MI_RESP_SIZE);
571 if (res) {
572 pr_notice("MI: ex %016llx failed:0x%x\n",
573 SAS_ADDR(dev->sas_addr), res);
574 goto out;
575 } else if (mi_resp[2] != SMP_RESP_FUNC_ACC) {
576 pr_debug("MI ex %016llx returned SMP result:0x%x\n",
577 SAS_ADDR(dev->sas_addr), mi_resp[2]);
578 goto out;
579 }
580
581 ex_assign_manuf_info(dev, mi_resp);
582out:
583 kfree(mi_req);
584 kfree(mi_resp);
585 return res;
586}
587
588#define PC_REQ_SIZE 44
589#define PC_RESP_SIZE 8
590
591int sas_smp_phy_control(struct domain_device *dev, int phy_id,
592 enum phy_func phy_func,
593 struct sas_phy_linkrates *rates)
594{
595 u8 *pc_req;
596 u8 *pc_resp;
597 int res;
598
599 pc_req = alloc_smp_req(PC_REQ_SIZE);
600 if (!pc_req)
601 return -ENOMEM;
602
603 pc_resp = alloc_smp_resp(PC_RESP_SIZE);
604 if (!pc_resp) {
605 kfree(pc_req);
606 return -ENOMEM;
607 }
608
609 pc_req[1] = SMP_PHY_CONTROL;
610 pc_req[9] = phy_id;
611 pc_req[10]= phy_func;
612 if (rates) {
613 pc_req[32] = rates->minimum_linkrate << 4;
614 pc_req[33] = rates->maximum_linkrate << 4;
615 }
616
617 res = smp_execute_task(dev, pc_req, PC_REQ_SIZE, pc_resp,PC_RESP_SIZE);
618 if (res) {
619 pr_err("ex %016llx phy%02d PHY control failed: %d\n",
620 SAS_ADDR(dev->sas_addr), phy_id, res);
621 } else if (pc_resp[2] != SMP_RESP_FUNC_ACC) {
622 pr_err("ex %016llx phy%02d PHY control failed: function result 0x%x\n",
623 SAS_ADDR(dev->sas_addr), phy_id, pc_resp[2]);
624 res = pc_resp[2];
625 }
626 kfree(pc_resp);
627 kfree(pc_req);
628 return res;
629}
630
631static void sas_ex_disable_phy(struct domain_device *dev, int phy_id)
632{
633 struct expander_device *ex = &dev->ex_dev;
634 struct ex_phy *phy = &ex->ex_phy[phy_id];
635
636 sas_smp_phy_control(dev, phy_id, PHY_FUNC_DISABLE, NULL);
637 phy->linkrate = SAS_PHY_DISABLED;
638}
639
640static void sas_ex_disable_port(struct domain_device *dev, u8 *sas_addr)
641{
642 struct expander_device *ex = &dev->ex_dev;
643 int i;
644
645 for (i = 0; i < ex->num_phys; i++) {
646 struct ex_phy *phy = &ex->ex_phy[i];
647
648 if (phy->phy_state == PHY_VACANT ||
649 phy->phy_state == PHY_NOT_PRESENT)
650 continue;
651
652 if (SAS_ADDR(phy->attached_sas_addr) == SAS_ADDR(sas_addr))
653 sas_ex_disable_phy(dev, i);
654 }
655}
656
657static int sas_dev_present_in_domain(struct asd_sas_port *port,
658 u8 *sas_addr)
659{
660 struct domain_device *dev;
661
662 if (SAS_ADDR(port->sas_addr) == SAS_ADDR(sas_addr))
663 return 1;
664 list_for_each_entry(dev, &port->dev_list, dev_list_node) {
665 if (SAS_ADDR(dev->sas_addr) == SAS_ADDR(sas_addr))
666 return 1;
667 }
668 return 0;
669}
670
671#define RPEL_REQ_SIZE 16
672#define RPEL_RESP_SIZE 32
673int sas_smp_get_phy_events(struct sas_phy *phy)
674{
675 int res;
676 u8 *req;
677 u8 *resp;
678 struct sas_rphy *rphy = dev_to_rphy(phy->dev.parent);
679 struct domain_device *dev = sas_find_dev_by_rphy(rphy);
680
681 req = alloc_smp_req(RPEL_REQ_SIZE);
682 if (!req)
683 return -ENOMEM;
684
685 resp = alloc_smp_resp(RPEL_RESP_SIZE);
686 if (!resp) {
687 kfree(req);
688 return -ENOMEM;
689 }
690
691 req[1] = SMP_REPORT_PHY_ERR_LOG;
692 req[9] = phy->number;
693
694 res = smp_execute_task(dev, req, RPEL_REQ_SIZE,
695 resp, RPEL_RESP_SIZE);
696
697 if (res)
698 goto out;
699
700 phy->invalid_dword_count = get_unaligned_be32(&resp[12]);
701 phy->running_disparity_error_count = get_unaligned_be32(&resp[16]);
702 phy->loss_of_dword_sync_count = get_unaligned_be32(&resp[20]);
703 phy->phy_reset_problem_count = get_unaligned_be32(&resp[24]);
704
705 out:
706 kfree(req);
707 kfree(resp);
708 return res;
709
710}
711
712#ifdef CONFIG_SCSI_SAS_ATA
713
714#define RPS_REQ_SIZE 16
715#define RPS_RESP_SIZE 60
716
717int sas_get_report_phy_sata(struct domain_device *dev, int phy_id,
718 struct smp_resp *rps_resp)
719{
720 int res;
721 u8 *rps_req = alloc_smp_req(RPS_REQ_SIZE);
722 u8 *resp = (u8 *)rps_resp;
723
724 if (!rps_req)
725 return -ENOMEM;
726
727 rps_req[1] = SMP_REPORT_PHY_SATA;
728 rps_req[9] = phy_id;
729
730 res = smp_execute_task(dev, rps_req, RPS_REQ_SIZE,
731 rps_resp, RPS_RESP_SIZE);
732
733
734
735
736
737
738 if (!res && resp[27] == 0x34 && resp[24] != 0x34) {
739 int i;
740
741 for (i = 0; i < 5; i++) {
742 int j = 24 + (i*4);
743 u8 a, b;
744 a = resp[j + 0];
745 b = resp[j + 1];
746 resp[j + 0] = resp[j + 3];
747 resp[j + 1] = resp[j + 2];
748 resp[j + 2] = b;
749 resp[j + 3] = a;
750 }
751 }
752
753 kfree(rps_req);
754 return res;
755}
756#endif
757
758static void sas_ex_get_linkrate(struct domain_device *parent,
759 struct domain_device *child,
760 struct ex_phy *parent_phy)
761{
762 struct expander_device *parent_ex = &parent->ex_dev;
763 struct sas_port *port;
764 int i;
765
766 child->pathways = 0;
767
768 port = parent_phy->port;
769
770 for (i = 0; i < parent_ex->num_phys; i++) {
771 struct ex_phy *phy = &parent_ex->ex_phy[i];
772
773 if (phy->phy_state == PHY_VACANT ||
774 phy->phy_state == PHY_NOT_PRESENT)
775 continue;
776
777 if (SAS_ADDR(phy->attached_sas_addr) ==
778 SAS_ADDR(child->sas_addr)) {
779
780 child->min_linkrate = min(parent->min_linkrate,
781 phy->linkrate);
782 child->max_linkrate = max(parent->max_linkrate,
783 phy->linkrate);
784 child->pathways++;
785 sas_port_add_phy(port, phy->phy);
786 }
787 }
788 child->linkrate = min(parent_phy->linkrate, child->max_linkrate);
789 child->pathways = min(child->pathways, parent->pathways);
790}
791
792static struct domain_device *sas_ex_discover_end_dev(
793 struct domain_device *parent, int phy_id)
794{
795 struct expander_device *parent_ex = &parent->ex_dev;
796 struct ex_phy *phy = &parent_ex->ex_phy[phy_id];
797 struct domain_device *child = NULL;
798 struct sas_rphy *rphy;
799 int res;
800
801 if (phy->attached_sata_host || phy->attached_sata_ps)
802 return NULL;
803
804 child = sas_alloc_device();
805 if (!child)
806 return NULL;
807
808 kref_get(&parent->kref);
809 child->parent = parent;
810 child->port = parent->port;
811 child->iproto = phy->attached_iproto;
812 memcpy(child->sas_addr, phy->attached_sas_addr, SAS_ADDR_SIZE);
813 sas_hash_addr(child->hashed_sas_addr, child->sas_addr);
814 if (!phy->port) {
815 phy->port = sas_port_alloc(&parent->rphy->dev, phy_id);
816 if (unlikely(!phy->port))
817 goto out_err;
818 if (unlikely(sas_port_add(phy->port) != 0)) {
819 sas_port_free(phy->port);
820 goto out_err;
821 }
822 }
823 sas_ex_get_linkrate(parent, child, phy);
824 sas_device_set_phy(child, phy->port);
825
826#ifdef CONFIG_SCSI_SAS_ATA
827 if ((phy->attached_tproto & SAS_PROTOCOL_STP) || phy->attached_sata_dev) {
828 if (child->linkrate > parent->min_linkrate) {
829 struct sas_phy *cphy = child->phy;
830 enum sas_linkrate min_prate = cphy->minimum_linkrate,
831 parent_min_lrate = parent->min_linkrate,
832 min_linkrate = (min_prate > parent_min_lrate) ?
833 parent_min_lrate : 0;
834 struct sas_phy_linkrates rates = {
835 .maximum_linkrate = parent->min_linkrate,
836 .minimum_linkrate = min_linkrate,
837 };
838 int ret;
839
840 pr_notice("ex %016llx phy%02d SATA device linkrate > min pathway connection rate, attempting to lower device linkrate\n",
841 SAS_ADDR(child->sas_addr), phy_id);
842 ret = sas_smp_phy_control(parent, phy_id,
843 PHY_FUNC_LINK_RESET, &rates);
844 if (ret) {
845 pr_err("ex %016llx phy%02d SATA device could not set linkrate (%d)\n",
846 SAS_ADDR(child->sas_addr), phy_id, ret);
847 goto out_free;
848 }
849 pr_notice("ex %016llx phy%02d SATA device set linkrate successfully\n",
850 SAS_ADDR(child->sas_addr), phy_id);
851 child->linkrate = child->min_linkrate;
852 }
853 res = sas_get_ata_info(child, phy);
854 if (res)
855 goto out_free;
856
857 sas_init_dev(child);
858 res = sas_ata_init(child);
859 if (res)
860 goto out_free;
861 rphy = sas_end_device_alloc(phy->port);
862 if (!rphy)
863 goto out_free;
864 rphy->identify.phy_identifier = phy_id;
865
866 child->rphy = rphy;
867 get_device(&rphy->dev);
868
869 list_add_tail(&child->disco_list_node, &parent->port->disco_list);
870
871 res = sas_discover_sata(child);
872 if (res) {
873 pr_notice("sas_discover_sata() for device %16llx at %016llx:%02d returned 0x%x\n",
874 SAS_ADDR(child->sas_addr),
875 SAS_ADDR(parent->sas_addr), phy_id, res);
876 goto out_list_del;
877 }
878 } else
879#endif
880 if (phy->attached_tproto & SAS_PROTOCOL_SSP) {
881 child->dev_type = SAS_END_DEVICE;
882 rphy = sas_end_device_alloc(phy->port);
883
884 if (unlikely(!rphy))
885 goto out_free;
886 child->tproto = phy->attached_tproto;
887 sas_init_dev(child);
888
889 child->rphy = rphy;
890 get_device(&rphy->dev);
891 rphy->identify.phy_identifier = phy_id;
892 sas_fill_in_rphy(child, rphy);
893
894 list_add_tail(&child->disco_list_node, &parent->port->disco_list);
895
896 res = sas_discover_end_dev(child);
897 if (res) {
898 pr_notice("sas_discover_end_dev() for device %16llx at %016llx:%02d returned 0x%x\n",
899 SAS_ADDR(child->sas_addr),
900 SAS_ADDR(parent->sas_addr), phy_id, res);
901 goto out_list_del;
902 }
903 } else {
904 pr_notice("target proto 0x%x at %016llx:0x%x not handled\n",
905 phy->attached_tproto, SAS_ADDR(parent->sas_addr),
906 phy_id);
907 goto out_free;
908 }
909
910 list_add_tail(&child->siblings, &parent_ex->children);
911 return child;
912
913 out_list_del:
914 sas_rphy_free(child->rphy);
915 list_del(&child->disco_list_node);
916 spin_lock_irq(&parent->port->dev_list_lock);
917 list_del(&child->dev_list_node);
918 spin_unlock_irq(&parent->port->dev_list_lock);
919 out_free:
920 sas_port_delete(phy->port);
921 out_err:
922 phy->port = NULL;
923 sas_put_device(child);
924 return NULL;
925}
926
927
928static bool sas_ex_join_wide_port(struct domain_device *parent, int phy_id)
929{
930 struct ex_phy *phy = &parent->ex_dev.ex_phy[phy_id];
931 int i;
932
933 for (i = 0; i < parent->ex_dev.num_phys; i++) {
934 struct ex_phy *ephy = &parent->ex_dev.ex_phy[i];
935
936 if (ephy == phy)
937 continue;
938
939 if (!memcmp(phy->attached_sas_addr, ephy->attached_sas_addr,
940 SAS_ADDR_SIZE) && ephy->port) {
941 sas_port_add_phy(ephy->port, phy->phy);
942 phy->port = ephy->port;
943 phy->phy_state = PHY_DEVICE_DISCOVERED;
944 return true;
945 }
946 }
947
948 return false;
949}
950
951static struct domain_device *sas_ex_discover_expander(
952 struct domain_device *parent, int phy_id)
953{
954 struct sas_expander_device *parent_ex = rphy_to_expander_device(parent->rphy);
955 struct ex_phy *phy = &parent->ex_dev.ex_phy[phy_id];
956 struct domain_device *child = NULL;
957 struct sas_rphy *rphy;
958 struct sas_expander_device *edev;
959 struct asd_sas_port *port;
960 int res;
961
962 if (phy->routing_attr == DIRECT_ROUTING) {
963 pr_warn("ex %016llx:%02d:D <--> ex %016llx:0x%x is not allowed\n",
964 SAS_ADDR(parent->sas_addr), phy_id,
965 SAS_ADDR(phy->attached_sas_addr),
966 phy->attached_phy_id);
967 return NULL;
968 }
969 child = sas_alloc_device();
970 if (!child)
971 return NULL;
972
973 phy->port = sas_port_alloc(&parent->rphy->dev, phy_id);
974
975 BUG_ON(sas_port_add(phy->port) != 0);
976
977
978 switch (phy->attached_dev_type) {
979 case SAS_EDGE_EXPANDER_DEVICE:
980 rphy = sas_expander_alloc(phy->port,
981 SAS_EDGE_EXPANDER_DEVICE);
982 break;
983 case SAS_FANOUT_EXPANDER_DEVICE:
984 rphy = sas_expander_alloc(phy->port,
985 SAS_FANOUT_EXPANDER_DEVICE);
986 break;
987 default:
988 rphy = NULL;
989 BUG();
990 }
991 port = parent->port;
992 child->rphy = rphy;
993 get_device(&rphy->dev);
994 edev = rphy_to_expander_device(rphy);
995 child->dev_type = phy->attached_dev_type;
996 kref_get(&parent->kref);
997 child->parent = parent;
998 child->port = port;
999 child->iproto = phy->attached_iproto;
1000 child->tproto = phy->attached_tproto;
1001 memcpy(child->sas_addr, phy->attached_sas_addr, SAS_ADDR_SIZE);
1002 sas_hash_addr(child->hashed_sas_addr, child->sas_addr);
1003 sas_ex_get_linkrate(parent, child, phy);
1004 edev->level = parent_ex->level + 1;
1005 parent->port->disc.max_level = max(parent->port->disc.max_level,
1006 edev->level);
1007 sas_init_dev(child);
1008 sas_fill_in_rphy(child, rphy);
1009 sas_rphy_add(rphy);
1010
1011 spin_lock_irq(&parent->port->dev_list_lock);
1012 list_add_tail(&child->dev_list_node, &parent->port->dev_list);
1013 spin_unlock_irq(&parent->port->dev_list_lock);
1014
1015 res = sas_discover_expander(child);
1016 if (res) {
1017 sas_rphy_delete(rphy);
1018 spin_lock_irq(&parent->port->dev_list_lock);
1019 list_del(&child->dev_list_node);
1020 spin_unlock_irq(&parent->port->dev_list_lock);
1021 sas_put_device(child);
1022 sas_port_delete(phy->port);
1023 phy->port = NULL;
1024 return NULL;
1025 }
1026 list_add_tail(&child->siblings, &parent->ex_dev.children);
1027 return child;
1028}
1029
1030static int sas_ex_discover_dev(struct domain_device *dev, int phy_id)
1031{
1032 struct expander_device *ex = &dev->ex_dev;
1033 struct ex_phy *ex_phy = &ex->ex_phy[phy_id];
1034 struct domain_device *child = NULL;
1035 int res = 0;
1036
1037
1038 if (ex_phy->linkrate == SAS_SATA_SPINUP_HOLD) {
1039 if (!sas_smp_phy_control(dev, phy_id, PHY_FUNC_LINK_RESET, NULL))
1040 res = sas_ex_phy_discover(dev, phy_id);
1041 if (res)
1042 return res;
1043 }
1044
1045
1046 if (!dev->parent && (SAS_ADDR(ex_phy->attached_sas_addr) ==
1047 SAS_ADDR(dev->port->sas_addr))) {
1048 sas_add_parent_port(dev, phy_id);
1049 return 0;
1050 }
1051 if (dev->parent && (SAS_ADDR(ex_phy->attached_sas_addr) ==
1052 SAS_ADDR(dev->parent->sas_addr))) {
1053 sas_add_parent_port(dev, phy_id);
1054 if (ex_phy->routing_attr == TABLE_ROUTING)
1055 sas_configure_phy(dev, phy_id, dev->port->sas_addr, 1);
1056 return 0;
1057 }
1058
1059 if (sas_dev_present_in_domain(dev->port, ex_phy->attached_sas_addr))
1060 sas_ex_disable_port(dev, ex_phy->attached_sas_addr);
1061
1062 if (ex_phy->attached_dev_type == SAS_PHY_UNUSED) {
1063 if (ex_phy->routing_attr == DIRECT_ROUTING) {
1064 memset(ex_phy->attached_sas_addr, 0, SAS_ADDR_SIZE);
1065 sas_configure_routing(dev, ex_phy->attached_sas_addr);
1066 }
1067 return 0;
1068 } else if (ex_phy->linkrate == SAS_LINK_RATE_UNKNOWN)
1069 return 0;
1070
1071 if (ex_phy->attached_dev_type != SAS_END_DEVICE &&
1072 ex_phy->attached_dev_type != SAS_FANOUT_EXPANDER_DEVICE &&
1073 ex_phy->attached_dev_type != SAS_EDGE_EXPANDER_DEVICE &&
1074 ex_phy->attached_dev_type != SAS_SATA_PENDING) {
1075 pr_warn("unknown device type(0x%x) attached to ex %016llx phy%02d\n",
1076 ex_phy->attached_dev_type,
1077 SAS_ADDR(dev->sas_addr),
1078 phy_id);
1079 return 0;
1080 }
1081
1082 res = sas_configure_routing(dev, ex_phy->attached_sas_addr);
1083 if (res) {
1084 pr_notice("configure routing for dev %016llx reported 0x%x. Forgotten\n",
1085 SAS_ADDR(ex_phy->attached_sas_addr), res);
1086 sas_disable_routing(dev, ex_phy->attached_sas_addr);
1087 return res;
1088 }
1089
1090 if (sas_ex_join_wide_port(dev, phy_id)) {
1091 pr_debug("Attaching ex phy%02d to wide port %016llx\n",
1092 phy_id, SAS_ADDR(ex_phy->attached_sas_addr));
1093 return res;
1094 }
1095
1096 switch (ex_phy->attached_dev_type) {
1097 case SAS_END_DEVICE:
1098 case SAS_SATA_PENDING:
1099 child = sas_ex_discover_end_dev(dev, phy_id);
1100 break;
1101 case SAS_FANOUT_EXPANDER_DEVICE:
1102 if (SAS_ADDR(dev->port->disc.fanout_sas_addr)) {
1103 pr_debug("second fanout expander %016llx phy%02d attached to ex %016llx phy%02d\n",
1104 SAS_ADDR(ex_phy->attached_sas_addr),
1105 ex_phy->attached_phy_id,
1106 SAS_ADDR(dev->sas_addr),
1107 phy_id);
1108 sas_ex_disable_phy(dev, phy_id);
1109 break;
1110 } else
1111 memcpy(dev->port->disc.fanout_sas_addr,
1112 ex_phy->attached_sas_addr, SAS_ADDR_SIZE);
1113
1114 case SAS_EDGE_EXPANDER_DEVICE:
1115 child = sas_ex_discover_expander(dev, phy_id);
1116 break;
1117 default:
1118 break;
1119 }
1120
1121 if (child) {
1122 int i;
1123
1124 for (i = 0; i < ex->num_phys; i++) {
1125 if (ex->ex_phy[i].phy_state == PHY_VACANT ||
1126 ex->ex_phy[i].phy_state == PHY_NOT_PRESENT)
1127 continue;
1128
1129
1130
1131
1132 if (SAS_ADDR(ex->ex_phy[i].attached_sas_addr) ==
1133 SAS_ADDR(child->sas_addr)) {
1134 ex->ex_phy[i].phy_state= PHY_DEVICE_DISCOVERED;
1135 if (sas_ex_join_wide_port(dev, i))
1136 pr_debug("Attaching ex phy%02d to wide port %016llx\n",
1137 i, SAS_ADDR(ex->ex_phy[i].attached_sas_addr));
1138 }
1139 }
1140 }
1141
1142 return res;
1143}
1144
1145static int sas_find_sub_addr(struct domain_device *dev, u8 *sub_addr)
1146{
1147 struct expander_device *ex = &dev->ex_dev;
1148 int i;
1149
1150 for (i = 0; i < ex->num_phys; i++) {
1151 struct ex_phy *phy = &ex->ex_phy[i];
1152
1153 if (phy->phy_state == PHY_VACANT ||
1154 phy->phy_state == PHY_NOT_PRESENT)
1155 continue;
1156
1157 if ((phy->attached_dev_type == SAS_EDGE_EXPANDER_DEVICE ||
1158 phy->attached_dev_type == SAS_FANOUT_EXPANDER_DEVICE) &&
1159 phy->routing_attr == SUBTRACTIVE_ROUTING) {
1160
1161 memcpy(sub_addr, phy->attached_sas_addr, SAS_ADDR_SIZE);
1162
1163 return 1;
1164 }
1165 }
1166 return 0;
1167}
1168
1169static int sas_check_level_subtractive_boundary(struct domain_device *dev)
1170{
1171 struct expander_device *ex = &dev->ex_dev;
1172 struct domain_device *child;
1173 u8 sub_addr[SAS_ADDR_SIZE] = {0, };
1174
1175 list_for_each_entry(child, &ex->children, siblings) {
1176 if (child->dev_type != SAS_EDGE_EXPANDER_DEVICE &&
1177 child->dev_type != SAS_FANOUT_EXPANDER_DEVICE)
1178 continue;
1179 if (sub_addr[0] == 0) {
1180 sas_find_sub_addr(child, sub_addr);
1181 continue;
1182 } else {
1183 u8 s2[SAS_ADDR_SIZE];
1184
1185 if (sas_find_sub_addr(child, s2) &&
1186 (SAS_ADDR(sub_addr) != SAS_ADDR(s2))) {
1187
1188 pr_notice("ex %016llx->%016llx-?->%016llx diverges from subtractive boundary %016llx\n",
1189 SAS_ADDR(dev->sas_addr),
1190 SAS_ADDR(child->sas_addr),
1191 SAS_ADDR(s2),
1192 SAS_ADDR(sub_addr));
1193
1194 sas_ex_disable_port(child, s2);
1195 }
1196 }
1197 }
1198 return 0;
1199}
1200
1201
1202
1203
1204
1205
1206
1207
1208static int sas_ex_discover_devices(struct domain_device *dev, int single)
1209{
1210 struct expander_device *ex = &dev->ex_dev;
1211 int i = 0, end = ex->num_phys;
1212 int res = 0;
1213
1214 if (0 <= single && single < end) {
1215 i = single;
1216 end = i+1;
1217 }
1218
1219 for ( ; i < end; i++) {
1220 struct ex_phy *ex_phy = &ex->ex_phy[i];
1221
1222 if (ex_phy->phy_state == PHY_VACANT ||
1223 ex_phy->phy_state == PHY_NOT_PRESENT ||
1224 ex_phy->phy_state == PHY_DEVICE_DISCOVERED)
1225 continue;
1226
1227 switch (ex_phy->linkrate) {
1228 case SAS_PHY_DISABLED:
1229 case SAS_PHY_RESET_PROBLEM:
1230 case SAS_SATA_PORT_SELECTOR:
1231 continue;
1232 default:
1233 res = sas_ex_discover_dev(dev, i);
1234 if (res)
1235 break;
1236 continue;
1237 }
1238 }
1239
1240 if (!res)
1241 sas_check_level_subtractive_boundary(dev);
1242
1243 return res;
1244}
1245
1246static int sas_check_ex_subtractive_boundary(struct domain_device *dev)
1247{
1248 struct expander_device *ex = &dev->ex_dev;
1249 int i;
1250 u8 *sub_sas_addr = NULL;
1251
1252 if (dev->dev_type != SAS_EDGE_EXPANDER_DEVICE)
1253 return 0;
1254
1255 for (i = 0; i < ex->num_phys; i++) {
1256 struct ex_phy *phy = &ex->ex_phy[i];
1257
1258 if (phy->phy_state == PHY_VACANT ||
1259 phy->phy_state == PHY_NOT_PRESENT)
1260 continue;
1261
1262 if ((phy->attached_dev_type == SAS_FANOUT_EXPANDER_DEVICE ||
1263 phy->attached_dev_type == SAS_EDGE_EXPANDER_DEVICE) &&
1264 phy->routing_attr == SUBTRACTIVE_ROUTING) {
1265
1266 if (!sub_sas_addr)
1267 sub_sas_addr = &phy->attached_sas_addr[0];
1268 else if (SAS_ADDR(sub_sas_addr) !=
1269 SAS_ADDR(phy->attached_sas_addr)) {
1270
1271 pr_notice("ex %016llx phy%02d diverges(%016llx) on subtractive boundary(%016llx). Disabled\n",
1272 SAS_ADDR(dev->sas_addr), i,
1273 SAS_ADDR(phy->attached_sas_addr),
1274 SAS_ADDR(sub_sas_addr));
1275 sas_ex_disable_phy(dev, i);
1276 }
1277 }
1278 }
1279 return 0;
1280}
1281
1282static void sas_print_parent_topology_bug(struct domain_device *child,
1283 struct ex_phy *parent_phy,
1284 struct ex_phy *child_phy)
1285{
1286 static const char *ex_type[] = {
1287 [SAS_EDGE_EXPANDER_DEVICE] = "edge",
1288 [SAS_FANOUT_EXPANDER_DEVICE] = "fanout",
1289 };
1290 struct domain_device *parent = child->parent;
1291
1292 pr_notice("%s ex %016llx phy%02d <--> %s ex %016llx phy%02d has %c:%c routing link!\n",
1293 ex_type[parent->dev_type],
1294 SAS_ADDR(parent->sas_addr),
1295 parent_phy->phy_id,
1296
1297 ex_type[child->dev_type],
1298 SAS_ADDR(child->sas_addr),
1299 child_phy->phy_id,
1300
1301 sas_route_char(parent, parent_phy),
1302 sas_route_char(child, child_phy));
1303}
1304
1305static int sas_check_eeds(struct domain_device *child,
1306 struct ex_phy *parent_phy,
1307 struct ex_phy *child_phy)
1308{
1309 int res = 0;
1310 struct domain_device *parent = child->parent;
1311
1312 if (SAS_ADDR(parent->port->disc.fanout_sas_addr) != 0) {
1313 res = -ENODEV;
1314 pr_warn("edge ex %016llx phy S:%02d <--> edge ex %016llx phy S:%02d, while there is a fanout ex %016llx\n",
1315 SAS_ADDR(parent->sas_addr),
1316 parent_phy->phy_id,
1317 SAS_ADDR(child->sas_addr),
1318 child_phy->phy_id,
1319 SAS_ADDR(parent->port->disc.fanout_sas_addr));
1320 } else if (SAS_ADDR(parent->port->disc.eeds_a) == 0) {
1321 memcpy(parent->port->disc.eeds_a, parent->sas_addr,
1322 SAS_ADDR_SIZE);
1323 memcpy(parent->port->disc.eeds_b, child->sas_addr,
1324 SAS_ADDR_SIZE);
1325 } else if (((SAS_ADDR(parent->port->disc.eeds_a) ==
1326 SAS_ADDR(parent->sas_addr)) ||
1327 (SAS_ADDR(parent->port->disc.eeds_a) ==
1328 SAS_ADDR(child->sas_addr)))
1329 &&
1330 ((SAS_ADDR(parent->port->disc.eeds_b) ==
1331 SAS_ADDR(parent->sas_addr)) ||
1332 (SAS_ADDR(parent->port->disc.eeds_b) ==
1333 SAS_ADDR(child->sas_addr))))
1334 ;
1335 else {
1336 res = -ENODEV;
1337 pr_warn("edge ex %016llx phy%02d <--> edge ex %016llx phy%02d link forms a third EEDS!\n",
1338 SAS_ADDR(parent->sas_addr),
1339 parent_phy->phy_id,
1340 SAS_ADDR(child->sas_addr),
1341 child_phy->phy_id);
1342 }
1343
1344 return res;
1345}
1346
1347
1348
1349static int sas_check_parent_topology(struct domain_device *child)
1350{
1351 struct expander_device *child_ex = &child->ex_dev;
1352 struct expander_device *parent_ex;
1353 int i;
1354 int res = 0;
1355
1356 if (!child->parent)
1357 return 0;
1358
1359 if (child->parent->dev_type != SAS_EDGE_EXPANDER_DEVICE &&
1360 child->parent->dev_type != SAS_FANOUT_EXPANDER_DEVICE)
1361 return 0;
1362
1363 parent_ex = &child->parent->ex_dev;
1364
1365 for (i = 0; i < parent_ex->num_phys; i++) {
1366 struct ex_phy *parent_phy = &parent_ex->ex_phy[i];
1367 struct ex_phy *child_phy;
1368
1369 if (parent_phy->phy_state == PHY_VACANT ||
1370 parent_phy->phy_state == PHY_NOT_PRESENT)
1371 continue;
1372
1373 if (SAS_ADDR(parent_phy->attached_sas_addr) != SAS_ADDR(child->sas_addr))
1374 continue;
1375
1376 child_phy = &child_ex->ex_phy[parent_phy->attached_phy_id];
1377
1378 switch (child->parent->dev_type) {
1379 case SAS_EDGE_EXPANDER_DEVICE:
1380 if (child->dev_type == SAS_FANOUT_EXPANDER_DEVICE) {
1381 if (parent_phy->routing_attr != SUBTRACTIVE_ROUTING ||
1382 child_phy->routing_attr != TABLE_ROUTING) {
1383 sas_print_parent_topology_bug(child, parent_phy, child_phy);
1384 res = -ENODEV;
1385 }
1386 } else if (parent_phy->routing_attr == SUBTRACTIVE_ROUTING) {
1387 if (child_phy->routing_attr == SUBTRACTIVE_ROUTING) {
1388 res = sas_check_eeds(child, parent_phy, child_phy);
1389 } else if (child_phy->routing_attr != TABLE_ROUTING) {
1390 sas_print_parent_topology_bug(child, parent_phy, child_phy);
1391 res = -ENODEV;
1392 }
1393 } else if (parent_phy->routing_attr == TABLE_ROUTING) {
1394 if (child_phy->routing_attr == SUBTRACTIVE_ROUTING ||
1395 (child_phy->routing_attr == TABLE_ROUTING &&
1396 child_ex->t2t_supp && parent_ex->t2t_supp)) {
1397 ;
1398 } else {
1399 sas_print_parent_topology_bug(child, parent_phy, child_phy);
1400 res = -ENODEV;
1401 }
1402 }
1403 break;
1404 case SAS_FANOUT_EXPANDER_DEVICE:
1405 if (parent_phy->routing_attr != TABLE_ROUTING ||
1406 child_phy->routing_attr != SUBTRACTIVE_ROUTING) {
1407 sas_print_parent_topology_bug(child, parent_phy, child_phy);
1408 res = -ENODEV;
1409 }
1410 break;
1411 default:
1412 break;
1413 }
1414 }
1415
1416 return res;
1417}
1418
1419#define RRI_REQ_SIZE 16
1420#define RRI_RESP_SIZE 44
1421
1422static int sas_configure_present(struct domain_device *dev, int phy_id,
1423 u8 *sas_addr, int *index, int *present)
1424{
1425 int i, res = 0;
1426 struct expander_device *ex = &dev->ex_dev;
1427 struct ex_phy *phy = &ex->ex_phy[phy_id];
1428 u8 *rri_req;
1429 u8 *rri_resp;
1430
1431 *present = 0;
1432 *index = 0;
1433
1434 rri_req = alloc_smp_req(RRI_REQ_SIZE);
1435 if (!rri_req)
1436 return -ENOMEM;
1437
1438 rri_resp = alloc_smp_resp(RRI_RESP_SIZE);
1439 if (!rri_resp) {
1440 kfree(rri_req);
1441 return -ENOMEM;
1442 }
1443
1444 rri_req[1] = SMP_REPORT_ROUTE_INFO;
1445 rri_req[9] = phy_id;
1446
1447 for (i = 0; i < ex->max_route_indexes ; i++) {
1448 *(__be16 *)(rri_req+6) = cpu_to_be16(i);
1449 res = smp_execute_task(dev, rri_req, RRI_REQ_SIZE, rri_resp,
1450 RRI_RESP_SIZE);
1451 if (res)
1452 goto out;
1453 res = rri_resp[2];
1454 if (res == SMP_RESP_NO_INDEX) {
1455 pr_warn("overflow of indexes: dev %016llx phy%02d index 0x%x\n",
1456 SAS_ADDR(dev->sas_addr), phy_id, i);
1457 goto out;
1458 } else if (res != SMP_RESP_FUNC_ACC) {
1459 pr_notice("%s: dev %016llx phy%02d index 0x%x result 0x%x\n",
1460 __func__, SAS_ADDR(dev->sas_addr), phy_id,
1461 i, res);
1462 goto out;
1463 }
1464 if (SAS_ADDR(sas_addr) != 0) {
1465 if (SAS_ADDR(rri_resp+16) == SAS_ADDR(sas_addr)) {
1466 *index = i;
1467 if ((rri_resp[12] & 0x80) == 0x80)
1468 *present = 0;
1469 else
1470 *present = 1;
1471 goto out;
1472 } else if (SAS_ADDR(rri_resp+16) == 0) {
1473 *index = i;
1474 *present = 0;
1475 goto out;
1476 }
1477 } else if (SAS_ADDR(rri_resp+16) == 0 &&
1478 phy->last_da_index < i) {
1479 phy->last_da_index = i;
1480 *index = i;
1481 *present = 0;
1482 goto out;
1483 }
1484 }
1485 res = -1;
1486out:
1487 kfree(rri_req);
1488 kfree(rri_resp);
1489 return res;
1490}
1491
1492#define CRI_REQ_SIZE 44
1493#define CRI_RESP_SIZE 8
1494
1495static int sas_configure_set(struct domain_device *dev, int phy_id,
1496 u8 *sas_addr, int index, int include)
1497{
1498 int res;
1499 u8 *cri_req;
1500 u8 *cri_resp;
1501
1502 cri_req = alloc_smp_req(CRI_REQ_SIZE);
1503 if (!cri_req)
1504 return -ENOMEM;
1505
1506 cri_resp = alloc_smp_resp(CRI_RESP_SIZE);
1507 if (!cri_resp) {
1508 kfree(cri_req);
1509 return -ENOMEM;
1510 }
1511
1512 cri_req[1] = SMP_CONF_ROUTE_INFO;
1513 *(__be16 *)(cri_req+6) = cpu_to_be16(index);
1514 cri_req[9] = phy_id;
1515 if (SAS_ADDR(sas_addr) == 0 || !include)
1516 cri_req[12] |= 0x80;
1517 memcpy(cri_req+16, sas_addr, SAS_ADDR_SIZE);
1518
1519 res = smp_execute_task(dev, cri_req, CRI_REQ_SIZE, cri_resp,
1520 CRI_RESP_SIZE);
1521 if (res)
1522 goto out;
1523 res = cri_resp[2];
1524 if (res == SMP_RESP_NO_INDEX) {
1525 pr_warn("overflow of indexes: dev %016llx phy%02d index 0x%x\n",
1526 SAS_ADDR(dev->sas_addr), phy_id, index);
1527 }
1528out:
1529 kfree(cri_req);
1530 kfree(cri_resp);
1531 return res;
1532}
1533
1534static int sas_configure_phy(struct domain_device *dev, int phy_id,
1535 u8 *sas_addr, int include)
1536{
1537 int index;
1538 int present;
1539 int res;
1540
1541 res = sas_configure_present(dev, phy_id, sas_addr, &index, &present);
1542 if (res)
1543 return res;
1544 if (include ^ present)
1545 return sas_configure_set(dev, phy_id, sas_addr, index,include);
1546
1547 return res;
1548}
1549
1550
1551
1552
1553
1554
1555
1556
1557static int sas_configure_parent(struct domain_device *parent,
1558 struct domain_device *child,
1559 u8 *sas_addr, int include)
1560{
1561 struct expander_device *ex_parent = &parent->ex_dev;
1562 int res = 0;
1563 int i;
1564
1565 if (parent->parent) {
1566 res = sas_configure_parent(parent->parent, parent, sas_addr,
1567 include);
1568 if (res)
1569 return res;
1570 }
1571
1572 if (ex_parent->conf_route_table == 0) {
1573 pr_debug("ex %016llx has self-configuring routing table\n",
1574 SAS_ADDR(parent->sas_addr));
1575 return 0;
1576 }
1577
1578 for (i = 0; i < ex_parent->num_phys; i++) {
1579 struct ex_phy *phy = &ex_parent->ex_phy[i];
1580
1581 if ((phy->routing_attr == TABLE_ROUTING) &&
1582 (SAS_ADDR(phy->attached_sas_addr) ==
1583 SAS_ADDR(child->sas_addr))) {
1584 res = sas_configure_phy(parent, i, sas_addr, include);
1585 if (res)
1586 return res;
1587 }
1588 }
1589
1590 return res;
1591}
1592
1593
1594
1595
1596
1597
1598static int sas_configure_routing(struct domain_device *dev, u8 *sas_addr)
1599{
1600 if (dev->parent)
1601 return sas_configure_parent(dev->parent, dev, sas_addr, 1);
1602 return 0;
1603}
1604
1605static int sas_disable_routing(struct domain_device *dev, u8 *sas_addr)
1606{
1607 if (dev->parent)
1608 return sas_configure_parent(dev->parent, dev, sas_addr, 0);
1609 return 0;
1610}
1611
1612
1613
1614
1615
1616
1617
1618static int sas_discover_expander(struct domain_device *dev)
1619{
1620 int res;
1621
1622 res = sas_notify_lldd_dev_found(dev);
1623 if (res)
1624 return res;
1625
1626 res = sas_ex_general(dev);
1627 if (res)
1628 goto out_err;
1629 res = sas_ex_manuf_info(dev);
1630 if (res)
1631 goto out_err;
1632
1633 res = sas_expander_discover(dev);
1634 if (res) {
1635 pr_warn("expander %016llx discovery failed(0x%x)\n",
1636 SAS_ADDR(dev->sas_addr), res);
1637 goto out_err;
1638 }
1639
1640 sas_check_ex_subtractive_boundary(dev);
1641 res = sas_check_parent_topology(dev);
1642 if (res)
1643 goto out_err;
1644 return 0;
1645out_err:
1646 sas_notify_lldd_dev_gone(dev);
1647 return res;
1648}
1649
1650static int sas_ex_level_discovery(struct asd_sas_port *port, const int level)
1651{
1652 int res = 0;
1653 struct domain_device *dev;
1654
1655 list_for_each_entry(dev, &port->dev_list, dev_list_node) {
1656 if (dev->dev_type == SAS_EDGE_EXPANDER_DEVICE ||
1657 dev->dev_type == SAS_FANOUT_EXPANDER_DEVICE) {
1658 struct sas_expander_device *ex =
1659 rphy_to_expander_device(dev->rphy);
1660
1661 if (level == ex->level)
1662 res = sas_ex_discover_devices(dev, -1);
1663 else if (level > 0)
1664 res = sas_ex_discover_devices(port->port_dev, -1);
1665
1666 }
1667 }
1668
1669 return res;
1670}
1671
1672static int sas_ex_bfs_disc(struct asd_sas_port *port)
1673{
1674 int res;
1675 int level;
1676
1677 do {
1678 level = port->disc.max_level;
1679 res = sas_ex_level_discovery(port, level);
1680 mb();
1681 } while (level < port->disc.max_level);
1682
1683 return res;
1684}
1685
1686int sas_discover_root_expander(struct domain_device *dev)
1687{
1688 int res;
1689 struct sas_expander_device *ex = rphy_to_expander_device(dev->rphy);
1690
1691 res = sas_rphy_add(dev->rphy);
1692 if (res)
1693 goto out_err;
1694
1695 ex->level = dev->port->disc.max_level;
1696 res = sas_discover_expander(dev);
1697 if (res)
1698 goto out_err2;
1699
1700 sas_ex_bfs_disc(dev->port);
1701
1702 return res;
1703
1704out_err2:
1705 sas_rphy_remove(dev->rphy);
1706out_err:
1707 return res;
1708}
1709
1710
1711
1712static int sas_get_phy_discover(struct domain_device *dev,
1713 int phy_id, struct smp_resp *disc_resp)
1714{
1715 int res;
1716 u8 *disc_req;
1717
1718 disc_req = alloc_smp_req(DISCOVER_REQ_SIZE);
1719 if (!disc_req)
1720 return -ENOMEM;
1721
1722 disc_req[1] = SMP_DISCOVER;
1723 disc_req[9] = phy_id;
1724
1725 res = smp_execute_task(dev, disc_req, DISCOVER_REQ_SIZE,
1726 disc_resp, DISCOVER_RESP_SIZE);
1727 if (res)
1728 goto out;
1729 else if (disc_resp->result != SMP_RESP_FUNC_ACC) {
1730 res = disc_resp->result;
1731 goto out;
1732 }
1733out:
1734 kfree(disc_req);
1735 return res;
1736}
1737
1738static int sas_get_phy_change_count(struct domain_device *dev,
1739 int phy_id, int *pcc)
1740{
1741 int res;
1742 struct smp_resp *disc_resp;
1743
1744 disc_resp = alloc_smp_resp(DISCOVER_RESP_SIZE);
1745 if (!disc_resp)
1746 return -ENOMEM;
1747
1748 res = sas_get_phy_discover(dev, phy_id, disc_resp);
1749 if (!res)
1750 *pcc = disc_resp->disc.change_count;
1751
1752 kfree(disc_resp);
1753 return res;
1754}
1755
1756static int sas_get_phy_attached_dev(struct domain_device *dev, int phy_id,
1757 u8 *sas_addr, enum sas_device_type *type)
1758{
1759 int res;
1760 struct smp_resp *disc_resp;
1761 struct discover_resp *dr;
1762
1763 disc_resp = alloc_smp_resp(DISCOVER_RESP_SIZE);
1764 if (!disc_resp)
1765 return -ENOMEM;
1766 dr = &disc_resp->disc;
1767
1768 res = sas_get_phy_discover(dev, phy_id, disc_resp);
1769 if (res == 0) {
1770 memcpy(sas_addr, disc_resp->disc.attached_sas_addr,
1771 SAS_ADDR_SIZE);
1772 *type = to_dev_type(dr);
1773 if (*type == 0)
1774 memset(sas_addr, 0, SAS_ADDR_SIZE);
1775 }
1776 kfree(disc_resp);
1777 return res;
1778}
1779
1780static int sas_find_bcast_phy(struct domain_device *dev, int *phy_id,
1781 int from_phy, bool update)
1782{
1783 struct expander_device *ex = &dev->ex_dev;
1784 int res = 0;
1785 int i;
1786
1787 for (i = from_phy; i < ex->num_phys; i++) {
1788 int phy_change_count = 0;
1789
1790 res = sas_get_phy_change_count(dev, i, &phy_change_count);
1791 switch (res) {
1792 case SMP_RESP_PHY_VACANT:
1793 case SMP_RESP_NO_PHY:
1794 continue;
1795 case SMP_RESP_FUNC_ACC:
1796 break;
1797 default:
1798 return res;
1799 }
1800
1801 if (phy_change_count != ex->ex_phy[i].phy_change_count) {
1802 if (update)
1803 ex->ex_phy[i].phy_change_count =
1804 phy_change_count;
1805 *phy_id = i;
1806 return 0;
1807 }
1808 }
1809 return 0;
1810}
1811
1812static int sas_get_ex_change_count(struct domain_device *dev, int *ecc)
1813{
1814 int res;
1815 u8 *rg_req;
1816 struct smp_resp *rg_resp;
1817
1818 rg_req = alloc_smp_req(RG_REQ_SIZE);
1819 if (!rg_req)
1820 return -ENOMEM;
1821
1822 rg_resp = alloc_smp_resp(RG_RESP_SIZE);
1823 if (!rg_resp) {
1824 kfree(rg_req);
1825 return -ENOMEM;
1826 }
1827
1828 rg_req[1] = SMP_REPORT_GENERAL;
1829
1830 res = smp_execute_task(dev, rg_req, RG_REQ_SIZE, rg_resp,
1831 RG_RESP_SIZE);
1832 if (res)
1833 goto out;
1834 if (rg_resp->result != SMP_RESP_FUNC_ACC) {
1835 res = rg_resp->result;
1836 goto out;
1837 }
1838
1839 *ecc = be16_to_cpu(rg_resp->rg.change_count);
1840out:
1841 kfree(rg_resp);
1842 kfree(rg_req);
1843 return res;
1844}
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860static int sas_find_bcast_dev(struct domain_device *dev,
1861 struct domain_device **src_dev)
1862{
1863 struct expander_device *ex = &dev->ex_dev;
1864 int ex_change_count = -1;
1865 int phy_id = -1;
1866 int res;
1867 struct domain_device *ch;
1868
1869 res = sas_get_ex_change_count(dev, &ex_change_count);
1870 if (res)
1871 goto out;
1872 if (ex_change_count != -1 && ex_change_count != ex->ex_change_count) {
1873
1874
1875
1876
1877 res = sas_find_bcast_phy(dev, &phy_id, 0, false);
1878 if (phy_id != -1) {
1879 *src_dev = dev;
1880 ex->ex_change_count = ex_change_count;
1881 pr_info("ex %016llx phy%02d change count has changed\n",
1882 SAS_ADDR(dev->sas_addr), phy_id);
1883 return res;
1884 } else
1885 pr_info("ex %016llx phys DID NOT change\n",
1886 SAS_ADDR(dev->sas_addr));
1887 }
1888 list_for_each_entry(ch, &ex->children, siblings) {
1889 if (ch->dev_type == SAS_EDGE_EXPANDER_DEVICE || ch->dev_type == SAS_FANOUT_EXPANDER_DEVICE) {
1890 res = sas_find_bcast_dev(ch, src_dev);
1891 if (*src_dev)
1892 return res;
1893 }
1894 }
1895out:
1896 return res;
1897}
1898
1899static void sas_unregister_ex_tree(struct asd_sas_port *port, struct domain_device *dev)
1900{
1901 struct expander_device *ex = &dev->ex_dev;
1902 struct domain_device *child, *n;
1903
1904 list_for_each_entry_safe(child, n, &ex->children, siblings) {
1905 set_bit(SAS_DEV_GONE, &child->state);
1906 if (child->dev_type == SAS_EDGE_EXPANDER_DEVICE ||
1907 child->dev_type == SAS_FANOUT_EXPANDER_DEVICE)
1908 sas_unregister_ex_tree(port, child);
1909 else
1910 sas_unregister_dev(port, child);
1911 }
1912 sas_unregister_dev(port, dev);
1913}
1914
1915static void sas_unregister_devs_sas_addr(struct domain_device *parent,
1916 int phy_id, bool last)
1917{
1918 struct expander_device *ex_dev = &parent->ex_dev;
1919 struct ex_phy *phy = &ex_dev->ex_phy[phy_id];
1920 struct domain_device *child, *n, *found = NULL;
1921 if (last) {
1922 list_for_each_entry_safe(child, n,
1923 &ex_dev->children, siblings) {
1924 if (SAS_ADDR(child->sas_addr) ==
1925 SAS_ADDR(phy->attached_sas_addr)) {
1926 set_bit(SAS_DEV_GONE, &child->state);
1927 if (child->dev_type == SAS_EDGE_EXPANDER_DEVICE ||
1928 child->dev_type == SAS_FANOUT_EXPANDER_DEVICE)
1929 sas_unregister_ex_tree(parent->port, child);
1930 else
1931 sas_unregister_dev(parent->port, child);
1932 found = child;
1933 break;
1934 }
1935 }
1936 sas_disable_routing(parent, phy->attached_sas_addr);
1937 }
1938 memset(phy->attached_sas_addr, 0, SAS_ADDR_SIZE);
1939 if (phy->port) {
1940 sas_port_delete_phy(phy->port, phy->phy);
1941 sas_device_set_phy(found, phy->port);
1942 if (phy->port->num_phys == 0)
1943 list_add_tail(&phy->port->del_list,
1944 &parent->port->sas_port_del_list);
1945 phy->port = NULL;
1946 }
1947}
1948
1949static int sas_discover_bfs_by_root_level(struct domain_device *root,
1950 const int level)
1951{
1952 struct expander_device *ex_root = &root->ex_dev;
1953 struct domain_device *child;
1954 int res = 0;
1955
1956 list_for_each_entry(child, &ex_root->children, siblings) {
1957 if (child->dev_type == SAS_EDGE_EXPANDER_DEVICE ||
1958 child->dev_type == SAS_FANOUT_EXPANDER_DEVICE) {
1959 struct sas_expander_device *ex =
1960 rphy_to_expander_device(child->rphy);
1961
1962 if (level > ex->level)
1963 res = sas_discover_bfs_by_root_level(child,
1964 level);
1965 else if (level == ex->level)
1966 res = sas_ex_discover_devices(child, -1);
1967 }
1968 }
1969 return res;
1970}
1971
1972static int sas_discover_bfs_by_root(struct domain_device *dev)
1973{
1974 int res;
1975 struct sas_expander_device *ex = rphy_to_expander_device(dev->rphy);
1976 int level = ex->level+1;
1977
1978 res = sas_ex_discover_devices(dev, -1);
1979 if (res)
1980 goto out;
1981 do {
1982 res = sas_discover_bfs_by_root_level(dev, level);
1983 mb();
1984 level += 1;
1985 } while (level <= dev->port->disc.max_level);
1986out:
1987 return res;
1988}
1989
1990static int sas_discover_new(struct domain_device *dev, int phy_id)
1991{
1992 struct ex_phy *ex_phy = &dev->ex_dev.ex_phy[phy_id];
1993 struct domain_device *child;
1994 int res;
1995
1996 pr_debug("ex %016llx phy%02d new device attached\n",
1997 SAS_ADDR(dev->sas_addr), phy_id);
1998 res = sas_ex_phy_discover(dev, phy_id);
1999 if (res)
2000 return res;
2001
2002 if (sas_ex_join_wide_port(dev, phy_id))
2003 return 0;
2004
2005 res = sas_ex_discover_devices(dev, phy_id);
2006 if (res)
2007 return res;
2008 list_for_each_entry(child, &dev->ex_dev.children, siblings) {
2009 if (SAS_ADDR(child->sas_addr) ==
2010 SAS_ADDR(ex_phy->attached_sas_addr)) {
2011 if (child->dev_type == SAS_EDGE_EXPANDER_DEVICE ||
2012 child->dev_type == SAS_FANOUT_EXPANDER_DEVICE)
2013 res = sas_discover_bfs_by_root(child);
2014 break;
2015 }
2016 }
2017 return res;
2018}
2019
2020static bool dev_type_flutter(enum sas_device_type new, enum sas_device_type old)
2021{
2022 if (old == new)
2023 return true;
2024
2025
2026
2027
2028 if ((old == SAS_SATA_PENDING && new == SAS_END_DEVICE) ||
2029 (old == SAS_END_DEVICE && new == SAS_SATA_PENDING))
2030 return true;
2031
2032 return false;
2033}
2034
2035static int sas_rediscover_dev(struct domain_device *dev, int phy_id,
2036 bool last, int sibling)
2037{
2038 struct expander_device *ex = &dev->ex_dev;
2039 struct ex_phy *phy = &ex->ex_phy[phy_id];
2040 enum sas_device_type type = SAS_PHY_UNUSED;
2041 u8 sas_addr[SAS_ADDR_SIZE];
2042 char msg[80] = "";
2043 int res;
2044
2045 if (!last)
2046 sprintf(msg, ", part of a wide port with phy%02d", sibling);
2047
2048 pr_debug("ex %016llx rediscovering phy%02d%s\n",
2049 SAS_ADDR(dev->sas_addr), phy_id, msg);
2050
2051 memset(sas_addr, 0, SAS_ADDR_SIZE);
2052 res = sas_get_phy_attached_dev(dev, phy_id, sas_addr, &type);
2053 switch (res) {
2054 case SMP_RESP_NO_PHY:
2055 phy->phy_state = PHY_NOT_PRESENT;
2056 sas_unregister_devs_sas_addr(dev, phy_id, last);
2057 return res;
2058 case SMP_RESP_PHY_VACANT:
2059 phy->phy_state = PHY_VACANT;
2060 sas_unregister_devs_sas_addr(dev, phy_id, last);
2061 return res;
2062 case SMP_RESP_FUNC_ACC:
2063 break;
2064 case -ECOMM:
2065 break;
2066 default:
2067 return res;
2068 }
2069
2070 if ((SAS_ADDR(sas_addr) == 0) || (res == -ECOMM)) {
2071 phy->phy_state = PHY_EMPTY;
2072 sas_unregister_devs_sas_addr(dev, phy_id, last);
2073
2074
2075
2076
2077 sas_ex_phy_discover(dev, phy_id);
2078 return res;
2079 } else if (SAS_ADDR(sas_addr) == SAS_ADDR(phy->attached_sas_addr) &&
2080 dev_type_flutter(type, phy->attached_dev_type)) {
2081 struct domain_device *ata_dev = sas_ex_to_ata(dev, phy_id);
2082 char *action = "";
2083
2084 sas_ex_phy_discover(dev, phy_id);
2085
2086 if (ata_dev && phy->attached_dev_type == SAS_SATA_PENDING)
2087 action = ", needs recovery";
2088 pr_debug("ex %016llx phy%02d broadcast flutter%s\n",
2089 SAS_ADDR(dev->sas_addr), phy_id, action);
2090 return res;
2091 }
2092
2093
2094 pr_info("ex %016llx phy%02d replace %016llx\n",
2095 SAS_ADDR(dev->sas_addr), phy_id,
2096 SAS_ADDR(phy->attached_sas_addr));
2097 sas_unregister_devs_sas_addr(dev, phy_id, last);
2098
2099 return sas_discover_new(dev, phy_id);
2100}
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116static int sas_rediscover(struct domain_device *dev, const int phy_id)
2117{
2118 struct expander_device *ex = &dev->ex_dev;
2119 struct ex_phy *changed_phy = &ex->ex_phy[phy_id];
2120 int res = 0;
2121 int i;
2122 bool last = true;
2123
2124 pr_debug("ex %016llx phy%02d originated BROADCAST(CHANGE)\n",
2125 SAS_ADDR(dev->sas_addr), phy_id);
2126
2127 if (SAS_ADDR(changed_phy->attached_sas_addr) != 0) {
2128 for (i = 0; i < ex->num_phys; i++) {
2129 struct ex_phy *phy = &ex->ex_phy[i];
2130
2131 if (i == phy_id)
2132 continue;
2133 if (SAS_ADDR(phy->attached_sas_addr) ==
2134 SAS_ADDR(changed_phy->attached_sas_addr)) {
2135 last = false;
2136 break;
2137 }
2138 }
2139 res = sas_rediscover_dev(dev, phy_id, last, i);
2140 } else
2141 res = sas_discover_new(dev, phy_id);
2142 return res;
2143}
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154int sas_ex_revalidate_domain(struct domain_device *port_dev)
2155{
2156 int res;
2157 struct domain_device *dev = NULL;
2158
2159 res = sas_find_bcast_dev(port_dev, &dev);
2160 if (res == 0 && dev) {
2161 struct expander_device *ex = &dev->ex_dev;
2162 int i = 0, phy_id;
2163
2164 do {
2165 phy_id = -1;
2166 res = sas_find_bcast_phy(dev, &phy_id, i, true);
2167 if (phy_id == -1)
2168 break;
2169 res = sas_rediscover(dev, phy_id);
2170 i = phy_id + 1;
2171 } while (i < ex->num_phys);
2172 }
2173 return res;
2174}
2175
2176void sas_smp_handler(struct bsg_job *job, struct Scsi_Host *shost,
2177 struct sas_rphy *rphy)
2178{
2179 struct domain_device *dev;
2180 unsigned int rcvlen = 0;
2181 int ret = -EINVAL;
2182
2183
2184 if (!rphy)
2185 return sas_smp_host_handler(job, shost);
2186
2187 switch (rphy->identify.device_type) {
2188 case SAS_EDGE_EXPANDER_DEVICE:
2189 case SAS_FANOUT_EXPANDER_DEVICE:
2190 break;
2191 default:
2192 pr_err("%s: can we send a smp request to a device?\n",
2193 __func__);
2194 goto out;
2195 }
2196
2197 dev = sas_find_dev_by_rphy(rphy);
2198 if (!dev) {
2199 pr_err("%s: fail to find a domain_device?\n", __func__);
2200 goto out;
2201 }
2202
2203
2204 if (job->request_payload.sg_cnt > 1 ||
2205 job->reply_payload.sg_cnt > 1) {
2206 pr_info("%s: multiple segments req %u, rsp %u\n",
2207 __func__, job->request_payload.payload_len,
2208 job->reply_payload.payload_len);
2209 goto out;
2210 }
2211
2212 ret = smp_execute_task_sg(dev, job->request_payload.sg_list,
2213 job->reply_payload.sg_list);
2214 if (ret >= 0) {
2215
2216 rcvlen = job->reply_payload.payload_len - ret;
2217 ret = 0;
2218 }
2219
2220out:
2221 bsg_job_done(job, ret, rcvlen);
2222}
2223