2 * Serial Attached SCSI (SAS) Expander discovery and configuration
4 * Copyright (C) 2005 Adaptec, Inc. All rights reserved.
5 * Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com>
7 * This file is licensed under GPLv2.
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License as
11 * published by the Free Software Foundation; either version 2 of the
12 * License, or (at your option) any later version.
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
25 #include <linux/pci.h>
26 #include <linux/scatterlist.h>
28 #include "sas_internal.h"
30 #include <scsi/scsi_transport.h>
31 #include <scsi/scsi_transport_sas.h>
32 #include "../scsi_sas_internal.h"
34 static int sas_discover_expander(struct domain_device
*dev
);
35 static int sas_configure_routing(struct domain_device
*dev
, u8
*sas_addr
);
36 static int sas_configure_phy(struct domain_device
*dev
, int phy_id
,
37 u8
*sas_addr
, int include
);
38 static int sas_disable_routing(struct domain_device
*dev
, u8
*sas_addr
);
41 /* FIXME: smp needs to migrate into the sas class */
42 static ssize_t
smp_portal_read(struct kobject
*, char *, loff_t
, size_t);
43 static ssize_t
smp_portal_write(struct kobject
*, char *, loff_t
, size_t);
46 /* ---------- SMP task management ---------- */
48 static void smp_task_timedout(unsigned long _task
)
50 struct sas_task
*task
= (void *) _task
;
53 spin_lock_irqsave(&task
->task_state_lock
, flags
);
54 if (!(task
->task_state_flags
& SAS_TASK_STATE_DONE
))
55 task
->task_state_flags
|= SAS_TASK_STATE_ABORTED
;
56 spin_unlock_irqrestore(&task
->task_state_lock
, flags
);
58 complete(&task
->completion
);
61 static void smp_task_done(struct sas_task
*task
)
63 if (!del_timer(&task
->timer
))
65 complete(&task
->completion
);
68 /* Give it some long enough timeout. In seconds. */
69 #define SMP_TIMEOUT 10
71 static int smp_execute_task(struct domain_device
*dev
, void *req
, int req_size
,
72 void *resp
, int resp_size
)
75 struct sas_task
*task
= NULL
;
76 struct sas_internal
*i
=
77 to_sas_internal(dev
->port
->ha
->core
.shost
->transportt
);
79 for (retry
= 0; retry
< 3; retry
++) {
80 task
= sas_alloc_task(GFP_KERNEL
);
85 task
->task_proto
= dev
->tproto
;
86 sg_init_one(&task
->smp_task
.smp_req
, req
, req_size
);
87 sg_init_one(&task
->smp_task
.smp_resp
, resp
, resp_size
);
89 task
->task_done
= smp_task_done
;
91 task
->timer
.data
= (unsigned long) task
;
92 task
->timer
.function
= smp_task_timedout
;
93 task
->timer
.expires
= jiffies
+ SMP_TIMEOUT
*HZ
;
94 add_timer(&task
->timer
);
96 res
= i
->dft
->lldd_execute_task(task
, 1, GFP_KERNEL
);
99 del_timer(&task
->timer
);
100 SAS_DPRINTK("executing SMP task failed:%d\n", res
);
104 wait_for_completion(&task
->completion
);
106 if ((task
->task_state_flags
& SAS_TASK_STATE_ABORTED
)) {
107 SAS_DPRINTK("smp task timed out or aborted\n");
108 i
->dft
->lldd_abort_task(task
);
109 if (!(task
->task_state_flags
& SAS_TASK_STATE_DONE
)) {
110 SAS_DPRINTK("SMP task aborted and not done\n");
114 if (task
->task_status
.resp
== SAS_TASK_COMPLETE
&&
115 task
->task_status
.stat
== SAM_GOOD
) {
119 SAS_DPRINTK("%s: task to dev %016llx response: 0x%x "
120 "status 0x%x\n", __FUNCTION__
,
121 SAS_ADDR(dev
->sas_addr
),
122 task
->task_status
.resp
,
123 task
->task_status
.stat
);
129 BUG_ON(retry
== 3 && task
!= NULL
);
136 /* ---------- Allocations ---------- */
138 static inline void *alloc_smp_req(int size
)
140 u8
*p
= kzalloc(size
, GFP_KERNEL
);
146 static inline void *alloc_smp_resp(int size
)
148 return kzalloc(size
, GFP_KERNEL
);
151 /* ---------- Expander configuration ---------- */
153 static void sas_set_ex_phy(struct domain_device
*dev
, int phy_id
,
156 struct expander_device
*ex
= &dev
->ex_dev
;
157 struct ex_phy
*phy
= &ex
->ex_phy
[phy_id
];
158 struct smp_resp
*resp
= disc_resp
;
159 struct discover_resp
*dr
= &resp
->disc
;
160 struct sas_rphy
*rphy
= dev
->rphy
;
161 int rediscover
= (phy
->phy
!= NULL
);
164 phy
->phy
= sas_phy_alloc(&rphy
->dev
, phy_id
);
166 /* FIXME: error_handling */
170 switch (resp
->result
) {
171 case SMP_RESP_PHY_VACANT
:
172 phy
->phy_state
= PHY_VACANT
;
175 phy
->phy_state
= PHY_NOT_PRESENT
;
177 case SMP_RESP_FUNC_ACC
:
178 phy
->phy_state
= PHY_EMPTY
; /* do not know yet */
182 phy
->phy_id
= phy_id
;
183 phy
->attached_dev_type
= dr
->attached_dev_type
;
184 phy
->linkrate
= dr
->linkrate
;
185 phy
->attached_sata_host
= dr
->attached_sata_host
;
186 phy
->attached_sata_dev
= dr
->attached_sata_dev
;
187 phy
->attached_sata_ps
= dr
->attached_sata_ps
;
188 phy
->attached_iproto
= dr
->iproto
<< 1;
189 phy
->attached_tproto
= dr
->tproto
<< 1;
190 memcpy(phy
->attached_sas_addr
, dr
->attached_sas_addr
, SAS_ADDR_SIZE
);
191 phy
->attached_phy_id
= dr
->attached_phy_id
;
192 phy
->phy_change_count
= dr
->change_count
;
193 phy
->routing_attr
= dr
->routing_attr
;
194 phy
->virtual = dr
->virtual;
195 phy
->last_da_index
= -1;
197 phy
->phy
->identify
.initiator_port_protocols
= phy
->attached_iproto
;
198 phy
->phy
->identify
.target_port_protocols
= phy
->attached_tproto
;
199 phy
->phy
->identify
.phy_identifier
= phy_id
;
200 phy
->phy
->minimum_linkrate_hw
= dr
->hmin_linkrate
;
201 phy
->phy
->maximum_linkrate_hw
= dr
->hmax_linkrate
;
202 phy
->phy
->minimum_linkrate
= dr
->pmin_linkrate
;
203 phy
->phy
->maximum_linkrate
= dr
->pmax_linkrate
;
204 phy
->phy
->negotiated_linkrate
= phy
->linkrate
;
207 sas_phy_add(phy
->phy
);
209 SAS_DPRINTK("ex %016llx phy%02d:%c attached: %016llx\n",
210 SAS_ADDR(dev
->sas_addr
), phy
->phy_id
,
211 phy
->routing_attr
== TABLE_ROUTING
? 'T' :
212 phy
->routing_attr
== DIRECT_ROUTING
? 'D' :
213 phy
->routing_attr
== SUBTRACTIVE_ROUTING
? 'S' : '?',
214 SAS_ADDR(phy
->attached_sas_addr
));
219 #define DISCOVER_REQ_SIZE 16
220 #define DISCOVER_RESP_SIZE 56
222 static int sas_ex_phy_discover(struct domain_device
*dev
, int single
)
224 struct expander_device
*ex
= &dev
->ex_dev
;
229 disc_req
= alloc_smp_req(DISCOVER_REQ_SIZE
);
233 disc_resp
= alloc_smp_req(DISCOVER_RESP_SIZE
);
239 disc_req
[1] = SMP_DISCOVER
;
241 if (0 <= single
&& single
< ex
->num_phys
) {
242 disc_req
[9] = single
;
243 res
= smp_execute_task(dev
, disc_req
, DISCOVER_REQ_SIZE
,
244 disc_resp
, DISCOVER_RESP_SIZE
);
247 sas_set_ex_phy(dev
, single
, disc_resp
);
251 for (i
= 0; i
< ex
->num_phys
; i
++) {
253 res
= smp_execute_task(dev
, disc_req
,
254 DISCOVER_REQ_SIZE
, disc_resp
,
258 sas_set_ex_phy(dev
, i
, disc_resp
);
267 static int sas_expander_discover(struct domain_device
*dev
)
269 struct expander_device
*ex
= &dev
->ex_dev
;
272 ex
->ex_phy
= kzalloc(sizeof(*ex
->ex_phy
)*ex
->num_phys
, GFP_KERNEL
);
276 res
= sas_ex_phy_discover(dev
, -1);
287 #define MAX_EXPANDER_PHYS 128
289 static void ex_assign_report_general(struct domain_device
*dev
,
290 struct smp_resp
*resp
)
292 struct report_general_resp
*rg
= &resp
->rg
;
294 dev
->ex_dev
.ex_change_count
= be16_to_cpu(rg
->change_count
);
295 dev
->ex_dev
.max_route_indexes
= be16_to_cpu(rg
->route_indexes
);
296 dev
->ex_dev
.num_phys
= min(rg
->num_phys
, (u8
)MAX_EXPANDER_PHYS
);
297 dev
->ex_dev
.conf_route_table
= rg
->conf_route_table
;
298 dev
->ex_dev
.configuring
= rg
->configuring
;
299 memcpy(dev
->ex_dev
.enclosure_logical_id
, rg
->enclosure_logical_id
, 8);
302 #define RG_REQ_SIZE 8
303 #define RG_RESP_SIZE 32
305 static int sas_ex_general(struct domain_device
*dev
)
308 struct smp_resp
*rg_resp
;
312 rg_req
= alloc_smp_req(RG_REQ_SIZE
);
316 rg_resp
= alloc_smp_resp(RG_RESP_SIZE
);
322 rg_req
[1] = SMP_REPORT_GENERAL
;
324 for (i
= 0; i
< 5; i
++) {
325 res
= smp_execute_task(dev
, rg_req
, RG_REQ_SIZE
, rg_resp
,
329 SAS_DPRINTK("RG to ex %016llx failed:0x%x\n",
330 SAS_ADDR(dev
->sas_addr
), res
);
332 } else if (rg_resp
->result
!= SMP_RESP_FUNC_ACC
) {
333 SAS_DPRINTK("RG:ex %016llx returned SMP result:0x%x\n",
334 SAS_ADDR(dev
->sas_addr
), rg_resp
->result
);
335 res
= rg_resp
->result
;
339 ex_assign_report_general(dev
, rg_resp
);
341 if (dev
->ex_dev
.configuring
) {
342 SAS_DPRINTK("RG: ex %llx self-configuring...\n",
343 SAS_ADDR(dev
->sas_addr
));
344 schedule_timeout_interruptible(5*HZ
);
354 static void ex_assign_manuf_info(struct domain_device
*dev
, void
357 u8
*mi_resp
= _mi_resp
;
358 struct sas_rphy
*rphy
= dev
->rphy
;
359 struct sas_expander_device
*edev
= rphy_to_expander_device(rphy
);
361 memcpy(edev
->vendor_id
, mi_resp
+ 12, SAS_EXPANDER_VENDOR_ID_LEN
);
362 memcpy(edev
->product_id
, mi_resp
+ 20, SAS_EXPANDER_PRODUCT_ID_LEN
);
363 memcpy(edev
->product_rev
, mi_resp
+ 36,
364 SAS_EXPANDER_PRODUCT_REV_LEN
);
366 if (mi_resp
[8] & 1) {
367 memcpy(edev
->component_vendor_id
, mi_resp
+ 40,
368 SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN
);
369 edev
->component_id
= mi_resp
[48] << 8 | mi_resp
[49];
370 edev
->component_revision_id
= mi_resp
[50];
374 #define MI_REQ_SIZE 8
375 #define MI_RESP_SIZE 64
377 static int sas_ex_manuf_info(struct domain_device
*dev
)
383 mi_req
= alloc_smp_req(MI_REQ_SIZE
);
387 mi_resp
= alloc_smp_resp(MI_RESP_SIZE
);
393 mi_req
[1] = SMP_REPORT_MANUF_INFO
;
395 res
= smp_execute_task(dev
, mi_req
, MI_REQ_SIZE
, mi_resp
,MI_RESP_SIZE
);
397 SAS_DPRINTK("MI: ex %016llx failed:0x%x\n",
398 SAS_ADDR(dev
->sas_addr
), res
);
400 } else if (mi_resp
[2] != SMP_RESP_FUNC_ACC
) {
401 SAS_DPRINTK("MI ex %016llx returned SMP result:0x%x\n",
402 SAS_ADDR(dev
->sas_addr
), mi_resp
[2]);
406 ex_assign_manuf_info(dev
, mi_resp
);
413 #define PC_REQ_SIZE 44
414 #define PC_RESP_SIZE 8
416 int sas_smp_phy_control(struct domain_device
*dev
, int phy_id
,
417 enum phy_func phy_func
,
418 struct sas_phy_linkrates
*rates
)
424 pc_req
= alloc_smp_req(PC_REQ_SIZE
);
428 pc_resp
= alloc_smp_resp(PC_RESP_SIZE
);
434 pc_req
[1] = SMP_PHY_CONTROL
;
436 pc_req
[10]= phy_func
;
438 pc_req
[32] = rates
->minimum_linkrate
<< 4;
439 pc_req
[33] = rates
->maximum_linkrate
<< 4;
442 res
= smp_execute_task(dev
, pc_req
, PC_REQ_SIZE
, pc_resp
,PC_RESP_SIZE
);
449 static void sas_ex_disable_phy(struct domain_device
*dev
, int phy_id
)
451 struct expander_device
*ex
= &dev
->ex_dev
;
452 struct ex_phy
*phy
= &ex
->ex_phy
[phy_id
];
454 sas_smp_phy_control(dev
, phy_id
, PHY_FUNC_DISABLE
, NULL
);
455 phy
->linkrate
= SAS_PHY_DISABLED
;
458 static void sas_ex_disable_port(struct domain_device
*dev
, u8
*sas_addr
)
460 struct expander_device
*ex
= &dev
->ex_dev
;
463 for (i
= 0; i
< ex
->num_phys
; i
++) {
464 struct ex_phy
*phy
= &ex
->ex_phy
[i
];
466 if (phy
->phy_state
== PHY_VACANT
||
467 phy
->phy_state
== PHY_NOT_PRESENT
)
470 if (SAS_ADDR(phy
->attached_sas_addr
) == SAS_ADDR(sas_addr
))
471 sas_ex_disable_phy(dev
, i
);
475 static int sas_dev_present_in_domain(struct asd_sas_port
*port
,
478 struct domain_device
*dev
;
480 if (SAS_ADDR(port
->sas_addr
) == SAS_ADDR(sas_addr
))
482 list_for_each_entry(dev
, &port
->dev_list
, dev_list_node
) {
483 if (SAS_ADDR(dev
->sas_addr
) == SAS_ADDR(sas_addr
))
489 #define RPEL_REQ_SIZE 16
490 #define RPEL_RESP_SIZE 32
491 int sas_smp_get_phy_events(struct sas_phy
*phy
)
494 struct sas_rphy
*rphy
= dev_to_rphy(phy
->dev
.parent
);
495 struct domain_device
*dev
= sas_find_dev_by_rphy(rphy
);
496 u8
*req
= alloc_smp_req(RPEL_REQ_SIZE
);
497 u8
*resp
= kzalloc(RPEL_RESP_SIZE
, GFP_KERNEL
);
502 req
[1] = SMP_REPORT_PHY_ERR_LOG
;
503 req
[9] = phy
->number
;
505 res
= smp_execute_task(dev
, req
, RPEL_REQ_SIZE
,
506 resp
, RPEL_RESP_SIZE
);
511 phy
->invalid_dword_count
= scsi_to_u32(&resp
[12]);
512 phy
->running_disparity_error_count
= scsi_to_u32(&resp
[16]);
513 phy
->loss_of_dword_sync_count
= scsi_to_u32(&resp
[20]);
514 phy
->phy_reset_problem_count
= scsi_to_u32(&resp
[24]);
522 #define RPS_REQ_SIZE 16
523 #define RPS_RESP_SIZE 60
525 static int sas_get_report_phy_sata(struct domain_device
*dev
,
527 struct smp_resp
*rps_resp
)
530 u8
*rps_req
= alloc_smp_req(RPS_REQ_SIZE
);
535 rps_req
[1] = SMP_REPORT_PHY_SATA
;
538 res
= smp_execute_task(dev
, rps_req
, RPS_REQ_SIZE
,
539 rps_resp
, RPS_RESP_SIZE
);
545 static void sas_ex_get_linkrate(struct domain_device
*parent
,
546 struct domain_device
*child
,
547 struct ex_phy
*parent_phy
)
549 struct expander_device
*parent_ex
= &parent
->ex_dev
;
550 struct sas_port
*port
;
555 port
= parent_phy
->port
;
557 for (i
= 0; i
< parent_ex
->num_phys
; i
++) {
558 struct ex_phy
*phy
= &parent_ex
->ex_phy
[i
];
560 if (phy
->phy_state
== PHY_VACANT
||
561 phy
->phy_state
== PHY_NOT_PRESENT
)
564 if (SAS_ADDR(phy
->attached_sas_addr
) ==
565 SAS_ADDR(child
->sas_addr
)) {
567 child
->min_linkrate
= min(parent
->min_linkrate
,
569 child
->max_linkrate
= max(parent
->max_linkrate
,
572 sas_port_add_phy(port
, phy
->phy
);
575 child
->linkrate
= min(parent_phy
->linkrate
, child
->max_linkrate
);
576 child
->pathways
= min(child
->pathways
, parent
->pathways
);
579 static struct domain_device
*sas_ex_discover_end_dev(
580 struct domain_device
*parent
, int phy_id
)
582 struct expander_device
*parent_ex
= &parent
->ex_dev
;
583 struct ex_phy
*phy
= &parent_ex
->ex_phy
[phy_id
];
584 struct domain_device
*child
= NULL
;
585 struct sas_rphy
*rphy
;
588 if (phy
->attached_sata_host
|| phy
->attached_sata_ps
)
591 child
= kzalloc(sizeof(*child
), GFP_KERNEL
);
595 child
->parent
= parent
;
596 child
->port
= parent
->port
;
597 child
->iproto
= phy
->attached_iproto
;
598 memcpy(child
->sas_addr
, phy
->attached_sas_addr
, SAS_ADDR_SIZE
);
599 sas_hash_addr(child
->hashed_sas_addr
, child
->sas_addr
);
601 phy
->port
= sas_port_alloc(&parent
->rphy
->dev
, phy_id
);
602 if (unlikely(!phy
->port
))
604 if (unlikely(sas_port_add(phy
->port
) != 0)) {
605 sas_port_free(phy
->port
);
609 sas_ex_get_linkrate(parent
, child
, phy
);
611 if ((phy
->attached_tproto
& SAS_PROTO_STP
) || phy
->attached_sata_dev
) {
612 child
->dev_type
= SATA_DEV
;
613 if (phy
->attached_tproto
& SAS_PROTO_STP
)
614 child
->tproto
= phy
->attached_tproto
;
615 if (phy
->attached_sata_dev
)
616 child
->tproto
|= SATA_DEV
;
617 res
= sas_get_report_phy_sata(parent
, phy_id
,
618 &child
->sata_dev
.rps_resp
);
620 SAS_DPRINTK("report phy sata to %016llx:0x%x returned "
621 "0x%x\n", SAS_ADDR(parent
->sas_addr
),
625 memcpy(child
->frame_rcvd
, &child
->sata_dev
.rps_resp
.rps
.fis
,
626 sizeof(struct dev_to_host_fis
));
628 res
= sas_discover_sata(child
);
630 SAS_DPRINTK("sas_discover_sata() for device %16llx at "
631 "%016llx:0x%x returned 0x%x\n",
632 SAS_ADDR(child
->sas_addr
),
633 SAS_ADDR(parent
->sas_addr
), phy_id
, res
);
636 } else if (phy
->attached_tproto
& SAS_PROTO_SSP
) {
637 child
->dev_type
= SAS_END_DEV
;
638 rphy
= sas_end_device_alloc(phy
->port
);
639 /* FIXME: error handling */
642 child
->tproto
= phy
->attached_tproto
;
646 sas_fill_in_rphy(child
, rphy
);
648 spin_lock(&parent
->port
->dev_list_lock
);
649 list_add_tail(&child
->dev_list_node
, &parent
->port
->dev_list
);
650 spin_unlock(&parent
->port
->dev_list_lock
);
652 res
= sas_discover_end_dev(child
);
654 SAS_DPRINTK("sas_discover_end_dev() for device %16llx "
655 "at %016llx:0x%x returned 0x%x\n",
656 SAS_ADDR(child
->sas_addr
),
657 SAS_ADDR(parent
->sas_addr
), phy_id
, res
);
661 SAS_DPRINTK("target proto 0x%x at %016llx:0x%x not handled\n",
662 phy
->attached_tproto
, SAS_ADDR(parent
->sas_addr
),
666 list_add_tail(&child
->siblings
, &parent_ex
->children
);
670 sas_rphy_free(child
->rphy
);
672 list_del(&child
->dev_list_node
);
674 sas_port_delete(phy
->port
);
681 /* See if this phy is part of a wide port */
682 static int sas_ex_join_wide_port(struct domain_device
*parent
, int phy_id
)
684 struct ex_phy
*phy
= &parent
->ex_dev
.ex_phy
[phy_id
];
687 for (i
= 0; i
< parent
->ex_dev
.num_phys
; i
++) {
688 struct ex_phy
*ephy
= &parent
->ex_dev
.ex_phy
[i
];
693 if (!memcmp(phy
->attached_sas_addr
, ephy
->attached_sas_addr
,
694 SAS_ADDR_SIZE
) && ephy
->port
) {
695 sas_port_add_phy(ephy
->port
, phy
->phy
);
696 phy
->phy_state
= PHY_DEVICE_DISCOVERED
;
704 static struct domain_device
*sas_ex_discover_expander(
705 struct domain_device
*parent
, int phy_id
)
707 struct sas_expander_device
*parent_ex
= rphy_to_expander_device(parent
->rphy
);
708 struct ex_phy
*phy
= &parent
->ex_dev
.ex_phy
[phy_id
];
709 struct domain_device
*child
= NULL
;
710 struct sas_rphy
*rphy
;
711 struct sas_expander_device
*edev
;
712 struct asd_sas_port
*port
;
715 if (phy
->routing_attr
== DIRECT_ROUTING
) {
716 SAS_DPRINTK("ex %016llx:0x%x:D <--> ex %016llx:0x%x is not "
718 SAS_ADDR(parent
->sas_addr
), phy_id
,
719 SAS_ADDR(phy
->attached_sas_addr
),
720 phy
->attached_phy_id
);
723 child
= kzalloc(sizeof(*child
), GFP_KERNEL
);
727 phy
->port
= sas_port_alloc(&parent
->rphy
->dev
, phy_id
);
728 /* FIXME: better error handling */
729 BUG_ON(sas_port_add(phy
->port
) != 0);
732 switch (phy
->attached_dev_type
) {
734 rphy
= sas_expander_alloc(phy
->port
,
735 SAS_EDGE_EXPANDER_DEVICE
);
738 rphy
= sas_expander_alloc(phy
->port
,
739 SAS_FANOUT_EXPANDER_DEVICE
);
742 rphy
= NULL
; /* shut gcc up */
747 edev
= rphy_to_expander_device(rphy
);
748 child
->dev_type
= phy
->attached_dev_type
;
749 child
->parent
= parent
;
751 child
->iproto
= phy
->attached_iproto
;
752 child
->tproto
= phy
->attached_tproto
;
753 memcpy(child
->sas_addr
, phy
->attached_sas_addr
, SAS_ADDR_SIZE
);
754 sas_hash_addr(child
->hashed_sas_addr
, child
->sas_addr
);
755 sas_ex_get_linkrate(parent
, child
, phy
);
756 edev
->level
= parent_ex
->level
+ 1;
757 parent
->port
->disc
.max_level
= max(parent
->port
->disc
.max_level
,
760 sas_fill_in_rphy(child
, rphy
);
763 spin_lock(&parent
->port
->dev_list_lock
);
764 list_add_tail(&child
->dev_list_node
, &parent
->port
->dev_list
);
765 spin_unlock(&parent
->port
->dev_list_lock
);
767 res
= sas_discover_expander(child
);
772 list_add_tail(&child
->siblings
, &parent
->ex_dev
.children
);
776 static int sas_ex_discover_dev(struct domain_device
*dev
, int phy_id
)
778 struct expander_device
*ex
= &dev
->ex_dev
;
779 struct ex_phy
*ex_phy
= &ex
->ex_phy
[phy_id
];
780 struct domain_device
*child
= NULL
;
784 if (ex_phy
->linkrate
== SAS_SATA_SPINUP_HOLD
) {
785 if (!sas_smp_phy_control(dev
, phy_id
, PHY_FUNC_LINK_RESET
, NULL
))
786 res
= sas_ex_phy_discover(dev
, phy_id
);
791 /* Parent and domain coherency */
792 if (!dev
->parent
&& (SAS_ADDR(ex_phy
->attached_sas_addr
) ==
793 SAS_ADDR(dev
->port
->sas_addr
))) {
794 sas_add_parent_port(dev
, phy_id
);
797 if (dev
->parent
&& (SAS_ADDR(ex_phy
->attached_sas_addr
) ==
798 SAS_ADDR(dev
->parent
->sas_addr
))) {
799 sas_add_parent_port(dev
, phy_id
);
800 if (ex_phy
->routing_attr
== TABLE_ROUTING
)
801 sas_configure_phy(dev
, phy_id
, dev
->port
->sas_addr
, 1);
805 if (sas_dev_present_in_domain(dev
->port
, ex_phy
->attached_sas_addr
))
806 sas_ex_disable_port(dev
, ex_phy
->attached_sas_addr
);
808 if (ex_phy
->attached_dev_type
== NO_DEVICE
) {
809 if (ex_phy
->routing_attr
== DIRECT_ROUTING
) {
810 memset(ex_phy
->attached_sas_addr
, 0, SAS_ADDR_SIZE
);
811 sas_configure_routing(dev
, ex_phy
->attached_sas_addr
);
814 } else if (ex_phy
->linkrate
== SAS_LINK_RATE_UNKNOWN
)
817 if (ex_phy
->attached_dev_type
!= SAS_END_DEV
&&
818 ex_phy
->attached_dev_type
!= FANOUT_DEV
&&
819 ex_phy
->attached_dev_type
!= EDGE_DEV
) {
820 SAS_DPRINTK("unknown device type(0x%x) attached to ex %016llx "
821 "phy 0x%x\n", ex_phy
->attached_dev_type
,
822 SAS_ADDR(dev
->sas_addr
),
827 res
= sas_configure_routing(dev
, ex_phy
->attached_sas_addr
);
829 SAS_DPRINTK("configure routing for dev %016llx "
830 "reported 0x%x. Forgotten\n",
831 SAS_ADDR(ex_phy
->attached_sas_addr
), res
);
832 sas_disable_routing(dev
, ex_phy
->attached_sas_addr
);
836 res
= sas_ex_join_wide_port(dev
, phy_id
);
838 SAS_DPRINTK("Attaching ex phy%d to wide port %016llx\n",
839 phy_id
, SAS_ADDR(ex_phy
->attached_sas_addr
));
843 switch (ex_phy
->attached_dev_type
) {
845 child
= sas_ex_discover_end_dev(dev
, phy_id
);
848 if (SAS_ADDR(dev
->port
->disc
.fanout_sas_addr
)) {
849 SAS_DPRINTK("second fanout expander %016llx phy 0x%x "
850 "attached to ex %016llx phy 0x%x\n",
851 SAS_ADDR(ex_phy
->attached_sas_addr
),
852 ex_phy
->attached_phy_id
,
853 SAS_ADDR(dev
->sas_addr
),
855 sas_ex_disable_phy(dev
, phy_id
);
858 memcpy(dev
->port
->disc
.fanout_sas_addr
,
859 ex_phy
->attached_sas_addr
, SAS_ADDR_SIZE
);
862 child
= sas_ex_discover_expander(dev
, phy_id
);
871 for (i
= 0; i
< ex
->num_phys
; i
++) {
872 if (ex
->ex_phy
[i
].phy_state
== PHY_VACANT
||
873 ex
->ex_phy
[i
].phy_state
== PHY_NOT_PRESENT
)
876 if (SAS_ADDR(ex
->ex_phy
[i
].attached_sas_addr
) ==
877 SAS_ADDR(child
->sas_addr
))
878 ex
->ex_phy
[i
].phy_state
= PHY_DEVICE_DISCOVERED
;
885 static int sas_find_sub_addr(struct domain_device
*dev
, u8
*sub_addr
)
887 struct expander_device
*ex
= &dev
->ex_dev
;
890 for (i
= 0; i
< ex
->num_phys
; i
++) {
891 struct ex_phy
*phy
= &ex
->ex_phy
[i
];
893 if (phy
->phy_state
== PHY_VACANT
||
894 phy
->phy_state
== PHY_NOT_PRESENT
)
897 if ((phy
->attached_dev_type
== EDGE_DEV
||
898 phy
->attached_dev_type
== FANOUT_DEV
) &&
899 phy
->routing_attr
== SUBTRACTIVE_ROUTING
) {
901 memcpy(sub_addr
, phy
->attached_sas_addr
,SAS_ADDR_SIZE
);
909 static int sas_check_level_subtractive_boundary(struct domain_device
*dev
)
911 struct expander_device
*ex
= &dev
->ex_dev
;
912 struct domain_device
*child
;
913 u8 sub_addr
[8] = {0, };
915 list_for_each_entry(child
, &ex
->children
, siblings
) {
916 if (child
->dev_type
!= EDGE_DEV
&&
917 child
->dev_type
!= FANOUT_DEV
)
919 if (sub_addr
[0] == 0) {
920 sas_find_sub_addr(child
, sub_addr
);
925 if (sas_find_sub_addr(child
, s2
) &&
926 (SAS_ADDR(sub_addr
) != SAS_ADDR(s2
))) {
928 SAS_DPRINTK("ex %016llx->%016llx-?->%016llx "
929 "diverges from subtractive "
930 "boundary %016llx\n",
931 SAS_ADDR(dev
->sas_addr
),
932 SAS_ADDR(child
->sas_addr
),
936 sas_ex_disable_port(child
, s2
);
943 * sas_ex_discover_devices -- discover devices attached to this expander
944 * dev: pointer to the expander domain device
945 * single: if you want to do a single phy, else set to -1;
947 * Configure this expander for use with its devices and register the
948 * devices of this expander.
950 static int sas_ex_discover_devices(struct domain_device
*dev
, int single
)
952 struct expander_device
*ex
= &dev
->ex_dev
;
953 int i
= 0, end
= ex
->num_phys
;
956 if (0 <= single
&& single
< end
) {
961 for ( ; i
< end
; i
++) {
962 struct ex_phy
*ex_phy
= &ex
->ex_phy
[i
];
964 if (ex_phy
->phy_state
== PHY_VACANT
||
965 ex_phy
->phy_state
== PHY_NOT_PRESENT
||
966 ex_phy
->phy_state
== PHY_DEVICE_DISCOVERED
)
969 switch (ex_phy
->linkrate
) {
970 case SAS_PHY_DISABLED
:
971 case SAS_PHY_RESET_PROBLEM
:
972 case SAS_SATA_PORT_SELECTOR
:
975 res
= sas_ex_discover_dev(dev
, i
);
983 sas_check_level_subtractive_boundary(dev
);
988 static int sas_check_ex_subtractive_boundary(struct domain_device
*dev
)
990 struct expander_device
*ex
= &dev
->ex_dev
;
992 u8
*sub_sas_addr
= NULL
;
994 if (dev
->dev_type
!= EDGE_DEV
)
997 for (i
= 0; i
< ex
->num_phys
; i
++) {
998 struct ex_phy
*phy
= &ex
->ex_phy
[i
];
1000 if (phy
->phy_state
== PHY_VACANT
||
1001 phy
->phy_state
== PHY_NOT_PRESENT
)
1004 if ((phy
->attached_dev_type
== FANOUT_DEV
||
1005 phy
->attached_dev_type
== EDGE_DEV
) &&
1006 phy
->routing_attr
== SUBTRACTIVE_ROUTING
) {
1009 sub_sas_addr
= &phy
->attached_sas_addr
[0];
1010 else if (SAS_ADDR(sub_sas_addr
) !=
1011 SAS_ADDR(phy
->attached_sas_addr
)) {
1013 SAS_DPRINTK("ex %016llx phy 0x%x "
1014 "diverges(%016llx) on subtractive "
1015 "boundary(%016llx). Disabled\n",
1016 SAS_ADDR(dev
->sas_addr
), i
,
1017 SAS_ADDR(phy
->attached_sas_addr
),
1018 SAS_ADDR(sub_sas_addr
));
1019 sas_ex_disable_phy(dev
, i
);
1026 static void sas_print_parent_topology_bug(struct domain_device
*child
,
1027 struct ex_phy
*parent_phy
,
1028 struct ex_phy
*child_phy
)
1030 static const char ra_char
[] = {
1031 [DIRECT_ROUTING
] = 'D',
1032 [SUBTRACTIVE_ROUTING
] = 'S',
1033 [TABLE_ROUTING
] = 'T',
1035 static const char *ex_type
[] = {
1036 [EDGE_DEV
] = "edge",
1037 [FANOUT_DEV
] = "fanout",
1039 struct domain_device
*parent
= child
->parent
;
1041 sas_printk("%s ex %016llx phy 0x%x <--> %s ex %016llx phy 0x%x "
1042 "has %c:%c routing link!\n",
1044 ex_type
[parent
->dev_type
],
1045 SAS_ADDR(parent
->sas_addr
),
1048 ex_type
[child
->dev_type
],
1049 SAS_ADDR(child
->sas_addr
),
1052 ra_char
[parent_phy
->routing_attr
],
1053 ra_char
[child_phy
->routing_attr
]);
1056 static int sas_check_eeds(struct domain_device
*child
,
1057 struct ex_phy
*parent_phy
,
1058 struct ex_phy
*child_phy
)
1061 struct domain_device
*parent
= child
->parent
;
1063 if (SAS_ADDR(parent
->port
->disc
.fanout_sas_addr
) != 0) {
1065 SAS_DPRINTK("edge ex %016llx phy S:0x%x <--> edge ex %016llx "
1066 "phy S:0x%x, while there is a fanout ex %016llx\n",
1067 SAS_ADDR(parent
->sas_addr
),
1069 SAS_ADDR(child
->sas_addr
),
1071 SAS_ADDR(parent
->port
->disc
.fanout_sas_addr
));
1072 } else if (SAS_ADDR(parent
->port
->disc
.eeds_a
) == 0) {
1073 memcpy(parent
->port
->disc
.eeds_a
, parent
->sas_addr
,
1075 memcpy(parent
->port
->disc
.eeds_b
, child
->sas_addr
,
1077 } else if (((SAS_ADDR(parent
->port
->disc
.eeds_a
) ==
1078 SAS_ADDR(parent
->sas_addr
)) ||
1079 (SAS_ADDR(parent
->port
->disc
.eeds_a
) ==
1080 SAS_ADDR(child
->sas_addr
)))
1082 ((SAS_ADDR(parent
->port
->disc
.eeds_b
) ==
1083 SAS_ADDR(parent
->sas_addr
)) ||
1084 (SAS_ADDR(parent
->port
->disc
.eeds_b
) ==
1085 SAS_ADDR(child
->sas_addr
))))
1089 SAS_DPRINTK("edge ex %016llx phy 0x%x <--> edge ex %016llx "
1090 "phy 0x%x link forms a third EEDS!\n",
1091 SAS_ADDR(parent
->sas_addr
),
1093 SAS_ADDR(child
->sas_addr
),
1100 /* Here we spill over 80 columns. It is intentional.
1102 static int sas_check_parent_topology(struct domain_device
*child
)
1104 struct expander_device
*child_ex
= &child
->ex_dev
;
1105 struct expander_device
*parent_ex
;
1112 if (child
->parent
->dev_type
!= EDGE_DEV
&&
1113 child
->parent
->dev_type
!= FANOUT_DEV
)
1116 parent_ex
= &child
->parent
->ex_dev
;
1118 for (i
= 0; i
< parent_ex
->num_phys
; i
++) {
1119 struct ex_phy
*parent_phy
= &parent_ex
->ex_phy
[i
];
1120 struct ex_phy
*child_phy
;
1122 if (parent_phy
->phy_state
== PHY_VACANT
||
1123 parent_phy
->phy_state
== PHY_NOT_PRESENT
)
1126 if (SAS_ADDR(parent_phy
->attached_sas_addr
) != SAS_ADDR(child
->sas_addr
))
1129 child_phy
= &child_ex
->ex_phy
[parent_phy
->attached_phy_id
];
1131 switch (child
->parent
->dev_type
) {
1133 if (child
->dev_type
== FANOUT_DEV
) {
1134 if (parent_phy
->routing_attr
!= SUBTRACTIVE_ROUTING
||
1135 child_phy
->routing_attr
!= TABLE_ROUTING
) {
1136 sas_print_parent_topology_bug(child
, parent_phy
, child_phy
);
1139 } else if (parent_phy
->routing_attr
== SUBTRACTIVE_ROUTING
) {
1140 if (child_phy
->routing_attr
== SUBTRACTIVE_ROUTING
) {
1141 res
= sas_check_eeds(child
, parent_phy
, child_phy
);
1142 } else if (child_phy
->routing_attr
!= TABLE_ROUTING
) {
1143 sas_print_parent_topology_bug(child
, parent_phy
, child_phy
);
1146 } else if (parent_phy
->routing_attr
== TABLE_ROUTING
&&
1147 child_phy
->routing_attr
!= SUBTRACTIVE_ROUTING
) {
1148 sas_print_parent_topology_bug(child
, parent_phy
, child_phy
);
1153 if (parent_phy
->routing_attr
!= TABLE_ROUTING
||
1154 child_phy
->routing_attr
!= SUBTRACTIVE_ROUTING
) {
1155 sas_print_parent_topology_bug(child
, parent_phy
, child_phy
);
1167 #define RRI_REQ_SIZE 16
1168 #define RRI_RESP_SIZE 44
1170 static int sas_configure_present(struct domain_device
*dev
, int phy_id
,
1171 u8
*sas_addr
, int *index
, int *present
)
1174 struct expander_device
*ex
= &dev
->ex_dev
;
1175 struct ex_phy
*phy
= &ex
->ex_phy
[phy_id
];
1182 rri_req
= alloc_smp_req(RRI_REQ_SIZE
);
1186 rri_resp
= alloc_smp_resp(RRI_RESP_SIZE
);
1192 rri_req
[1] = SMP_REPORT_ROUTE_INFO
;
1193 rri_req
[9] = phy_id
;
1195 for (i
= 0; i
< ex
->max_route_indexes
; i
++) {
1196 *(__be16
*)(rri_req
+6) = cpu_to_be16(i
);
1197 res
= smp_execute_task(dev
, rri_req
, RRI_REQ_SIZE
, rri_resp
,
1202 if (res
== SMP_RESP_NO_INDEX
) {
1203 SAS_DPRINTK("overflow of indexes: dev %016llx "
1204 "phy 0x%x index 0x%x\n",
1205 SAS_ADDR(dev
->sas_addr
), phy_id
, i
);
1207 } else if (res
!= SMP_RESP_FUNC_ACC
) {
1208 SAS_DPRINTK("%s: dev %016llx phy 0x%x index 0x%x "
1209 "result 0x%x\n", __FUNCTION__
,
1210 SAS_ADDR(dev
->sas_addr
), phy_id
, i
, res
);
1213 if (SAS_ADDR(sas_addr
) != 0) {
1214 if (SAS_ADDR(rri_resp
+16) == SAS_ADDR(sas_addr
)) {
1216 if ((rri_resp
[12] & 0x80) == 0x80)
1221 } else if (SAS_ADDR(rri_resp
+16) == 0) {
1226 } else if (SAS_ADDR(rri_resp
+16) == 0 &&
1227 phy
->last_da_index
< i
) {
1228 phy
->last_da_index
= i
;
1241 #define CRI_REQ_SIZE 44
1242 #define CRI_RESP_SIZE 8
1244 static int sas_configure_set(struct domain_device
*dev
, int phy_id
,
1245 u8
*sas_addr
, int index
, int include
)
1251 cri_req
= alloc_smp_req(CRI_REQ_SIZE
);
1255 cri_resp
= alloc_smp_resp(CRI_RESP_SIZE
);
1261 cri_req
[1] = SMP_CONF_ROUTE_INFO
;
1262 *(__be16
*)(cri_req
+6) = cpu_to_be16(index
);
1263 cri_req
[9] = phy_id
;
1264 if (SAS_ADDR(sas_addr
) == 0 || !include
)
1265 cri_req
[12] |= 0x80;
1266 memcpy(cri_req
+16, sas_addr
, SAS_ADDR_SIZE
);
1268 res
= smp_execute_task(dev
, cri_req
, CRI_REQ_SIZE
, cri_resp
,
1273 if (res
== SMP_RESP_NO_INDEX
) {
1274 SAS_DPRINTK("overflow of indexes: dev %016llx phy 0x%x "
1276 SAS_ADDR(dev
->sas_addr
), phy_id
, index
);
1284 static int sas_configure_phy(struct domain_device
*dev
, int phy_id
,
1285 u8
*sas_addr
, int include
)
1291 res
= sas_configure_present(dev
, phy_id
, sas_addr
, &index
, &present
);
1294 if (include
^ present
)
1295 return sas_configure_set(dev
, phy_id
, sas_addr
, index
,include
);
1301 * sas_configure_parent -- configure routing table of parent
1302 * parent: parent expander
1303 * child: child expander
1304 * sas_addr: SAS port identifier of device directly attached to child
1306 static int sas_configure_parent(struct domain_device
*parent
,
1307 struct domain_device
*child
,
1308 u8
*sas_addr
, int include
)
1310 struct expander_device
*ex_parent
= &parent
->ex_dev
;
1314 if (parent
->parent
) {
1315 res
= sas_configure_parent(parent
->parent
, parent
, sas_addr
,
1321 if (ex_parent
->conf_route_table
== 0) {
1322 SAS_DPRINTK("ex %016llx has self-configuring routing table\n",
1323 SAS_ADDR(parent
->sas_addr
));
1327 for (i
= 0; i
< ex_parent
->num_phys
; i
++) {
1328 struct ex_phy
*phy
= &ex_parent
->ex_phy
[i
];
1330 if ((phy
->routing_attr
== TABLE_ROUTING
) &&
1331 (SAS_ADDR(phy
->attached_sas_addr
) ==
1332 SAS_ADDR(child
->sas_addr
))) {
1333 res
= sas_configure_phy(parent
, i
, sas_addr
, include
);
1343 * sas_configure_routing -- configure routing
1344 * dev: expander device
1345 * sas_addr: port identifier of device directly attached to the expander device
1347 static int sas_configure_routing(struct domain_device
*dev
, u8
*sas_addr
)
1350 return sas_configure_parent(dev
->parent
, dev
, sas_addr
, 1);
1354 static int sas_disable_routing(struct domain_device
*dev
, u8
*sas_addr
)
1357 return sas_configure_parent(dev
->parent
, dev
, sas_addr
, 0);
1362 #define SMP_BIN_ATTR_NAME "smp_portal"
1364 static void sas_ex_smp_hook(struct domain_device
*dev
)
1366 struct expander_device
*ex_dev
= &dev
->ex_dev
;
1367 struct bin_attribute
*bin_attr
= &ex_dev
->smp_bin_attr
;
1369 memset(bin_attr
, 0, sizeof(*bin_attr
));
1371 bin_attr
->attr
.name
= SMP_BIN_ATTR_NAME
;
1372 bin_attr
->attr
.owner
= THIS_MODULE
;
1373 bin_attr
->attr
.mode
= 0600;
1376 bin_attr
->private = NULL
;
1377 bin_attr
->read
= smp_portal_read
;
1378 bin_attr
->write
= smp_portal_write
;
1379 bin_attr
->mmap
= NULL
;
1381 ex_dev
->smp_portal_pid
= -1;
1382 init_MUTEX(&ex_dev
->smp_sema
);
1387 * sas_discover_expander -- expander discovery
1388 * @ex: pointer to expander domain device
1390 * See comment in sas_discover_sata().
1392 static int sas_discover_expander(struct domain_device
*dev
)
1396 res
= sas_notify_lldd_dev_found(dev
);
1400 res
= sas_ex_general(dev
);
1403 res
= sas_ex_manuf_info(dev
);
1407 res
= sas_expander_discover(dev
);
1409 SAS_DPRINTK("expander %016llx discovery failed(0x%x)\n",
1410 SAS_ADDR(dev
->sas_addr
), res
);
1414 sas_check_ex_subtractive_boundary(dev
);
1415 res
= sas_check_parent_topology(dev
);
1420 sas_notify_lldd_dev_gone(dev
);
1424 static int sas_ex_level_discovery(struct asd_sas_port
*port
, const int level
)
1427 struct domain_device
*dev
;
1429 list_for_each_entry(dev
, &port
->dev_list
, dev_list_node
) {
1430 if (dev
->dev_type
== EDGE_DEV
||
1431 dev
->dev_type
== FANOUT_DEV
) {
1432 struct sas_expander_device
*ex
=
1433 rphy_to_expander_device(dev
->rphy
);
1435 if (level
== ex
->level
)
1436 res
= sas_ex_discover_devices(dev
, -1);
1438 res
= sas_ex_discover_devices(port
->port_dev
, -1);
1446 static int sas_ex_bfs_disc(struct asd_sas_port
*port
)
1452 level
= port
->disc
.max_level
;
1453 res
= sas_ex_level_discovery(port
, level
);
1455 } while (level
< port
->disc
.max_level
);
1460 int sas_discover_root_expander(struct domain_device
*dev
)
1463 struct sas_expander_device
*ex
= rphy_to_expander_device(dev
->rphy
);
1465 res
= sas_rphy_add(dev
->rphy
);
1469 ex
->level
= dev
->port
->disc
.max_level
; /* 0 */
1470 res
= sas_discover_expander(dev
);
1474 sas_ex_bfs_disc(dev
->port
);
1479 sas_rphy_remove(dev
->rphy
);
1484 /* ---------- Domain revalidation ---------- */
1486 static int sas_get_phy_discover(struct domain_device
*dev
,
1487 int phy_id
, struct smp_resp
*disc_resp
)
1492 disc_req
= alloc_smp_req(DISCOVER_REQ_SIZE
);
1496 disc_req
[1] = SMP_DISCOVER
;
1497 disc_req
[9] = phy_id
;
1499 res
= smp_execute_task(dev
, disc_req
, DISCOVER_REQ_SIZE
,
1500 disc_resp
, DISCOVER_RESP_SIZE
);
1503 else if (disc_resp
->result
!= SMP_RESP_FUNC_ACC
) {
1504 res
= disc_resp
->result
;
1512 static int sas_get_phy_change_count(struct domain_device
*dev
,
1513 int phy_id
, int *pcc
)
1516 struct smp_resp
*disc_resp
;
1518 disc_resp
= alloc_smp_resp(DISCOVER_RESP_SIZE
);
1522 res
= sas_get_phy_discover(dev
, phy_id
, disc_resp
);
1524 *pcc
= disc_resp
->disc
.change_count
;
1530 static int sas_get_phy_attached_sas_addr(struct domain_device
*dev
,
1531 int phy_id
, u8
*attached_sas_addr
)
1534 struct smp_resp
*disc_resp
;
1535 struct discover_resp
*dr
;
1537 disc_resp
= alloc_smp_resp(DISCOVER_RESP_SIZE
);
1540 dr
= &disc_resp
->disc
;
1542 res
= sas_get_phy_discover(dev
, phy_id
, disc_resp
);
1544 memcpy(attached_sas_addr
,disc_resp
->disc
.attached_sas_addr
,8);
1545 if (dr
->attached_dev_type
== 0)
1546 memset(attached_sas_addr
, 0, 8);
1552 static int sas_find_bcast_phy(struct domain_device
*dev
, int *phy_id
,
1555 struct expander_device
*ex
= &dev
->ex_dev
;
1559 for (i
= from_phy
; i
< ex
->num_phys
; i
++) {
1560 int phy_change_count
= 0;
1562 res
= sas_get_phy_change_count(dev
, i
, &phy_change_count
);
1565 else if (phy_change_count
!= ex
->ex_phy
[i
].phy_change_count
) {
1566 ex
->ex_phy
[i
].phy_change_count
= phy_change_count
;
1575 static int sas_get_ex_change_count(struct domain_device
*dev
, int *ecc
)
1579 struct smp_resp
*rg_resp
;
1581 rg_req
= alloc_smp_req(RG_REQ_SIZE
);
1585 rg_resp
= alloc_smp_resp(RG_RESP_SIZE
);
1591 rg_req
[1] = SMP_REPORT_GENERAL
;
1593 res
= smp_execute_task(dev
, rg_req
, RG_REQ_SIZE
, rg_resp
,
1597 if (rg_resp
->result
!= SMP_RESP_FUNC_ACC
) {
1598 res
= rg_resp
->result
;
1602 *ecc
= be16_to_cpu(rg_resp
->rg
.change_count
);
1609 static int sas_find_bcast_dev(struct domain_device
*dev
,
1610 struct domain_device
**src_dev
)
1612 struct expander_device
*ex
= &dev
->ex_dev
;
1613 int ex_change_count
= -1;
1616 res
= sas_get_ex_change_count(dev
, &ex_change_count
);
1619 if (ex_change_count
!= -1 &&
1620 ex_change_count
!= ex
->ex_change_count
) {
1622 ex
->ex_change_count
= ex_change_count
;
1624 struct domain_device
*ch
;
1626 list_for_each_entry(ch
, &ex
->children
, siblings
) {
1627 if (ch
->dev_type
== EDGE_DEV
||
1628 ch
->dev_type
== FANOUT_DEV
) {
1629 res
= sas_find_bcast_dev(ch
, src_dev
);
1639 static void sas_unregister_ex_tree(struct domain_device
*dev
)
1641 struct expander_device
*ex
= &dev
->ex_dev
;
1642 struct domain_device
*child
, *n
;
1644 list_for_each_entry_safe(child
, n
, &ex
->children
, siblings
) {
1645 if (child
->dev_type
== EDGE_DEV
||
1646 child
->dev_type
== FANOUT_DEV
)
1647 sas_unregister_ex_tree(child
);
1649 sas_unregister_dev(child
);
1651 sas_unregister_dev(dev
);
1654 static void sas_unregister_devs_sas_addr(struct domain_device
*parent
,
1657 struct expander_device
*ex_dev
= &parent
->ex_dev
;
1658 struct ex_phy
*phy
= &ex_dev
->ex_phy
[phy_id
];
1659 struct domain_device
*child
, *n
;
1661 list_for_each_entry_safe(child
, n
, &ex_dev
->children
, siblings
) {
1662 if (SAS_ADDR(child
->sas_addr
) ==
1663 SAS_ADDR(phy
->attached_sas_addr
)) {
1664 if (child
->dev_type
== EDGE_DEV
||
1665 child
->dev_type
== FANOUT_DEV
)
1666 sas_unregister_ex_tree(child
);
1668 sas_unregister_dev(child
);
1672 sas_disable_routing(parent
, phy
->attached_sas_addr
);
1673 memset(phy
->attached_sas_addr
, 0, SAS_ADDR_SIZE
);
1674 sas_port_delete_phy(phy
->port
, phy
->phy
);
1675 if (phy
->port
->num_phys
== 0)
1676 sas_port_delete(phy
->port
);
1680 static int sas_discover_bfs_by_root_level(struct domain_device
*root
,
1683 struct expander_device
*ex_root
= &root
->ex_dev
;
1684 struct domain_device
*child
;
1687 list_for_each_entry(child
, &ex_root
->children
, siblings
) {
1688 if (child
->dev_type
== EDGE_DEV
||
1689 child
->dev_type
== FANOUT_DEV
) {
1690 struct sas_expander_device
*ex
=
1691 rphy_to_expander_device(child
->rphy
);
1693 if (level
> ex
->level
)
1694 res
= sas_discover_bfs_by_root_level(child
,
1696 else if (level
== ex
->level
)
1697 res
= sas_ex_discover_devices(child
, -1);
1703 static int sas_discover_bfs_by_root(struct domain_device
*dev
)
1706 struct sas_expander_device
*ex
= rphy_to_expander_device(dev
->rphy
);
1707 int level
= ex
->level
+1;
1709 res
= sas_ex_discover_devices(dev
, -1);
1713 res
= sas_discover_bfs_by_root_level(dev
, level
);
1716 } while (level
<= dev
->port
->disc
.max_level
);
1721 static int sas_discover_new(struct domain_device
*dev
, int phy_id
)
1723 struct ex_phy
*ex_phy
= &dev
->ex_dev
.ex_phy
[phy_id
];
1724 struct domain_device
*child
;
1727 SAS_DPRINTK("ex %016llx phy%d new device attached\n",
1728 SAS_ADDR(dev
->sas_addr
), phy_id
);
1729 res
= sas_ex_phy_discover(dev
, phy_id
);
1732 res
= sas_ex_discover_devices(dev
, phy_id
);
1735 list_for_each_entry(child
, &dev
->ex_dev
.children
, siblings
) {
1736 if (SAS_ADDR(child
->sas_addr
) ==
1737 SAS_ADDR(ex_phy
->attached_sas_addr
)) {
1738 if (child
->dev_type
== EDGE_DEV
||
1739 child
->dev_type
== FANOUT_DEV
)
1740 res
= sas_discover_bfs_by_root(child
);
1748 static int sas_rediscover_dev(struct domain_device
*dev
, int phy_id
)
1750 struct expander_device
*ex
= &dev
->ex_dev
;
1751 struct ex_phy
*phy
= &ex
->ex_phy
[phy_id
];
1752 u8 attached_sas_addr
[8];
1755 res
= sas_get_phy_attached_sas_addr(dev
, phy_id
, attached_sas_addr
);
1757 case SMP_RESP_NO_PHY
:
1758 phy
->phy_state
= PHY_NOT_PRESENT
;
1759 sas_unregister_devs_sas_addr(dev
, phy_id
);
1761 case SMP_RESP_PHY_VACANT
:
1762 phy
->phy_state
= PHY_VACANT
;
1763 sas_unregister_devs_sas_addr(dev
, phy_id
);
1765 case SMP_RESP_FUNC_ACC
:
1769 if (SAS_ADDR(attached_sas_addr
) == 0) {
1770 phy
->phy_state
= PHY_EMPTY
;
1771 sas_unregister_devs_sas_addr(dev
, phy_id
);
1772 } else if (SAS_ADDR(attached_sas_addr
) ==
1773 SAS_ADDR(phy
->attached_sas_addr
)) {
1774 SAS_DPRINTK("ex %016llx phy 0x%x broadcast flutter\n",
1775 SAS_ADDR(dev
->sas_addr
), phy_id
);
1776 sas_ex_phy_discover(dev
, phy_id
);
1778 res
= sas_discover_new(dev
, phy_id
);
1783 static int sas_rediscover(struct domain_device
*dev
, const int phy_id
)
1785 struct expander_device
*ex
= &dev
->ex_dev
;
1786 struct ex_phy
*changed_phy
= &ex
->ex_phy
[phy_id
];
1790 SAS_DPRINTK("ex %016llx phy%d originated BROADCAST(CHANGE)\n",
1791 SAS_ADDR(dev
->sas_addr
), phy_id
);
1793 if (SAS_ADDR(changed_phy
->attached_sas_addr
) != 0) {
1794 for (i
= 0; i
< ex
->num_phys
; i
++) {
1795 struct ex_phy
*phy
= &ex
->ex_phy
[i
];
1799 if (SAS_ADDR(phy
->attached_sas_addr
) ==
1800 SAS_ADDR(changed_phy
->attached_sas_addr
)) {
1801 SAS_DPRINTK("phy%d part of wide port with "
1802 "phy%d\n", phy_id
, i
);
1806 res
= sas_rediscover_dev(dev
, phy_id
);
1808 res
= sas_discover_new(dev
, phy_id
);
1814 * sas_revalidate_domain -- revalidate the domain
1815 * @port: port to the domain of interest
1817 * NOTE: this process _must_ quit (return) as soon as any connection
1818 * errors are encountered. Connection recovery is done elsewhere.
1819 * Discover process only interrogates devices in order to discover the
1822 int sas_ex_revalidate_domain(struct domain_device
*port_dev
)
1825 struct domain_device
*dev
= NULL
;
1827 res
= sas_find_bcast_dev(port_dev
, &dev
);
1831 struct expander_device
*ex
= &dev
->ex_dev
;
1836 res
= sas_find_bcast_phy(dev
, &phy_id
, i
);
1839 res
= sas_rediscover(dev
, phy_id
);
1841 } while (i
< ex
->num_phys
);
1848 /* ---------- SMP portal ---------- */
1850 static ssize_t
smp_portal_write(struct kobject
*kobj
, char *buf
, loff_t offs
,
1853 struct domain_device
*dev
= to_dom_device(kobj
);
1854 struct expander_device
*ex
= &dev
->ex_dev
;
1861 down_interruptible(&ex
->smp_sema
);
1864 ex
->smp_req
= kzalloc(size
, GFP_USER
);
1869 memcpy(ex
->smp_req
, buf
, size
);
1870 ex
->smp_req_size
= size
;
1871 ex
->smp_portal_pid
= current
->pid
;
1877 static ssize_t
smp_portal_read(struct kobject
*kobj
, char *buf
, loff_t offs
,
1880 struct domain_device
*dev
= to_dom_device(kobj
);
1881 struct expander_device
*ex
= &dev
->ex_dev
;
1885 /* XXX: sysfs gives us an offset of 0x10 or 0x8 while in fact
1889 down_interruptible(&ex
->smp_sema
);
1890 if (!ex
->smp_req
|| ex
->smp_portal_pid
!= current
->pid
)
1898 smp_resp
= alloc_smp_resp(size
);
1901 res
= smp_execute_task(dev
, ex
->smp_req
, ex
->smp_req_size
,
1904 memcpy(buf
, smp_resp
, size
);
1912 ex
->smp_req_size
= 0;
1913 ex
->smp_portal_pid
= -1;