Commit | Line | Data |
---|---|---|
289fcff4 HK |
1 | /** |
2 | * ulpi.c - USB ULPI PHY bus | |
3 | * | |
4 | * Copyright (C) 2015 Intel Corporation | |
5 | * | |
6 | * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify | |
9 | * it under the terms of the GNU General Public License version 2 as | |
10 | * published by the Free Software Foundation. | |
11 | */ | |
12 | ||
13 | #include <linux/ulpi/interface.h> | |
14 | #include <linux/ulpi/driver.h> | |
15 | #include <linux/ulpi/regs.h> | |
16 | #include <linux/module.h> | |
17 | #include <linux/slab.h> | |
18 | #include <linux/acpi.h> | |
19 | ||
20 | /* -------------------------------------------------------------------------- */ | |
21 | ||
22 | int ulpi_read(struct ulpi *ulpi, u8 addr) | |
23 | { | |
24 | return ulpi->ops->read(ulpi->ops, addr); | |
25 | } | |
26 | EXPORT_SYMBOL_GPL(ulpi_read); | |
27 | ||
28 | int ulpi_write(struct ulpi *ulpi, u8 addr, u8 val) | |
29 | { | |
30 | return ulpi->ops->write(ulpi->ops, addr, val); | |
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 | ||
42 | for (id = drv->id_table; id->vendor; id++) | |
43 | if (id->vendor == ulpi->id.vendor && | |
44 | id->product == ulpi->id.product) | |
45 | return 1; | |
46 | ||
47 | return 0; | |
48 | } | |
49 | ||
50 | static int ulpi_uevent(struct device *dev, struct kobj_uevent_env *env) | |
51 | { | |
52 | struct ulpi *ulpi = to_ulpi_dev(dev); | |
53 | ||
54 | if (add_uevent_var(env, "MODALIAS=ulpi:v%04xp%04x", | |
55 | ulpi->id.vendor, ulpi->id.product)) | |
56 | return -ENOMEM; | |
57 | return 0; | |
58 | } | |
59 | ||
60 | static int ulpi_probe(struct device *dev) | |
61 | { | |
62 | struct ulpi_driver *drv = to_ulpi_driver(dev->driver); | |
63 | ||
64 | return drv->probe(to_ulpi_dev(dev)); | |
65 | } | |
66 | ||
67 | static int ulpi_remove(struct device *dev) | |
68 | { | |
69 | struct ulpi_driver *drv = to_ulpi_driver(dev->driver); | |
70 | ||
71 | if (drv->remove) | |
72 | drv->remove(to_ulpi_dev(dev)); | |
73 | ||
74 | return 0; | |
75 | } | |
76 | ||
77 | static struct bus_type ulpi_bus = { | |
78 | .name = "ulpi", | |
79 | .match = ulpi_match, | |
80 | .uevent = ulpi_uevent, | |
81 | .probe = ulpi_probe, | |
82 | .remove = ulpi_remove, | |
83 | }; | |
84 | ||
85 | /* -------------------------------------------------------------------------- */ | |
86 | ||
87 | static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, | |
88 | char *buf) | |
89 | { | |
90 | struct ulpi *ulpi = to_ulpi_dev(dev); | |
91 | ||
92 | return sprintf(buf, "ulpi:v%04xp%04x\n", | |
93 | ulpi->id.vendor, ulpi->id.product); | |
94 | } | |
95 | static DEVICE_ATTR_RO(modalias); | |
96 | ||
97 | static struct attribute *ulpi_dev_attrs[] = { | |
98 | &dev_attr_modalias.attr, | |
99 | NULL | |
100 | }; | |
101 | ||
102 | static struct attribute_group ulpi_dev_attr_group = { | |
103 | .attrs = ulpi_dev_attrs, | |
104 | }; | |
105 | ||
106 | static const struct attribute_group *ulpi_dev_attr_groups[] = { | |
107 | &ulpi_dev_attr_group, | |
108 | NULL | |
109 | }; | |
110 | ||
111 | static void ulpi_dev_release(struct device *dev) | |
112 | { | |
113 | kfree(to_ulpi_dev(dev)); | |
114 | } | |
115 | ||
116 | static struct device_type ulpi_dev_type = { | |
117 | .name = "ulpi_device", | |
118 | .groups = ulpi_dev_attr_groups, | |
119 | .release = ulpi_dev_release, | |
120 | }; | |
121 | ||
122 | /* -------------------------------------------------------------------------- */ | |
123 | ||
124 | /** | |
125 | * ulpi_register_driver - register a driver with the ULPI bus | |
126 | * @drv: driver being registered | |
127 | * | |
128 | * Registers a driver with the ULPI bus. | |
129 | */ | |
130 | int ulpi_register_driver(struct ulpi_driver *drv) | |
131 | { | |
132 | if (!drv->probe) | |
133 | return -EINVAL; | |
134 | ||
135 | drv->driver.bus = &ulpi_bus; | |
136 | ||
137 | return driver_register(&drv->driver); | |
138 | } | |
139 | EXPORT_SYMBOL_GPL(ulpi_register_driver); | |
140 | ||
141 | /** | |
142 | * ulpi_unregister_driver - unregister a driver with the ULPI bus | |
143 | * @drv: driver to unregister | |
144 | * | |
145 | * Unregisters a driver with the ULPI bus. | |
146 | */ | |
147 | void ulpi_unregister_driver(struct ulpi_driver *drv) | |
148 | { | |
149 | driver_unregister(&drv->driver); | |
150 | } | |
151 | EXPORT_SYMBOL_GPL(ulpi_unregister_driver); | |
152 | ||
153 | /* -------------------------------------------------------------------------- */ | |
154 | ||
155 | static int ulpi_register(struct device *dev, struct ulpi *ulpi) | |
156 | { | |
157 | int ret; | |
158 | ||
159 | /* Test the interface */ | |
160 | ret = ulpi_write(ulpi, ULPI_SCRATCH, 0xaa); | |
161 | if (ret < 0) | |
162 | return ret; | |
163 | ||
164 | ret = ulpi_read(ulpi, ULPI_SCRATCH); | |
165 | if (ret < 0) | |
166 | return ret; | |
167 | ||
168 | if (ret != 0xaa) | |
169 | return -ENODEV; | |
170 | ||
171 | ulpi->id.vendor = ulpi_read(ulpi, ULPI_VENDOR_ID_LOW); | |
172 | ulpi->id.vendor |= ulpi_read(ulpi, ULPI_VENDOR_ID_HIGH) << 8; | |
173 | ||
174 | ulpi->id.product = ulpi_read(ulpi, ULPI_PRODUCT_ID_LOW); | |
175 | ulpi->id.product |= ulpi_read(ulpi, ULPI_PRODUCT_ID_HIGH) << 8; | |
176 | ||
177 | ulpi->dev.parent = dev; | |
178 | ulpi->dev.bus = &ulpi_bus; | |
179 | ulpi->dev.type = &ulpi_dev_type; | |
180 | dev_set_name(&ulpi->dev, "%s.ulpi", dev_name(dev)); | |
181 | ||
182 | ACPI_COMPANION_SET(&ulpi->dev, ACPI_COMPANION(dev)); | |
183 | ||
184 | request_module("ulpi:v%04xp%04x", ulpi->id.vendor, ulpi->id.product); | |
185 | ||
186 | ret = device_register(&ulpi->dev); | |
187 | if (ret) | |
188 | return ret; | |
189 | ||
190 | dev_dbg(&ulpi->dev, "registered ULPI PHY: vendor %04x, product %04x\n", | |
191 | ulpi->id.vendor, ulpi->id.product); | |
192 | ||
193 | return 0; | |
194 | } | |
195 | ||
196 | /** | |
197 | * ulpi_register_interface - instantiate new ULPI device | |
198 | * @dev: USB controller's device interface | |
199 | * @ops: ULPI register access | |
200 | * | |
201 | * Allocates and registers a ULPI device and an interface for it. Called from | |
202 | * the USB controller that provides the ULPI interface. | |
203 | */ | |
204 | struct ulpi *ulpi_register_interface(struct device *dev, struct ulpi_ops *ops) | |
205 | { | |
206 | struct ulpi *ulpi; | |
207 | int ret; | |
208 | ||
209 | ulpi = kzalloc(sizeof(*ulpi), GFP_KERNEL); | |
210 | if (!ulpi) | |
211 | return ERR_PTR(-ENOMEM); | |
212 | ||
213 | ulpi->ops = ops; | |
214 | ops->dev = dev; | |
215 | ||
216 | ret = ulpi_register(dev, ulpi); | |
217 | if (ret) { | |
218 | kfree(ulpi); | |
219 | return ERR_PTR(ret); | |
220 | } | |
221 | ||
222 | return ulpi; | |
223 | } | |
224 | EXPORT_SYMBOL_GPL(ulpi_register_interface); | |
225 | ||
226 | /** | |
227 | * ulpi_unregister_interface - unregister ULPI interface | |
228 | * @intrf: struct ulpi_interface | |
229 | * | |
230 | * Unregisters a ULPI device and it's interface that was created with | |
231 | * ulpi_create_interface(). | |
232 | */ | |
233 | void ulpi_unregister_interface(struct ulpi *ulpi) | |
234 | { | |
235 | device_unregister(&ulpi->dev); | |
236 | } | |
237 | EXPORT_SYMBOL_GPL(ulpi_unregister_interface); | |
238 | ||
239 | /* -------------------------------------------------------------------------- */ | |
240 | ||
241 | static int __init ulpi_init(void) | |
242 | { | |
243 | return bus_register(&ulpi_bus); | |
244 | } | |
4696b887 | 245 | subsys_initcall(ulpi_init); |
289fcff4 HK |
246 | |
247 | static void __exit ulpi_exit(void) | |
248 | { | |
249 | bus_unregister(&ulpi_bus); | |
250 | } | |
251 | module_exit(ulpi_exit); | |
252 | ||
253 | MODULE_AUTHOR("Intel Corporation"); | |
254 | MODULE_LICENSE("GPL v2"); | |
255 | MODULE_DESCRIPTION("USB ULPI PHY bus"); |