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, np: dev->of_node, index); |
29 | if (IS_ERR(ptr: phy)) { |
30 | if (PTR_ERR(ptr: phy) == -ENODEV) |
31 | return 0; |
32 | else |
33 | return PTR_ERR(ptr: phy); |
34 | } |
35 | |
36 | roothub_entry = devm_kzalloc(dev, size: sizeof(*roothub_entry), GFP_KERNEL); |
37 | if (!roothub_entry) |
38 | return -ENOMEM; |
39 | |
40 | INIT_LIST_HEAD(list: &roothub_entry->list); |
41 | |
42 | roothub_entry->phy = phy; |
43 | |
44 | list_add_tail(new: &roothub_entry->list, head: list); |
45 | |
46 | return 0; |
47 | } |
48 | |
49 | 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(np: dev->of_node, list_name: "phys" , |
58 | cells_name: "#phy-cells" ); |
59 | if (num_phys <= 0) |
60 | return NULL; |
61 | |
62 | phy_roothub = devm_kzalloc(dev, size: sizeof(*phy_roothub), GFP_KERNEL); |
63 | if (!phy_roothub) |
64 | return ERR_PTR(error: -ENOMEM); |
65 | |
66 | INIT_LIST_HEAD(list: &phy_roothub->list); |
67 | |
68 | for (i = 0; i < num_phys; i++) { |
69 | err = usb_phy_roothub_add_phy(dev, index: i, list: &phy_roothub->list); |
70 | if (err) |
71 | return ERR_PTR(error: err); |
72 | } |
73 | |
74 | return phy_roothub; |
75 | } |
76 | EXPORT_SYMBOL_GPL(usb_phy_roothub_alloc); |
77 | |
78 | 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 | if (!phy_roothub) |
85 | return 0; |
86 | |
87 | head = &phy_roothub->list; |
88 | |
89 | list_for_each_entry(roothub_entry, head, list) { |
90 | err = phy_init(phy: roothub_entry->phy); |
91 | if (err) |
92 | goto err_exit_phys; |
93 | } |
94 | |
95 | return 0; |
96 | |
97 | err_exit_phys: |
98 | list_for_each_entry_continue_reverse(roothub_entry, head, list) |
99 | phy_exit(phy: roothub_entry->phy); |
100 | |
101 | return err; |
102 | } |
103 | EXPORT_SYMBOL_GPL(usb_phy_roothub_init); |
104 | |
105 | 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 | if (!phy_roothub) |
112 | return 0; |
113 | |
114 | head = &phy_roothub->list; |
115 | |
116 | list_for_each_entry(roothub_entry, head, list) { |
117 | err = phy_exit(phy: roothub_entry->phy); |
118 | if (err) |
119 | ret = err; |
120 | } |
121 | |
122 | return ret; |
123 | } |
124 | EXPORT_SYMBOL_GPL(usb_phy_roothub_exit); |
125 | |
126 | 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 | if (!phy_roothub) |
134 | return 0; |
135 | |
136 | head = &phy_roothub->list; |
137 | |
138 | list_for_each_entry(roothub_entry, head, list) { |
139 | err = phy_set_mode(roothub_entry->phy, mode); |
140 | if (err) |
141 | goto err_out; |
142 | } |
143 | |
144 | return 0; |
145 | |
146 | err_out: |
147 | list_for_each_entry_continue_reverse(roothub_entry, head, list) |
148 | phy_power_off(phy: roothub_entry->phy); |
149 | |
150 | return err; |
151 | } |
152 | EXPORT_SYMBOL_GPL(usb_phy_roothub_set_mode); |
153 | |
154 | 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 | if (!phy_roothub) |
161 | return 0; |
162 | |
163 | head = &phy_roothub->list; |
164 | |
165 | list_for_each_entry(roothub_entry, head, list) { |
166 | err = phy_calibrate(phy: roothub_entry->phy); |
167 | if (err) |
168 | return err; |
169 | } |
170 | |
171 | return 0; |
172 | } |
173 | EXPORT_SYMBOL_GPL(usb_phy_roothub_calibrate); |
174 | |
175 | 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 | if (!phy_roothub) |
182 | return 0; |
183 | |
184 | head = &phy_roothub->list; |
185 | |
186 | list_for_each_entry(roothub_entry, head, list) { |
187 | err = phy_power_on(phy: roothub_entry->phy); |
188 | if (err) |
189 | goto err_out; |
190 | } |
191 | |
192 | return 0; |
193 | |
194 | err_out: |
195 | list_for_each_entry_continue_reverse(roothub_entry, head, list) |
196 | phy_power_off(phy: roothub_entry->phy); |
197 | |
198 | return err; |
199 | } |
200 | EXPORT_SYMBOL_GPL(usb_phy_roothub_power_on); |
201 | |
202 | void usb_phy_roothub_power_off(struct usb_phy_roothub *phy_roothub) |
203 | { |
204 | struct usb_phy_roothub *roothub_entry; |
205 | |
206 | if (!phy_roothub) |
207 | return; |
208 | |
209 | list_for_each_entry_reverse(roothub_entry, &phy_roothub->list, list) |
210 | phy_power_off(phy: roothub_entry->phy); |
211 | } |
212 | EXPORT_SYMBOL_GPL(usb_phy_roothub_power_off); |
213 | |
214 | 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 | if (device_may_wakeup(dev: controller_dev)) |
221 | return 0; |
222 | |
223 | return usb_phy_roothub_exit(phy_roothub); |
224 | } |
225 | EXPORT_SYMBOL_GPL(usb_phy_roothub_suspend); |
226 | |
227 | 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 | if (!device_may_wakeup(dev: controller_dev)) { |
234 | err = usb_phy_roothub_init(phy_roothub); |
235 | if (err) |
236 | return err; |
237 | } |
238 | |
239 | err = usb_phy_roothub_power_on(phy_roothub); |
240 | |
241 | /* undo _init if _power_on failed */ |
242 | if (err && !device_may_wakeup(dev: controller_dev)) |
243 | usb_phy_roothub_exit(phy_roothub); |
244 | |
245 | return err; |
246 | } |
247 | EXPORT_SYMBOL_GPL(usb_phy_roothub_resume); |
248 | |