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