Home | History | Annotate | Line # | Download | only in fdt
fdt_port.c revision 1.1
      1 /*	$NetBSD: fdt_port.c,v 1.1 2018/04/03 12:40:20 bouyer Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 2018 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by Manuel Bouyer.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29  * POSSIBILITY OF SUCH DAMAGE.
     30  */
     31 
     32 /*
     33  * ports and endpoints management. from
     34  * linux/Documentation/devicetree/bindings/graph.txt
     35  * Given a device and its node, it enumerates all ports and endpoints for this
     36  * device, and register connections with the remote endpoints.
     37  */
     38 
     39 #include <sys/cdefs.h>
     40 
     41 __KERNEL_RCSID(1, "$NetBSD: fdt_port.c,v 1.1 2018/04/03 12:40:20 bouyer Exp $");
     42 
     43 #include <sys/param.h>
     44 #include <sys/systm.h>
     45 #include <sys/device.h>
     46 #include <sys/bus.h>
     47 #include <sys/kmem.h>
     48 
     49 #include <dev/fdt/fdtvar.h>
     50 #include <dev/fdt/fdt_port.h>
     51 
     52 struct fdt_endpoint;
     53 
     54 struct fdt_port {
     55 	int	port_id;
     56 	int	port_phandle; /* port's node */
     57 	struct fdt_endpoint *port_ep; /* this port's endpoints */
     58 	int	port_nep; /* number of endpoints for this port */
     59 	struct fdt_device_ports *port_dp; /* this port's device */
     60 };
     61 
     62 struct fdt_endpoint {
     63 	int		ep_id;
     64 	enum endpoint_type ep_type;
     65 	int		ep_phandle;
     66 	struct fdt_port	*ep_port; /* parent of this endpoint */
     67 	int		ep_rphandle; /* report endpoint */
     68 	struct fdt_endpoint *ep_rep;
     69 	bool		ep_active;
     70 	bool		ep_enabled;
     71 };
     72 
     73 SLIST_HEAD(, fdt_device_ports) fdt_port_devices =
     74     SLIST_HEAD_INITIALIZER(&fdt_port_devices);
     75 
     76 static void fdt_endpoints_register(int, struct fdt_port *, enum endpoint_type);
     77 static const char *ep_name(struct fdt_endpoint *, char *, int);
     78 
     79 struct fdt_endpoint *
     80 fdt_endpoint_get_from_phandle(int rphandle)
     81 {
     82 	struct fdt_device_ports *ports;
     83 	int p, e;
     84 
     85 	if (rphandle < 0)
     86 		return NULL;
     87 
     88 	SLIST_FOREACH(ports, &fdt_port_devices, dp_list) {
     89 		for (p = 0; p < ports->dp_nports; p++) {
     90 			struct fdt_port *port = &ports->dp_port[p];
     91 			for (e = 0; e < port->port_nep; e++) {
     92 				struct fdt_endpoint *ep = &port->port_ep[e];
     93 				if (ep->ep_phandle == rphandle)
     94 					return ep;
     95 			}
     96 		}
     97 	}
     98 	return NULL;
     99 
    100 }
    101 
    102 struct fdt_endpoint *
    103 fdt_endpoint_get_from_index(struct fdt_device_ports *device_ports,
    104     int port_index, int ep_index)
    105 {
    106 	int p, e;
    107 	for (p = 0; p < device_ports->dp_nports; p++) {
    108 		struct fdt_port *port = &device_ports->dp_port[p];
    109 		if (port->port_id != port_index)
    110 			continue;
    111 		for (e = 0; e < port->port_nep; e++) {
    112 			struct fdt_endpoint *ep = &port->port_ep[e];
    113 			if (ep->ep_id == ep_index) {
    114 				return ep;
    115 			}
    116 		}
    117 	}
    118 	return NULL;
    119 }
    120 
    121 struct fdt_endpoint *
    122 fdt_endpoint_remote(struct fdt_endpoint *ep)
    123 {
    124 	return ep->ep_rep;
    125 }
    126 
    127 int
    128 fdt_endpoint_port_index(struct fdt_endpoint *ep)
    129 {
    130 	return ep->ep_port->port_id;
    131 }
    132 
    133 int
    134 fdt_endpoint_index(struct fdt_endpoint *ep)
    135 {
    136 	return ep->ep_id;
    137 }
    138 
    139 device_t
    140 fdt_endpoint_device(struct fdt_endpoint *ep)
    141 {
    142 	return ep->ep_port->port_dp->dp_dev;
    143 }
    144 
    145 bool
    146 fdt_endpoint_is_active(struct fdt_endpoint *ep)
    147 {
    148 	return ep->ep_active;
    149 }
    150 
    151 bool
    152 fdt_endpoint_is_enabled(struct fdt_endpoint *ep)
    153 {
    154 	return ep->ep_enabled;
    155 }
    156 
    157 int
    158 fdt_endpoint_activate(struct fdt_endpoint *ep, bool activate)
    159 {
    160 	struct fdt_endpoint *rep = fdt_endpoint_remote(ep);
    161 	struct fdt_device_ports *rdp;
    162 	int error = 0;
    163 
    164 	if (rep == NULL)
    165 		return ENODEV;
    166 
    167 	KASSERT(ep->ep_active == rep->ep_active);
    168 	KASSERT(ep->ep_enabled == rep->ep_enabled);
    169 	if (!activate && ep->ep_enabled)
    170 		return EBUSY;
    171 
    172 	rdp = rep->ep_port->port_dp;
    173 	if (rdp->dp_ep_activate)
    174 		error = rdp->dp_ep_activate(rdp->dp_dev, rep, activate);
    175 
    176 	if (error == 0)
    177 		rep->ep_active = ep->ep_active = activate;
    178 	return error;
    179 }
    180 
    181 int
    182 fdt_endpoint_enable(struct fdt_endpoint *ep, bool enable)
    183 {
    184 	struct fdt_endpoint *rep = fdt_endpoint_remote(ep);
    185 	struct fdt_device_ports *rdp;
    186 	int error = 0;
    187 
    188 	if (rep == NULL)
    189 		return EINVAL;
    190 
    191 	KASSERT(ep->ep_active == rep->ep_active);
    192 	KASSERT(ep->ep_enabled == rep->ep_enabled);
    193 	if (ep->ep_active == false)
    194 		return EINVAL;
    195 
    196 	rdp = rep->ep_port->port_dp;
    197 	if (rdp->dp_ep_enable)
    198 		error = rdp->dp_ep_enable(rdp->dp_dev, rep, enable);
    199 
    200 	if (error == 0)
    201 		rep->ep_enabled = ep->ep_enabled = enable;
    202 	return error;
    203 }
    204 
    205 void *
    206 fdt_endpoint_get_data(struct fdt_endpoint *ep)
    207 {
    208 	struct fdt_device_ports *dp = ep->ep_port->port_dp;
    209 
    210 	if (dp->dp_ep_get_data)
    211 		return dp->dp_ep_get_data(dp->dp_dev, ep);
    212 
    213 	return NULL;
    214 }
    215 
    216 int
    217 fdt_ports_register(struct fdt_device_ports *ports, device_t self,
    218     int phandle, enum endpoint_type type)
    219 {
    220 	int port_phandle, child;
    221 	int i;
    222 	char buf[20];
    223 	uint64_t id;
    224 
    225 	ports->dp_dev = self;
    226 	SLIST_INSERT_HEAD(&fdt_port_devices, ports, dp_list);
    227 
    228 	/*
    229 	 * walk the childs looking for ports. ports may be grouped under
    230 	 * an optional ports node
    231 	 */
    232 	port_phandle = phandle;
    233 again:
    234 	ports->dp_nports = 0;
    235 	for (child = OF_child(port_phandle); child; child = OF_peer(child)) {
    236 		if (OF_getprop(child, "name", buf, sizeof(buf)) <= 0)
    237 			continue;
    238 		if (strcmp(buf, "ports") == 0) {
    239 			port_phandle = child;
    240 			goto again;
    241 		}
    242 		if (strcmp(buf, "port") != 0)
    243 			continue;
    244 		ports->dp_nports++;
    245 	}
    246 	if (ports->dp_nports == 0)
    247 		return 0;
    248 
    249 	ports->dp_port =
    250 	    kmem_zalloc(sizeof(struct fdt_port) * ports->dp_nports, KM_SLEEP);
    251 	KASSERT(ports->dp_port != NULL);
    252 	/* now scan again ports, looking for endpoints */
    253 	for (child = OF_child(port_phandle), i = 0; child;
    254 	    child = OF_peer(child)) {
    255 		if (OF_getprop(child, "name", buf, sizeof(buf)) <= 0)
    256 			continue;
    257 		if (strcmp(buf, "ports") == 0) {
    258 			panic("fdt_ports_register: undetected ports");
    259 		}
    260 		if (strcmp(buf, "port") != 0)
    261 			continue;
    262 		if (fdtbus_get_reg64(child, 0, &id, NULL) != 0) {
    263 			if (ports->dp_nports > 1)
    264 				aprint_error_dev(self,
    265 				    "%s: missing reg property",
    266 				    fdtbus_get_string(child, "name"));
    267 			id = i;
    268 		}
    269 		ports->dp_port[i].port_id = id;
    270 		ports->dp_port[i].port_phandle = child;
    271 		ports->dp_port[i].port_dp = ports;
    272 		fdt_endpoints_register(child, &ports->dp_port[i], type);
    273 		i++;
    274 	}
    275 	KASSERT(i == ports->dp_nports);
    276 	return 0;
    277 }
    278 
    279 
    280 static void
    281 fdt_endpoints_register(int phandle, struct fdt_port *port,
    282     enum endpoint_type type)
    283 {
    284 	int child;
    285 	int i;
    286 	char buf[128];
    287 	uint64_t id;
    288 	struct fdt_endpoint *ep, *rep;
    289 	struct fdt_device_ports *dp;
    290 
    291 	port->port_nep = 0;
    292 	for (child = OF_child(phandle); child; child = OF_peer(child)) {
    293 		if (OF_getprop(child, "name", buf, sizeof(buf)) <= 0)
    294 			continue;
    295 		if (strcmp(buf, "endpoint") != 0)
    296 			continue;
    297 		port->port_nep++;
    298 	}
    299 	if (port->port_nep == 0) {
    300 		port->port_ep = NULL;
    301 		return;
    302 	}
    303 
    304 	port->port_ep =
    305 	    kmem_zalloc(sizeof(struct fdt_endpoint) * port->port_nep, KM_SLEEP);
    306 	KASSERT(port->port_ep != NULL);
    307 	/* now scan again ports, looking for endpoints */
    308 	for (child = OF_child(phandle), i = 0; child; child = OF_peer(child)) {
    309 		if (OF_getprop(child, "name", buf, sizeof(buf)) <= 0)
    310 			continue;
    311 		if (strcmp(buf, "endpoint") != 0)
    312 			continue;
    313 		if (fdtbus_get_reg64(child, 0, &id, NULL) != 0) {
    314 			if (port->port_nep > 1)
    315 				aprint_error_dev(port->port_dp->dp_dev,
    316 				    "%s: missing reg property",
    317 				    fdtbus_get_string(child, "name"));
    318 			id = i;
    319 		}
    320 		ep = &port->port_ep[i];
    321 		ep->ep_id = id;
    322 		ep->ep_type = type;
    323 		ep->ep_phandle = child;
    324 		ep->ep_port = port;
    325 		ep->ep_rphandle = fdtbus_get_phandle(child, "remote-endpoint");
    326 		ep->ep_rep = fdt_endpoint_get_from_phandle(
    327 		    port->port_ep[i].ep_rphandle);
    328 		rep = ep->ep_rep;
    329 		if (rep != NULL && rep->ep_rep != NULL) {
    330 			aprint_error("%s: ", ep_name(ep, buf, sizeof(buf)));
    331 			aprint_error("remote endpoint %s ",
    332 			    ep_name(rep, buf, sizeof(buf)));
    333 			aprint_error("already connected to %s\n",
    334 			    ep_name(rep->ep_rep, buf, sizeof(buf)));
    335 		} else if (rep != NULL) {
    336 			rep->ep_rep = ep;
    337 			rep->ep_rphandle = child;
    338 			aprint_verbose("%s ", ep_name(ep, buf, sizeof(buf)));
    339 			aprint_verbose("connected to %s\n",
    340 			    ep_name(rep, buf, sizeof(buf)));
    341 			if (rep->ep_type == EP_OTHER)
    342 				rep->ep_type = ep->ep_type;
    343 			else if (ep->ep_type == EP_OTHER)
    344 				ep->ep_type = rep->ep_type;
    345 			dp = port->port_dp;
    346 			if (dp->dp_ep_connect)
    347 				dp->dp_ep_connect(dp->dp_dev, ep, true);
    348 			dp = rep->ep_port->port_dp;
    349 			if (dp->dp_ep_connect)
    350 				dp->dp_ep_connect(dp->dp_dev, rep, true);
    351 		}
    352 		i++;
    353 	}
    354 	KASSERT(i == port->port_nep);
    355 }
    356 
    357 static const char *
    358 ep_name(struct fdt_endpoint *ep, char *buf, int size)
    359 {
    360 	int a;
    361 
    362 	a = snprintf(&buf[0], size, "%s",
    363 	    device_xname(ep->ep_port->port_dp->dp_dev));
    364 	if (ep->ep_port->port_id >= 0 && a < size)
    365 		a += snprintf(&buf[a], size - a, " port %d",
    366 		    ep->ep_port->port_id);
    367 	if (ep->ep_id >= 0 && a < size)
    368 		snprintf(&buf[a], size - a, " endpoint %d", ep->ep_id);
    369 	return buf;
    370 }
    371