Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0+
2 : : /*
3 : : * A wrapper for multiple PHYs which passes all phy_* function calls to
4 : : * multiple (actual) PHY devices. This is comes handy when initializing
5 : : * all PHYs on a HCD and to keep them all in the same state.
6 : : *
7 : : * Copyright (C) 2018 Martin Blumenstingl <martin.blumenstingl@googlemail.com>
8 : : */
9 : :
10 : : #include <linux/device.h>
11 : : #include <linux/list.h>
12 : : #include <linux/phy/phy.h>
13 : : #include <linux/of.h>
14 : :
15 : : #include "phy.h"
16 : :
17 : : struct usb_phy_roothub {
18 : : struct phy *phy;
19 : : struct list_head list;
20 : : };
21 : :
22 : : static int usb_phy_roothub_add_phy(struct device *dev, int index,
23 : : struct list_head *list)
24 : : {
25 : : struct usb_phy_roothub *roothub_entry;
26 : : struct phy *phy;
27 : :
28 : : phy = devm_of_phy_get_by_index(dev, dev->of_node, index);
29 : : if (IS_ERR(phy)) {
30 : : if (PTR_ERR(phy) == -ENODEV)
31 : : return 0;
32 : : else
33 : : return PTR_ERR(phy);
34 : : }
35 : :
36 : : roothub_entry = devm_kzalloc(dev, sizeof(*roothub_entry), GFP_KERNEL);
37 : : if (!roothub_entry)
38 : : return -ENOMEM;
39 : :
40 : : INIT_LIST_HEAD(&roothub_entry->list);
41 : :
42 : : roothub_entry->phy = phy;
43 : :
44 : : list_add_tail(&roothub_entry->list, list);
45 : :
46 : : return 0;
47 : : }
48 : :
49 : 404 : struct usb_phy_roothub *usb_phy_roothub_alloc(struct device *dev)
50 : : {
51 : : struct usb_phy_roothub *phy_roothub;
52 : : int i, num_phys, err;
53 : :
54 : : if (!IS_ENABLED(CONFIG_GENERIC_PHY))
55 : : return NULL;
56 : :
57 : : num_phys = of_count_phandle_with_args(dev->of_node, "phys",
58 : : "#phy-cells");
59 : : if (num_phys <= 0)
60 : : return NULL;
61 : :
62 : : phy_roothub = devm_kzalloc(dev, sizeof(*phy_roothub), GFP_KERNEL);
63 : : if (!phy_roothub)
64 : : return ERR_PTR(-ENOMEM);
65 : :
66 : : INIT_LIST_HEAD(&phy_roothub->list);
67 : :
68 : : for (i = 0; i < num_phys; i++) {
69 : : err = usb_phy_roothub_add_phy(dev, i, &phy_roothub->list);
70 : : if (err)
71 : : return ERR_PTR(err);
72 : : }
73 : :
74 : : return phy_roothub;
75 : : }
76 : : EXPORT_SYMBOL_GPL(usb_phy_roothub_alloc);
77 : :
78 : 404 : int usb_phy_roothub_init(struct usb_phy_roothub *phy_roothub)
79 : : {
80 : : struct usb_phy_roothub *roothub_entry;
81 : : struct list_head *head;
82 : : int err;
83 : :
84 [ - + ]: 404 : if (!phy_roothub)
85 : : return 0;
86 : :
87 : 0 : head = &phy_roothub->list;
88 : :
89 [ # # ]: 0 : list_for_each_entry(roothub_entry, head, list) {
90 : 0 : err = phy_init(roothub_entry->phy);
91 [ # # ]: 0 : if (err)
92 : : goto err_exit_phys;
93 : : }
94 : :
95 : : return 0;
96 : :
97 : : err_exit_phys:
98 [ # # ]: 0 : list_for_each_entry_continue_reverse(roothub_entry, head, list)
99 : : phy_exit(roothub_entry->phy);
100 : :
101 : 0 : return err;
102 : : }
103 : : EXPORT_SYMBOL_GPL(usb_phy_roothub_init);
104 : :
105 : 0 : int usb_phy_roothub_exit(struct usb_phy_roothub *phy_roothub)
106 : : {
107 : : struct usb_phy_roothub *roothub_entry;
108 : : struct list_head *head;
109 : : int err, ret = 0;
110 : :
111 [ # # # # : 0 : if (!phy_roothub)
# # ]
112 : : return 0;
113 : :
114 : : head = &phy_roothub->list;
115 : :
116 [ # # # # : 0 : list_for_each_entry(roothub_entry, head, list) {
# # ]
117 : 0 : err = phy_exit(roothub_entry->phy);
118 [ # # # # ]: 0 : if (err)
119 : : ret = err;
120 : : }
121 : :
122 : 0 : return ret;
123 : : }
124 : : EXPORT_SYMBOL_GPL(usb_phy_roothub_exit);
125 : :
126 : 404 : int usb_phy_roothub_set_mode(struct usb_phy_roothub *phy_roothub,
127 : : enum phy_mode mode)
128 : : {
129 : : struct usb_phy_roothub *roothub_entry;
130 : : struct list_head *head;
131 : : int err;
132 : :
133 [ - + ]: 404 : if (!phy_roothub)
134 : : return 0;
135 : :
136 : 0 : head = &phy_roothub->list;
137 : :
138 [ # # ]: 0 : list_for_each_entry(roothub_entry, head, list) {
139 : 0 : err = phy_set_mode(roothub_entry->phy, mode);
140 [ # # ]: 0 : if (err)
141 : : goto err_out;
142 : : }
143 : :
144 : : return 0;
145 : :
146 : : err_out:
147 [ # # ]: 0 : list_for_each_entry_continue_reverse(roothub_entry, head, list)
148 : : phy_power_off(roothub_entry->phy);
149 : :
150 : 0 : return err;
151 : : }
152 : : EXPORT_SYMBOL_GPL(usb_phy_roothub_set_mode);
153 : :
154 : 404 : int usb_phy_roothub_calibrate(struct usb_phy_roothub *phy_roothub)
155 : : {
156 : : struct usb_phy_roothub *roothub_entry;
157 : : struct list_head *head;
158 : : int err;
159 : :
160 [ - + ]: 404 : if (!phy_roothub)
161 : : return 0;
162 : :
163 : : head = &phy_roothub->list;
164 : :
165 [ # # ]: 0 : list_for_each_entry(roothub_entry, head, list) {
166 : 0 : err = phy_calibrate(roothub_entry->phy);
167 [ # # ]: 0 : if (err)
168 : 0 : return err;
169 : : }
170 : :
171 : : return 0;
172 : : }
173 : : EXPORT_SYMBOL_GPL(usb_phy_roothub_calibrate);
174 : :
175 : 404 : int usb_phy_roothub_power_on(struct usb_phy_roothub *phy_roothub)
176 : : {
177 : : struct usb_phy_roothub *roothub_entry;
178 : : struct list_head *head;
179 : : int err;
180 : :
181 [ - + ]: 404 : if (!phy_roothub)
182 : : return 0;
183 : :
184 : 0 : head = &phy_roothub->list;
185 : :
186 [ # # ]: 0 : list_for_each_entry(roothub_entry, head, list) {
187 : 0 : err = phy_power_on(roothub_entry->phy);
188 [ # # ]: 0 : if (err)
189 : : goto err_out;
190 : : }
191 : :
192 : : return 0;
193 : :
194 : : err_out:
195 [ # # ]: 0 : list_for_each_entry_continue_reverse(roothub_entry, head, list)
196 : : phy_power_off(roothub_entry->phy);
197 : :
198 : 0 : return err;
199 : : }
200 : : EXPORT_SYMBOL_GPL(usb_phy_roothub_power_on);
201 : :
202 : 0 : void usb_phy_roothub_power_off(struct usb_phy_roothub *phy_roothub)
203 : : {
204 : : struct usb_phy_roothub *roothub_entry;
205 : :
206 [ # # # # ]: 0 : if (!phy_roothub)
207 : 0 : return;
208 : :
209 [ # # # # ]: 0 : list_for_each_entry_reverse(roothub_entry, &phy_roothub->list, list)
210 : : phy_power_off(roothub_entry->phy);
211 : : }
212 : : EXPORT_SYMBOL_GPL(usb_phy_roothub_power_off);
213 : :
214 : 0 : int usb_phy_roothub_suspend(struct device *controller_dev,
215 : : struct usb_phy_roothub *phy_roothub)
216 : : {
217 : : usb_phy_roothub_power_off(phy_roothub);
218 : :
219 : : /* keep the PHYs initialized so the device can wake up the system */
220 [ # # ]: 0 : if (device_may_wakeup(controller_dev))
221 : : return 0;
222 : :
223 : 0 : return usb_phy_roothub_exit(phy_roothub);
224 : : }
225 : : EXPORT_SYMBOL_GPL(usb_phy_roothub_suspend);
226 : :
227 : 0 : int usb_phy_roothub_resume(struct device *controller_dev,
228 : : struct usb_phy_roothub *phy_roothub)
229 : : {
230 : : int err;
231 : :
232 : : /* if the device can't wake up the system _exit was called */
233 [ # # ]: 0 : if (!device_may_wakeup(controller_dev)) {
234 : 0 : err = usb_phy_roothub_init(phy_roothub);
235 [ # # ]: 0 : if (err)
236 : : return err;
237 : : }
238 : :
239 : 0 : err = usb_phy_roothub_power_on(phy_roothub);
240 : :
241 : : /* undo _init if _power_on failed */
242 [ # # # # ]: 0 : if (err && !device_may_wakeup(controller_dev))
243 : : usb_phy_roothub_exit(phy_roothub);
244 : :
245 : : return err;
246 : : }
247 : : EXPORT_SYMBOL_GPL(usb_phy_roothub_resume);
|
