xref: /freebsd-12.1/sys/dev/extres/phy/phy.c (revision 514bfd46) 
1 /*-
2  * Copyright 2016 Michal Meloun <[email protected]>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  */
26 
27  #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
29 
30 #include "opt_platform.h"
31 #include <sys/param.h>
32 #include <sys/kernel.h>
33 #include <sys/kobj.h>
34 #include <sys/lock.h>
35 #include <sys/malloc.h>
36 #include <sys/queue.h>
37 #include <sys/systm.h>
38 #include <sys/sx.h>
39 
40 #ifdef FDT
41 #include <dev/ofw/ofw_bus.h>
42 #include <dev/ofw/ofw_bus_subr.h>
43 #endif
44 
45 #include  <dev/extres/phy/phy.h>
46 #include  <dev/extres/phy/phy_internal.h>
47 
48 #include "phydev_if.h"
49 
50 MALLOC_DEFINE(M_PHY, "phy", "Phy framework");
51 
52 /* Default phy methods. */
53 static int phynode_method_init(struct phynode *phynode);
54 static int phynode_method_enable(struct phynode *phynode, bool disable);
55 static int phynode_method_status(struct phynode *phynode, int *status);
56 
57 
58 /*
59  * Phy controller methods.
60  */
61 static phynode_method_t phynode_methods[] = {
62 	PHYNODEMETHOD(phynode_init,		phynode_method_init),
63 	PHYNODEMETHOD(phynode_enable,		phynode_method_enable),
64 	PHYNODEMETHOD(phynode_status,		phynode_method_status),
65 
66 	PHYNODEMETHOD_END
67 };
68 DEFINE_CLASS_0(phynode, phynode_class, phynode_methods, 0);
69 
70 static phynode_list_t phynode_list = TAILQ_HEAD_INITIALIZER(phynode_list);
71 struct sx phynode_topo_lock;
72 SX_SYSINIT(phy_topology, &phynode_topo_lock, "Phy topology lock");
73 
74 /* ----------------------------------------------------------------------------
75  *
76  * Default phy methods for base class.
77  *
78  */
79 
80 static int
81 phynode_method_init(struct phynode *phynode)
82 {
83 
84 	return (0);
85 }
86 
87 static int
88 phynode_method_enable(struct phynode *phynode, bool enable)
89 {
90 
91 	if (!enable)
92 		return (ENXIO);
93 
94 	return (0);
95 }
96 
97 static int
98 phynode_method_status(struct phynode *phynode, int *status)
99 {
100 	*status = PHY_STATUS_ENABLED;
101 	return (0);
102 }
103 
104 /* ----------------------------------------------------------------------------
105  *
106  * Internal functions.
107  *
108  */
109 /*
110  * Create and initialize phy object, but do not register it.
111  */
112 struct phynode *
113 phynode_create(device_t pdev, phynode_class_t phynode_class,
114     struct phynode_init_def *def)
115 {
116 	struct phynode *phynode;
117 
118 
119 	/* Create object and initialize it. */
120 	phynode = malloc(sizeof(struct phynode), M_PHY, M_WAITOK | M_ZERO);
121 	kobj_init((kobj_t)phynode, (kobj_class_t)phynode_class);
122 	sx_init(&phynode->lock, "Phy node lock");
123 
124 	/* Allocate softc if required. */
125 	if (phynode_class->size > 0) {
126 		phynode->softc = malloc(phynode_class->size, M_PHY,
127 		    M_WAITOK | M_ZERO);
128 	}
129 
130 	/* Rest of init. */
131 	TAILQ_INIT(&phynode->consumers_list);
132 	phynode->id = def->id;
133 	phynode->pdev = pdev;
134 #ifdef FDT
135 	phynode->ofw_node = def->ofw_node;
136 #endif
137 
138 	return (phynode);
139 }
140 
141 /* Register phy object. */
142 struct phynode *
143 phynode_register(struct phynode *phynode)
144 {
145 	int rv;
146 
147 #ifdef FDT
148 	if (phynode->ofw_node <= 0)
149 		phynode->ofw_node = ofw_bus_get_node(phynode->pdev);
150 	if (phynode->ofw_node <= 0)
151 		return (NULL);
152 #endif
153 
154 	rv = PHYNODE_INIT(phynode);
155 	if (rv != 0) {
156 		printf("PHYNODE_INIT failed: %d\n", rv);
157 		return (NULL);
158 	}
159 
160 	PHY_TOPO_XLOCK();
161 	TAILQ_INSERT_TAIL(&phynode_list, phynode, phylist_link);
162 	PHY_TOPO_UNLOCK();
163 #ifdef FDT
164 	OF_device_register_xref(OF_xref_from_node(phynode->ofw_node),
165 	    phynode->pdev);
166 #endif
167 	return (phynode);
168 }
169 
170 static struct phynode *
171 phynode_find_by_id(device_t dev, intptr_t id)
172 {
173 	struct phynode *entry;
174 
175 	PHY_TOPO_ASSERT();
176 
177 	TAILQ_FOREACH(entry, &phynode_list, phylist_link) {
178 		if ((entry->pdev == dev) && (entry->id ==  id))
179 			return (entry);
180 	}
181 
182 	return (NULL);
183 }
184 
185 /* --------------------------------------------------------------------------
186  *
187  * Phy providers interface
188  *
189  */
190 
191 void *
192 phynode_get_softc(struct phynode *phynode)
193 {
194 
195 	return (phynode->softc);
196 }
197 
198 device_t
199 phynode_get_device(struct phynode *phynode)
200 {
201 
202 	return (phynode->pdev);
203 }
204 
205 intptr_t phynode_get_id(struct phynode *phynode)
206 {
207 
208 	return (phynode->id);
209 }
210 
211 #ifdef FDT
212 phandle_t
213 phynode_get_ofw_node(struct phynode *phynode)
214 {
215 
216 	return (phynode->ofw_node);
217 }
218 #endif
219 
220 /* --------------------------------------------------------------------------
221  *
222  * Real consumers executive
223  *
224  */
225 
226 /*
227  * Enable phy.
228  */
229 int
230 phynode_enable(struct phynode *phynode)
231 {
232 	int rv;
233 
234 	PHY_TOPO_ASSERT();
235 
236 	PHYNODE_XLOCK(phynode);
237 	if (phynode->enable_cnt == 0) {
238 		rv = PHYNODE_ENABLE(phynode, true);
239 		if (rv != 0) {
240 			PHYNODE_UNLOCK(phynode);
241 			return (rv);
242 		}
243 	}
244 	phynode->enable_cnt++;
245 	PHYNODE_UNLOCK(phynode);
246 	return (0);
247 }
248 
249 /*
250  * Disable phy.
251  */
252 int
253 phynode_disable(struct phynode *phynode)
254 {
255 	int rv;
256 
257 	PHY_TOPO_ASSERT();
258 
259 	PHYNODE_XLOCK(phynode);
260 	if (phynode->enable_cnt == 1) {
261 		rv = PHYNODE_ENABLE(phynode, false);
262 		if (rv != 0) {
263 			PHYNODE_UNLOCK(phynode);
264 			return (rv);
265 		}
266 	}
267 	phynode->enable_cnt--;
268 	PHYNODE_UNLOCK(phynode);
269 	return (0);
270 }
271 
272 
273 /*
274  * Get phy status. (PHY_STATUS_*)
275  */
276 int
277 phynode_status(struct phynode *phynode, int *status)
278 {
279 	int rv;
280 
281 	PHY_TOPO_ASSERT();
282 
283 	PHYNODE_XLOCK(phynode);
284 	rv = PHYNODE_STATUS(phynode, status);
285 	PHYNODE_UNLOCK(phynode);
286 	return (rv);
287 }
288 
289  /* --------------------------------------------------------------------------
290  *
291  * Phy consumers interface.
292  *
293  */
294 
295 /* Helper function for phy_get*() */
296 static phy_t
297 phy_create(struct phynode *phynode, device_t cdev)
298 {
299 	struct phy *phy;
300 
301 	PHY_TOPO_ASSERT();
302 
303 	phy =  malloc(sizeof(struct phy), M_PHY, M_WAITOK | M_ZERO);
304 	phy->cdev = cdev;
305 	phy->phynode = phynode;
306 	phy->enable_cnt = 0;
307 
308 	PHYNODE_XLOCK(phynode);
309 	phynode->ref_cnt++;
310 	TAILQ_INSERT_TAIL(&phynode->consumers_list, phy, link);
311 	PHYNODE_UNLOCK(phynode);
312 
313 	return (phy);
314 }
315 
316 int
317 phy_enable(phy_t phy)
318 {
319 	int rv;
320 	struct phynode *phynode;
321 
322 	phynode = phy->phynode;
323 	KASSERT(phynode->ref_cnt > 0,
324 	    ("Attempt to access unreferenced phy.\n"));
325 
326 	PHY_TOPO_SLOCK();
327 	rv = phynode_enable(phynode);
328 	if (rv == 0)
329 		phy->enable_cnt++;
330 	PHY_TOPO_UNLOCK();
331 	return (rv);
332 }
333 
334 int
335 phy_disable(phy_t phy)
336 {
337 	int rv;
338 	struct phynode *phynode;
339 
340 	phynode = phy->phynode;
341 	KASSERT(phynode->ref_cnt > 0,
342 	   ("Attempt to access unreferenced phy.\n"));
343 	KASSERT(phy->enable_cnt > 0,
344 	   ("Attempt to disable already disabled phy.\n"));
345 
346 	PHY_TOPO_SLOCK();
347 	rv = phynode_disable(phynode);
348 	if (rv == 0)
349 		phy->enable_cnt--;
350 	PHY_TOPO_UNLOCK();
351 	return (rv);
352 }
353 
354 int
355 phy_status(phy_t phy, int *status)
356 {
357 	int rv;
358 	struct phynode *phynode;
359 
360 	phynode = phy->phynode;
361 	KASSERT(phynode->ref_cnt > 0,
362 	   ("Attempt to access unreferenced phy.\n"));
363 
364 	PHY_TOPO_SLOCK();
365 	rv = phynode_status(phynode, status);
366 	PHY_TOPO_UNLOCK();
367 	return (rv);
368 }
369 
370 int
371 phy_get_by_id(device_t consumer_dev, device_t provider_dev, intptr_t id,
372     phy_t *phy)
373 {
374 	struct phynode *phynode;
375 
376 	PHY_TOPO_SLOCK();
377 
378 	phynode = phynode_find_by_id(provider_dev, id);
379 	if (phynode == NULL) {
380 		PHY_TOPO_UNLOCK();
381 		return (ENODEV);
382 	}
383 	*phy = phy_create(phynode, consumer_dev);
384 	PHY_TOPO_UNLOCK();
385 
386 	return (0);
387 }
388 
389 void
390 phy_release(phy_t phy)
391 {
392 	struct phynode *phynode;
393 
394 	phynode = phy->phynode;
395 	KASSERT(phynode->ref_cnt > 0,
396 	   ("Attempt to access unreferenced phy.\n"));
397 
398 	PHY_TOPO_SLOCK();
399 	while (phy->enable_cnt > 0) {
400 		phynode_disable(phynode);
401 		phy->enable_cnt--;
402 	}
403 	PHYNODE_XLOCK(phynode);
404 	TAILQ_REMOVE(&phynode->consumers_list, phy, link);
405 	phynode->ref_cnt--;
406 	PHYNODE_UNLOCK(phynode);
407 	PHY_TOPO_UNLOCK();
408 
409 	free(phy, M_PHY);
410 }
411 
412 #ifdef FDT
413 int phydev_default_ofw_map(device_t provider, phandle_t xref, int ncells,
414     pcell_t *cells, intptr_t *id)
415 {
416 	struct phynode *entry;
417 	phandle_t node;
418 
419 	/* Single device can register multiple subnodes. */
420 	if (ncells == 0) {
421 
422 		node = OF_node_from_xref(xref);
423 		PHY_TOPO_XLOCK();
424 		TAILQ_FOREACH(entry, &phynode_list, phylist_link) {
425 			if ((entry->pdev == provider) &&
426 			    (entry->ofw_node == node)) {
427 				*id = entry->id;
428 				PHY_TOPO_UNLOCK();
429 				return (0);
430 			}
431 		}
432 		PHY_TOPO_UNLOCK();
433 		return (ERANGE);
434 	}
435 
436 	/* First cell is ID. */
437 	if (ncells == 1) {
438 		*id = cells[0];
439 		return (0);
440 	}
441 
442 	/* No default way how to get ID, custom mapper is required. */
443 	return  (ERANGE);
444 }
445 
446 int
447 phy_get_by_ofw_idx(device_t consumer_dev, phandle_t cnode, int idx, phy_t *phy)
448 {
449 	phandle_t xnode;
450 	pcell_t *cells;
451 	device_t phydev;
452 	int ncells, rv;
453 	intptr_t id;
454 
455 	if (cnode <= 0)
456 		cnode = ofw_bus_get_node(consumer_dev);
457 	if (cnode <= 0) {
458 		device_printf(consumer_dev,
459 		    "%s called on not ofw based device\n", __func__);
460 		return (ENXIO);
461 	}
462 	rv = ofw_bus_parse_xref_list_alloc(cnode, "phys", "#phy-cells", idx,
463 	    &xnode, &ncells, &cells);
464 	if (rv != 0)
465 		return (rv);
466 
467 	/* Tranlate provider to device. */
468 	phydev = OF_device_from_xref(xnode);
469 	if (phydev == NULL) {
470 		OF_prop_free(cells);
471 		return (ENODEV);
472 	}
473 	/* Map phy to number. */
474 	rv = PHYDEV_MAP(phydev, xnode, ncells, cells, &id);
475 	OF_prop_free(cells);
476 	if (rv != 0)
477 		return (rv);
478 
479 	return (phy_get_by_id(consumer_dev, phydev, id, phy));
480 }
481 
482 int
483 phy_get_by_ofw_name(device_t consumer_dev, phandle_t cnode, char *name,
484     phy_t *phy)
485 {
486 	int rv, idx;
487 
488 	if (cnode <= 0)
489 		cnode = ofw_bus_get_node(consumer_dev);
490 	if (cnode <= 0) {
491 		device_printf(consumer_dev,
492 		    "%s called on not ofw based device\n",  __func__);
493 		return (ENXIO);
494 	}
495 	rv = ofw_bus_find_string_index(cnode, "phy-names", name, &idx);
496 	if (rv != 0)
497 		return (rv);
498 	return (phy_get_by_ofw_idx(consumer_dev, cnode, idx, phy));
499 }
500 
501 int
502 phy_get_by_ofw_property(device_t consumer_dev, phandle_t cnode, char *name,
503     phy_t *phy)
504 {
505 	pcell_t *cells;
506 	device_t phydev;
507 	int ncells, rv;
508 	intptr_t id;
509 
510 	if (cnode <= 0)
511 		cnode = ofw_bus_get_node(consumer_dev);
512 	if (cnode <= 0) {
513 		device_printf(consumer_dev,
514 		    "%s called on not ofw based device\n", __func__);
515 		return (ENXIO);
516 	}
517 	ncells = OF_getencprop_alloc_multi(cnode, name, sizeof(pcell_t),
518 	    (void **)&cells);
519 	if (ncells < 1)
520 		return (ENOENT);
521 
522 	/* Tranlate provider to device. */
523 	phydev = OF_device_from_xref(cells[0]);
524 	if (phydev == NULL) {
525 		OF_prop_free(cells);
526 		return (ENODEV);
527 	}
528 	/* Map phy to number. */
529 	rv = PHYDEV_MAP(phydev, cells[0], ncells - 1 , cells + 1, &id);
530 	OF_prop_free(cells);
531 	if (rv != 0)
532 		return (rv);
533 
534 	return (phy_get_by_id(consumer_dev, phydev, id, phy));
535 }
536 #endif
537