]>
Commit | Line | Data |
---|---|---|
5fd54ace | 1 | // SPDX-License-Identifier: GPL-2.0 |
246d7a11 | 2 | /* |
289fcff4 HK |
3 | * ulpi.c - USB ULPI PHY bus |
4 | * | |
5 | * Copyright (C) 2015 Intel Corporation | |
6 | * | |
7 | * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com> | |
289fcff4 HK |
8 | */ |
9 | ||
10 | #include <linux/ulpi/interface.h> | |
11 | #include <linux/ulpi/driver.h> | |
12 | #include <linux/ulpi/regs.h> | |
13 | #include <linux/module.h> | |
14 | #include <linux/slab.h> | |
15 | #include <linux/acpi.h> | |
ef6a7bcf SB |
16 | #include <linux/of.h> |
17 | #include <linux/of_device.h> | |
18 | #include <linux/clk/clk-conf.h> | |
289fcff4 HK |
19 | |
20 | /* -------------------------------------------------------------------------- */ | |
21 | ||
22 | int ulpi_read(struct ulpi *ulpi, u8 addr) | |
23 | { | |
e6f74849 | 24 | return ulpi->ops->read(ulpi->dev.parent, addr); |
289fcff4 HK |
25 | } |
26 | EXPORT_SYMBOL_GPL(ulpi_read); | |
27 | ||
28 | int ulpi_write(struct ulpi *ulpi, u8 addr, u8 val) | |
29 | { | |
e6f74849 | 30 | return ulpi->ops->write(ulpi->dev.parent, addr, val); |
289fcff4 HK |
31 | } |
32 | EXPORT_SYMBOL_GPL(ulpi_write); | |
33 | ||
34 | /* -------------------------------------------------------------------------- */ | |
35 | ||
36 | static int ulpi_match(struct device *dev, struct device_driver *driver) | |
37 | { | |
38 | struct ulpi_driver *drv = to_ulpi_driver(driver); | |
39 | struct ulpi *ulpi = to_ulpi_dev(dev); | |
40 | const struct ulpi_device_id *id; | |
41 | ||
ef6a7bcf SB |
42 | /* Some ULPI devices don't have a vendor id so rely on OF match */ |
43 | if (ulpi->id.vendor == 0) | |
44 | return of_driver_match_device(dev, driver); | |
45 | ||
289fcff4 HK |
46 | for (id = drv->id_table; id->vendor; id++) |
47 | if (id->vendor == ulpi->id.vendor && | |
48 | id->product == ulpi->id.product) | |
49 | return 1; | |
50 | ||
51 | return 0; | |
52 | } | |
53 | ||
54 | static int ulpi_uevent(struct device *dev, struct kobj_uevent_env *env) | |
55 | { | |
56 | struct ulpi *ulpi = to_ulpi_dev(dev); | |
ef6a7bcf SB |
57 | int ret; |
58 | ||
59 | ret = of_device_uevent_modalias(dev, env); | |
60 | if (ret != -ENODEV) | |
61 | return ret; | |
289fcff4 HK |
62 | |
63 | if (add_uevent_var(env, "MODALIAS=ulpi:v%04xp%04x", | |
64 | ulpi->id.vendor, ulpi->id.product)) | |
65 | return -ENOMEM; | |
66 | return 0; | |
67 | } | |
68 | ||
69 | static int ulpi_probe(struct device *dev) | |
70 | { | |
71 | struct ulpi_driver *drv = to_ulpi_driver(dev->driver); | |
ef6a7bcf SB |
72 | int ret; |
73 | ||
74 | ret = of_clk_set_defaults(dev->of_node, false); | |
75 | if (ret < 0) | |
76 | return ret; | |
289fcff4 HK |
77 | |
78 | return drv->probe(to_ulpi_dev(dev)); | |
79 | } | |
80 | ||
81 | static int ulpi_remove(struct device *dev) | |
82 | { | |
83 | struct ulpi_driver *drv = to_ulpi_driver(dev->driver); | |
84 | ||
85 | if (drv->remove) | |
86 | drv->remove(to_ulpi_dev(dev)); | |
87 | ||
88 | return 0; | |
89 | } | |
90 | ||
91 | static struct bus_type ulpi_bus = { | |
92 | .name = "ulpi", | |
93 | .match = ulpi_match, | |
94 | .uevent = ulpi_uevent, | |
95 | .probe = ulpi_probe, | |
96 | .remove = ulpi_remove, | |
97 | }; | |
98 | ||
99 | /* -------------------------------------------------------------------------- */ | |
100 | ||
101 | static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, | |
102 | char *buf) | |
103 | { | |
ef6a7bcf | 104 | int len; |
289fcff4 HK |
105 | struct ulpi *ulpi = to_ulpi_dev(dev); |
106 | ||
0634c295 | 107 | len = of_device_modalias(dev, buf, PAGE_SIZE); |
ef6a7bcf SB |
108 | if (len != -ENODEV) |
109 | return len; | |
110 | ||
289fcff4 HK |
111 | return sprintf(buf, "ulpi:v%04xp%04x\n", |
112 | ulpi->id.vendor, ulpi->id.product); | |
113 | } | |
114 | static DEVICE_ATTR_RO(modalias); | |
115 | ||
116 | static struct attribute *ulpi_dev_attrs[] = { | |
117 | &dev_attr_modalias.attr, | |
118 | NULL | |
119 | }; | |
120 | ||
52170e93 | 121 | static const struct attribute_group ulpi_dev_attr_group = { |
289fcff4 HK |
122 | .attrs = ulpi_dev_attrs, |
123 | }; | |
124 | ||
125 | static const struct attribute_group *ulpi_dev_attr_groups[] = { | |
126 | &ulpi_dev_attr_group, | |
127 | NULL | |
128 | }; | |
129 | ||
130 | static void ulpi_dev_release(struct device *dev) | |
131 | { | |
132 | kfree(to_ulpi_dev(dev)); | |
133 | } | |
134 | ||
53ec7f27 | 135 | static const struct device_type ulpi_dev_type = { |
289fcff4 HK |
136 | .name = "ulpi_device", |
137 | .groups = ulpi_dev_attr_groups, | |
138 | .release = ulpi_dev_release, | |
139 | }; | |
140 | ||
141 | /* -------------------------------------------------------------------------- */ | |
142 | ||
143 | /** | |
144 | * ulpi_register_driver - register a driver with the ULPI bus | |
145 | * @drv: driver being registered | |
246d7a11 | 146 | * @module: ends up being THIS_MODULE |
289fcff4 HK |
147 | * |
148 | * Registers a driver with the ULPI bus. | |
149 | */ | |
1ebe88d3 | 150 | int __ulpi_register_driver(struct ulpi_driver *drv, struct module *module) |
289fcff4 HK |
151 | { |
152 | if (!drv->probe) | |
153 | return -EINVAL; | |
154 | ||
1ebe88d3 | 155 | drv->driver.owner = module; |
289fcff4 HK |
156 | drv->driver.bus = &ulpi_bus; |
157 | ||
158 | return driver_register(&drv->driver); | |
159 | } | |
1ebe88d3 | 160 | EXPORT_SYMBOL_GPL(__ulpi_register_driver); |
289fcff4 HK |
161 | |
162 | /** | |
163 | * ulpi_unregister_driver - unregister a driver with the ULPI bus | |
164 | * @drv: driver to unregister | |
165 | * | |
166 | * Unregisters a driver with the ULPI bus. | |
167 | */ | |
168 | void ulpi_unregister_driver(struct ulpi_driver *drv) | |
169 | { | |
170 | driver_unregister(&drv->driver); | |
171 | } | |
172 | EXPORT_SYMBOL_GPL(ulpi_unregister_driver); | |
173 | ||
174 | /* -------------------------------------------------------------------------- */ | |
175 | ||
ef6a7bcf | 176 | static int ulpi_of_register(struct ulpi *ulpi) |
289fcff4 | 177 | { |
ef6a7bcf SB |
178 | struct device_node *np = NULL, *child; |
179 | struct device *parent; | |
180 | ||
181 | /* Find a ulpi bus underneath the parent or the grandparent */ | |
182 | parent = ulpi->dev.parent; | |
183 | if (parent->of_node) | |
33c309eb | 184 | np = of_get_child_by_name(parent->of_node, "ulpi"); |
ef6a7bcf | 185 | else if (parent->parent && parent->parent->of_node) |
33c309eb | 186 | np = of_get_child_by_name(parent->parent->of_node, "ulpi"); |
ef6a7bcf SB |
187 | if (!np) |
188 | return 0; | |
189 | ||
190 | child = of_get_next_available_child(np, NULL); | |
191 | of_node_put(np); | |
192 | if (!child) | |
193 | return -EINVAL; | |
289fcff4 | 194 | |
ef6a7bcf SB |
195 | ulpi->dev.of_node = child; |
196 | ||
197 | return 0; | |
198 | } | |
199 | ||
200 | static int ulpi_read_id(struct ulpi *ulpi) | |
201 | { | |
202 | int ret; | |
51b0ce38 | 203 | |
289fcff4 HK |
204 | /* Test the interface */ |
205 | ret = ulpi_write(ulpi, ULPI_SCRATCH, 0xaa); | |
206 | if (ret < 0) | |
ef6a7bcf | 207 | goto err; |
289fcff4 HK |
208 | |
209 | ret = ulpi_read(ulpi, ULPI_SCRATCH); | |
210 | if (ret < 0) | |
211 | return ret; | |
212 | ||
213 | if (ret != 0xaa) | |
ef6a7bcf | 214 | goto err; |
289fcff4 HK |
215 | |
216 | ulpi->id.vendor = ulpi_read(ulpi, ULPI_VENDOR_ID_LOW); | |
217 | ulpi->id.vendor |= ulpi_read(ulpi, ULPI_VENDOR_ID_HIGH) << 8; | |
218 | ||
219 | ulpi->id.product = ulpi_read(ulpi, ULPI_PRODUCT_ID_LOW); | |
220 | ulpi->id.product |= ulpi_read(ulpi, ULPI_PRODUCT_ID_HIGH) << 8; | |
221 | ||
ef6a7bcf SB |
222 | /* Some ULPI devices don't have a vendor id so rely on OF match */ |
223 | if (ulpi->id.vendor == 0) | |
224 | goto err; | |
225 | ||
226 | request_module("ulpi:v%04xp%04x", ulpi->id.vendor, ulpi->id.product); | |
227 | return 0; | |
228 | err: | |
229 | of_device_request_module(&ulpi->dev); | |
230 | return 0; | |
231 | } | |
232 | ||
233 | static int ulpi_register(struct device *dev, struct ulpi *ulpi) | |
234 | { | |
235 | int ret; | |
236 | ||
237 | ulpi->dev.parent = dev; /* needed early for ops */ | |
289fcff4 HK |
238 | ulpi->dev.bus = &ulpi_bus; |
239 | ulpi->dev.type = &ulpi_dev_type; | |
240 | dev_set_name(&ulpi->dev, "%s.ulpi", dev_name(dev)); | |
241 | ||
242 | ACPI_COMPANION_SET(&ulpi->dev, ACPI_COMPANION(dev)); | |
243 | ||
ef6a7bcf SB |
244 | ret = ulpi_of_register(ulpi); |
245 | if (ret) | |
246 | return ret; | |
247 | ||
248 | ret = ulpi_read_id(ulpi); | |
249 | if (ret) | |
250 | return ret; | |
289fcff4 HK |
251 | |
252 | ret = device_register(&ulpi->dev); | |
253 | if (ret) | |
254 | return ret; | |
255 | ||
256 | dev_dbg(&ulpi->dev, "registered ULPI PHY: vendor %04x, product %04x\n", | |
257 | ulpi->id.vendor, ulpi->id.product); | |
258 | ||
259 | return 0; | |
260 | } | |
261 | ||
262 | /** | |
263 | * ulpi_register_interface - instantiate new ULPI device | |
264 | * @dev: USB controller's device interface | |
265 | * @ops: ULPI register access | |
266 | * | |
267 | * Allocates and registers a ULPI device and an interface for it. Called from | |
268 | * the USB controller that provides the ULPI interface. | |
269 | */ | |
b9454f90 TS |
270 | struct ulpi *ulpi_register_interface(struct device *dev, |
271 | const struct ulpi_ops *ops) | |
289fcff4 HK |
272 | { |
273 | struct ulpi *ulpi; | |
274 | int ret; | |
275 | ||
276 | ulpi = kzalloc(sizeof(*ulpi), GFP_KERNEL); | |
277 | if (!ulpi) | |
278 | return ERR_PTR(-ENOMEM); | |
279 | ||
280 | ulpi->ops = ops; | |
289fcff4 HK |
281 | |
282 | ret = ulpi_register(dev, ulpi); | |
283 | if (ret) { | |
284 | kfree(ulpi); | |
285 | return ERR_PTR(ret); | |
286 | } | |
287 | ||
288 | return ulpi; | |
289 | } | |
290 | EXPORT_SYMBOL_GPL(ulpi_register_interface); | |
291 | ||
292 | /** | |
293 | * ulpi_unregister_interface - unregister ULPI interface | |
246d7a11 | 294 | * @ulpi: struct ulpi_interface |
289fcff4 HK |
295 | * |
296 | * Unregisters a ULPI device and it's interface that was created with | |
297 | * ulpi_create_interface(). | |
298 | */ | |
299 | void ulpi_unregister_interface(struct ulpi *ulpi) | |
300 | { | |
ef6a7bcf | 301 | of_node_put(ulpi->dev.of_node); |
289fcff4 HK |
302 | device_unregister(&ulpi->dev); |
303 | } | |
304 | EXPORT_SYMBOL_GPL(ulpi_unregister_interface); | |
305 | ||
306 | /* -------------------------------------------------------------------------- */ | |
307 | ||
308 | static int __init ulpi_init(void) | |
309 | { | |
310 | return bus_register(&ulpi_bus); | |
311 | } | |
4696b887 | 312 | subsys_initcall(ulpi_init); |
289fcff4 HK |
313 | |
314 | static void __exit ulpi_exit(void) | |
315 | { | |
316 | bus_unregister(&ulpi_bus); | |
317 | } | |
318 | module_exit(ulpi_exit); | |
319 | ||
320 | MODULE_AUTHOR("Intel Corporation"); | |
321 | MODULE_LICENSE("GPL v2"); | |
322 | MODULE_DESCRIPTION("USB ULPI PHY bus"); |