Loading...
1/*
2 * phy.c -- USB phy handling
3 *
4 * Copyright (C) 2004-2013 Texas Instruments
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 */
11#include <linux/kernel.h>
12#include <linux/export.h>
13#include <linux/err.h>
14#include <linux/device.h>
15#include <linux/module.h>
16#include <linux/slab.h>
17#include <linux/of.h>
18
19#include <linux/usb/phy.h>
20
21static LIST_HEAD(phy_list);
22static LIST_HEAD(phy_bind_list);
23static DEFINE_SPINLOCK(phy_lock);
24
25struct phy_devm {
26 struct usb_phy *phy;
27 struct notifier_block *nb;
28};
29
30static struct usb_phy *__usb_find_phy(struct list_head *list,
31 enum usb_phy_type type)
32{
33 struct usb_phy *phy = NULL;
34
35 list_for_each_entry(phy, list, head) {
36 if (phy->type != type)
37 continue;
38
39 return phy;
40 }
41
42 return ERR_PTR(-ENODEV);
43}
44
45static struct usb_phy *__usb_find_phy_dev(struct device *dev,
46 struct list_head *list, u8 index)
47{
48 struct usb_phy_bind *phy_bind = NULL;
49
50 list_for_each_entry(phy_bind, list, list) {
51 if (!(strcmp(phy_bind->dev_name, dev_name(dev))) &&
52 phy_bind->index == index) {
53 if (phy_bind->phy)
54 return phy_bind->phy;
55 else
56 return ERR_PTR(-EPROBE_DEFER);
57 }
58 }
59
60 return ERR_PTR(-ENODEV);
61}
62
63static struct usb_phy *__of_usb_find_phy(struct device_node *node)
64{
65 struct usb_phy *phy;
66
67 if (!of_device_is_available(node))
68 return ERR_PTR(-ENODEV);
69
70 list_for_each_entry(phy, &phy_list, head) {
71 if (node != phy->dev->of_node)
72 continue;
73
74 return phy;
75 }
76
77 return ERR_PTR(-EPROBE_DEFER);
78}
79
80static void devm_usb_phy_release(struct device *dev, void *res)
81{
82 struct usb_phy *phy = *(struct usb_phy **)res;
83
84 usb_put_phy(phy);
85}
86
87static void devm_usb_phy_release2(struct device *dev, void *_res)
88{
89 struct phy_devm *res = _res;
90
91 if (res->nb)
92 usb_unregister_notifier(res->phy, res->nb);
93 usb_put_phy(res->phy);
94}
95
96static int devm_usb_phy_match(struct device *dev, void *res, void *match_data)
97{
98 struct usb_phy **phy = res;
99
100 return *phy == match_data;
101}
102
103/**
104 * devm_usb_get_phy - find the USB PHY
105 * @dev - device that requests this phy
106 * @type - the type of the phy the controller requires
107 *
108 * Gets the phy using usb_get_phy(), and associates a device with it using
109 * devres. On driver detach, release function is invoked on the devres data,
110 * then, devres data is freed.
111 *
112 * For use by USB host and peripheral drivers.
113 */
114struct usb_phy *devm_usb_get_phy(struct device *dev, enum usb_phy_type type)
115{
116 struct usb_phy **ptr, *phy;
117
118 ptr = devres_alloc(devm_usb_phy_release, sizeof(*ptr), GFP_KERNEL);
119 if (!ptr)
120 return ERR_PTR(-ENOMEM);
121
122 phy = usb_get_phy(type);
123 if (!IS_ERR(phy)) {
124 *ptr = phy;
125 devres_add(dev, ptr);
126 } else
127 devres_free(ptr);
128
129 return phy;
130}
131EXPORT_SYMBOL_GPL(devm_usb_get_phy);
132
133/**
134 * usb_get_phy - find the USB PHY
135 * @type - the type of the phy the controller requires
136 *
137 * Returns the phy driver, after getting a refcount to it; or
138 * -ENODEV if there is no such phy. The caller is responsible for
139 * calling usb_put_phy() to release that count.
140 *
141 * For use by USB host and peripheral drivers.
142 */
143struct usb_phy *usb_get_phy(enum usb_phy_type type)
144{
145 struct usb_phy *phy = NULL;
146 unsigned long flags;
147
148 spin_lock_irqsave(&phy_lock, flags);
149
150 phy = __usb_find_phy(&phy_list, type);
151 if (IS_ERR(phy) || !try_module_get(phy->dev->driver->owner)) {
152 pr_debug("PHY: unable to find transceiver of type %s\n",
153 usb_phy_type_string(type));
154 if (!IS_ERR(phy))
155 phy = ERR_PTR(-ENODEV);
156
157 goto err0;
158 }
159
160 get_device(phy->dev);
161
162err0:
163 spin_unlock_irqrestore(&phy_lock, flags);
164
165 return phy;
166}
167EXPORT_SYMBOL_GPL(usb_get_phy);
168
169/**
170 * devm_usb_get_phy_by_node - find the USB PHY by device_node
171 * @dev - device that requests this phy
172 * @node - the device_node for the phy device.
173 * @nb - a notifier_block to register with the phy.
174 *
175 * Returns the phy driver associated with the given device_node,
176 * after getting a refcount to it, -ENODEV if there is no such phy or
177 * -EPROBE_DEFER if the device is not yet loaded. While at that, it
178 * also associates the device with
179 * the phy using devres. On driver detach, release function is invoked
180 * on the devres data, then, devres data is freed.
181 *
182 * For use by peripheral drivers for devices related to a phy,
183 * such as a charger.
184 */
185struct usb_phy *devm_usb_get_phy_by_node(struct device *dev,
186 struct device_node *node,
187 struct notifier_block *nb)
188{
189 struct usb_phy *phy = ERR_PTR(-ENOMEM);
190 struct phy_devm *ptr;
191 unsigned long flags;
192
193 ptr = devres_alloc(devm_usb_phy_release2, sizeof(*ptr), GFP_KERNEL);
194 if (!ptr) {
195 dev_dbg(dev, "failed to allocate memory for devres\n");
196 goto err0;
197 }
198
199 spin_lock_irqsave(&phy_lock, flags);
200
201 phy = __of_usb_find_phy(node);
202 if (IS_ERR(phy)) {
203 devres_free(ptr);
204 goto err1;
205 }
206
207 if (!try_module_get(phy->dev->driver->owner)) {
208 phy = ERR_PTR(-ENODEV);
209 devres_free(ptr);
210 goto err1;
211 }
212 if (nb)
213 usb_register_notifier(phy, nb);
214 ptr->phy = phy;
215 ptr->nb = nb;
216 devres_add(dev, ptr);
217
218 get_device(phy->dev);
219
220err1:
221 spin_unlock_irqrestore(&phy_lock, flags);
222
223err0:
224
225 return phy;
226}
227EXPORT_SYMBOL_GPL(devm_usb_get_phy_by_node);
228
229/**
230 * devm_usb_get_phy_by_phandle - find the USB PHY by phandle
231 * @dev - device that requests this phy
232 * @phandle - name of the property holding the phy phandle value
233 * @index - the index of the phy
234 *
235 * Returns the phy driver associated with the given phandle value,
236 * after getting a refcount to it, -ENODEV if there is no such phy or
237 * -EPROBE_DEFER if there is a phandle to the phy, but the device is
238 * not yet loaded. While at that, it also associates the device with
239 * the phy using devres. On driver detach, release function is invoked
240 * on the devres data, then, devres data is freed.
241 *
242 * For use by USB host and peripheral drivers.
243 */
244struct usb_phy *devm_usb_get_phy_by_phandle(struct device *dev,
245 const char *phandle, u8 index)
246{
247 struct device_node *node;
248 struct usb_phy *phy;
249
250 if (!dev->of_node) {
251 dev_dbg(dev, "device does not have a device node entry\n");
252 return ERR_PTR(-EINVAL);
253 }
254
255 node = of_parse_phandle(dev->of_node, phandle, index);
256 if (!node) {
257 dev_dbg(dev, "failed to get %s phandle in %s node\n", phandle,
258 dev->of_node->full_name);
259 return ERR_PTR(-ENODEV);
260 }
261 phy = devm_usb_get_phy_by_node(dev, node, NULL);
262 of_node_put(node);
263 return phy;
264}
265EXPORT_SYMBOL_GPL(devm_usb_get_phy_by_phandle);
266
267/**
268 * usb_get_phy_dev - find the USB PHY
269 * @dev - device that requests this phy
270 * @index - the index of the phy
271 *
272 * Returns the phy driver, after getting a refcount to it; or
273 * -ENODEV if there is no such phy. The caller is responsible for
274 * calling usb_put_phy() to release that count.
275 *
276 * For use by USB host and peripheral drivers.
277 */
278struct usb_phy *usb_get_phy_dev(struct device *dev, u8 index)
279{
280 struct usb_phy *phy = NULL;
281 unsigned long flags;
282
283 spin_lock_irqsave(&phy_lock, flags);
284
285 phy = __usb_find_phy_dev(dev, &phy_bind_list, index);
286 if (IS_ERR(phy) || !try_module_get(phy->dev->driver->owner)) {
287 dev_dbg(dev, "unable to find transceiver\n");
288 if (!IS_ERR(phy))
289 phy = ERR_PTR(-ENODEV);
290
291 goto err0;
292 }
293
294 get_device(phy->dev);
295
296err0:
297 spin_unlock_irqrestore(&phy_lock, flags);
298
299 return phy;
300}
301EXPORT_SYMBOL_GPL(usb_get_phy_dev);
302
303/**
304 * devm_usb_get_phy_dev - find the USB PHY using device ptr and index
305 * @dev - device that requests this phy
306 * @index - the index of the phy
307 *
308 * Gets the phy using usb_get_phy_dev(), and associates a device with it using
309 * devres. On driver detach, release function is invoked on the devres data,
310 * then, devres data is freed.
311 *
312 * For use by USB host and peripheral drivers.
313 */
314struct usb_phy *devm_usb_get_phy_dev(struct device *dev, u8 index)
315{
316 struct usb_phy **ptr, *phy;
317
318 ptr = devres_alloc(devm_usb_phy_release, sizeof(*ptr), GFP_KERNEL);
319 if (!ptr)
320 return NULL;
321
322 phy = usb_get_phy_dev(dev, index);
323 if (!IS_ERR(phy)) {
324 *ptr = phy;
325 devres_add(dev, ptr);
326 } else
327 devres_free(ptr);
328
329 return phy;
330}
331EXPORT_SYMBOL_GPL(devm_usb_get_phy_dev);
332
333/**
334 * devm_usb_put_phy - release the USB PHY
335 * @dev - device that wants to release this phy
336 * @phy - the phy returned by devm_usb_get_phy()
337 *
338 * destroys the devres associated with this phy and invokes usb_put_phy
339 * to release the phy.
340 *
341 * For use by USB host and peripheral drivers.
342 */
343void devm_usb_put_phy(struct device *dev, struct usb_phy *phy)
344{
345 int r;
346
347 r = devres_destroy(dev, devm_usb_phy_release, devm_usb_phy_match, phy);
348 dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
349}
350EXPORT_SYMBOL_GPL(devm_usb_put_phy);
351
352/**
353 * usb_put_phy - release the USB PHY
354 * @x: the phy returned by usb_get_phy()
355 *
356 * Releases a refcount the caller received from usb_get_phy().
357 *
358 * For use by USB host and peripheral drivers.
359 */
360void usb_put_phy(struct usb_phy *x)
361{
362 if (x) {
363 struct module *owner = x->dev->driver->owner;
364
365 put_device(x->dev);
366 module_put(owner);
367 }
368}
369EXPORT_SYMBOL_GPL(usb_put_phy);
370
371/**
372 * usb_add_phy - declare the USB PHY
373 * @x: the USB phy to be used; or NULL
374 * @type - the type of this PHY
375 *
376 * This call is exclusively for use by phy drivers, which
377 * coordinate the activities of drivers for host and peripheral
378 * controllers, and in some cases for VBUS current regulation.
379 */
380int usb_add_phy(struct usb_phy *x, enum usb_phy_type type)
381{
382 int ret = 0;
383 unsigned long flags;
384 struct usb_phy *phy;
385
386 if (x->type != USB_PHY_TYPE_UNDEFINED) {
387 dev_err(x->dev, "not accepting initialized PHY %s\n", x->label);
388 return -EINVAL;
389 }
390
391 ATOMIC_INIT_NOTIFIER_HEAD(&x->notifier);
392
393 spin_lock_irqsave(&phy_lock, flags);
394
395 list_for_each_entry(phy, &phy_list, head) {
396 if (phy->type == type) {
397 ret = -EBUSY;
398 dev_err(x->dev, "transceiver type %s already exists\n",
399 usb_phy_type_string(type));
400 goto out;
401 }
402 }
403
404 x->type = type;
405 list_add_tail(&x->head, &phy_list);
406
407out:
408 spin_unlock_irqrestore(&phy_lock, flags);
409 return ret;
410}
411EXPORT_SYMBOL_GPL(usb_add_phy);
412
413/**
414 * usb_add_phy_dev - declare the USB PHY
415 * @x: the USB phy to be used; or NULL
416 *
417 * This call is exclusively for use by phy drivers, which
418 * coordinate the activities of drivers for host and peripheral
419 * controllers, and in some cases for VBUS current regulation.
420 */
421int usb_add_phy_dev(struct usb_phy *x)
422{
423 struct usb_phy_bind *phy_bind;
424 unsigned long flags;
425
426 if (!x->dev) {
427 dev_err(x->dev, "no device provided for PHY\n");
428 return -EINVAL;
429 }
430
431 ATOMIC_INIT_NOTIFIER_HEAD(&x->notifier);
432
433 spin_lock_irqsave(&phy_lock, flags);
434 list_for_each_entry(phy_bind, &phy_bind_list, list)
435 if (!(strcmp(phy_bind->phy_dev_name, dev_name(x->dev))))
436 phy_bind->phy = x;
437
438 list_add_tail(&x->head, &phy_list);
439
440 spin_unlock_irqrestore(&phy_lock, flags);
441 return 0;
442}
443EXPORT_SYMBOL_GPL(usb_add_phy_dev);
444
445/**
446 * usb_remove_phy - remove the OTG PHY
447 * @x: the USB OTG PHY to be removed;
448 *
449 * This reverts the effects of usb_add_phy
450 */
451void usb_remove_phy(struct usb_phy *x)
452{
453 unsigned long flags;
454 struct usb_phy_bind *phy_bind;
455
456 spin_lock_irqsave(&phy_lock, flags);
457 if (x) {
458 list_for_each_entry(phy_bind, &phy_bind_list, list)
459 if (phy_bind->phy == x)
460 phy_bind->phy = NULL;
461 list_del(&x->head);
462 }
463 spin_unlock_irqrestore(&phy_lock, flags);
464}
465EXPORT_SYMBOL_GPL(usb_remove_phy);
466
467/**
468 * usb_bind_phy - bind the phy and the controller that uses the phy
469 * @dev_name: the device name of the device that will bind to the phy
470 * @index: index to specify the port number
471 * @phy_dev_name: the device name of the phy
472 *
473 * Fills the phy_bind structure with the dev_name and phy_dev_name. This will
474 * be used when the phy driver registers the phy and when the controller
475 * requests this phy.
476 *
477 * To be used by platform specific initialization code.
478 */
479int usb_bind_phy(const char *dev_name, u8 index,
480 const char *phy_dev_name)
481{
482 struct usb_phy_bind *phy_bind;
483 unsigned long flags;
484
485 phy_bind = kzalloc(sizeof(*phy_bind), GFP_KERNEL);
486 if (!phy_bind)
487 return -ENOMEM;
488
489 phy_bind->dev_name = dev_name;
490 phy_bind->phy_dev_name = phy_dev_name;
491 phy_bind->index = index;
492
493 spin_lock_irqsave(&phy_lock, flags);
494 list_add_tail(&phy_bind->list, &phy_bind_list);
495 spin_unlock_irqrestore(&phy_lock, flags);
496
497 return 0;
498}
499EXPORT_SYMBOL_GPL(usb_bind_phy);
500
501/**
502 * usb_phy_set_event - set event to phy event
503 * @x: the phy returned by usb_get_phy();
504 *
505 * This sets event to phy event
506 */
507void usb_phy_set_event(struct usb_phy *x, unsigned long event)
508{
509 x->last_event = event;
510}
511EXPORT_SYMBOL_GPL(usb_phy_set_event);
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * phy.c -- USB phy handling
4 *
5 * Copyright (C) 2004-2013 Texas Instruments
6 */
7#include <linux/kernel.h>
8#include <linux/export.h>
9#include <linux/err.h>
10#include <linux/device.h>
11#include <linux/module.h>
12#include <linux/slab.h>
13#include <linux/of.h>
14
15#include <linux/usb/phy.h>
16
17/* Default current range by charger type. */
18#define DEFAULT_SDP_CUR_MIN 2
19#define DEFAULT_SDP_CUR_MAX 500
20#define DEFAULT_SDP_CUR_MIN_SS 150
21#define DEFAULT_SDP_CUR_MAX_SS 900
22#define DEFAULT_DCP_CUR_MIN 500
23#define DEFAULT_DCP_CUR_MAX 5000
24#define DEFAULT_CDP_CUR_MIN 1500
25#define DEFAULT_CDP_CUR_MAX 5000
26#define DEFAULT_ACA_CUR_MIN 1500
27#define DEFAULT_ACA_CUR_MAX 5000
28
29static LIST_HEAD(phy_list);
30static DEFINE_SPINLOCK(phy_lock);
31
32struct phy_devm {
33 struct usb_phy *phy;
34 struct notifier_block *nb;
35};
36
37static struct usb_phy *__usb_find_phy(struct list_head *list,
38 enum usb_phy_type type)
39{
40 struct usb_phy *phy = NULL;
41
42 list_for_each_entry(phy, list, head) {
43 if (phy->type != type)
44 continue;
45
46 return phy;
47 }
48
49 return ERR_PTR(-ENODEV);
50}
51
52static struct usb_phy *__of_usb_find_phy(struct device_node *node)
53{
54 struct usb_phy *phy;
55
56 if (!of_device_is_available(node))
57 return ERR_PTR(-ENODEV);
58
59 list_for_each_entry(phy, &phy_list, head) {
60 if (node != phy->dev->of_node)
61 continue;
62
63 return phy;
64 }
65
66 return ERR_PTR(-EPROBE_DEFER);
67}
68
69static void usb_phy_set_default_current(struct usb_phy *usb_phy)
70{
71 usb_phy->chg_cur.sdp_min = DEFAULT_SDP_CUR_MIN;
72 usb_phy->chg_cur.sdp_max = DEFAULT_SDP_CUR_MAX;
73 usb_phy->chg_cur.dcp_min = DEFAULT_DCP_CUR_MIN;
74 usb_phy->chg_cur.dcp_max = DEFAULT_DCP_CUR_MAX;
75 usb_phy->chg_cur.cdp_min = DEFAULT_CDP_CUR_MIN;
76 usb_phy->chg_cur.cdp_max = DEFAULT_CDP_CUR_MAX;
77 usb_phy->chg_cur.aca_min = DEFAULT_ACA_CUR_MIN;
78 usb_phy->chg_cur.aca_max = DEFAULT_ACA_CUR_MAX;
79}
80
81/**
82 * usb_phy_notify_charger_work - notify the USB charger state
83 * @work - the charger work to notify the USB charger state
84 *
85 * This work can be issued when USB charger state has been changed or
86 * USB charger current has been changed, then we can notify the current
87 * what can be drawn to power user and the charger state to userspace.
88 *
89 * If we get the charger type from extcon subsystem, we can notify the
90 * charger state to power user automatically by usb_phy_get_charger_type()
91 * issuing from extcon subsystem.
92 *
93 * If we get the charger type from ->charger_detect() instead of extcon
94 * subsystem, the usb phy driver should issue usb_phy_set_charger_state()
95 * to set charger state when the charger state has been changed.
96 */
97static void usb_phy_notify_charger_work(struct work_struct *work)
98{
99 struct usb_phy *usb_phy = container_of(work, struct usb_phy, chg_work);
100 char uchger_state[50] = { 0 };
101 char *envp[] = { uchger_state, NULL };
102 unsigned int min, max;
103
104 switch (usb_phy->chg_state) {
105 case USB_CHARGER_PRESENT:
106 usb_phy_get_charger_current(usb_phy, &min, &max);
107
108 atomic_notifier_call_chain(&usb_phy->notifier, max, usb_phy);
109 snprintf(uchger_state, ARRAY_SIZE(uchger_state),
110 "USB_CHARGER_STATE=%s", "USB_CHARGER_PRESENT");
111 break;
112 case USB_CHARGER_ABSENT:
113 usb_phy_set_default_current(usb_phy);
114
115 atomic_notifier_call_chain(&usb_phy->notifier, 0, usb_phy);
116 snprintf(uchger_state, ARRAY_SIZE(uchger_state),
117 "USB_CHARGER_STATE=%s", "USB_CHARGER_ABSENT");
118 break;
119 default:
120 dev_warn(usb_phy->dev, "Unknown USB charger state: %d\n",
121 usb_phy->chg_state);
122 return;
123 }
124
125 kobject_uevent_env(&usb_phy->dev->kobj, KOBJ_CHANGE, envp);
126}
127
128static void __usb_phy_get_charger_type(struct usb_phy *usb_phy)
129{
130 if (extcon_get_state(usb_phy->edev, EXTCON_CHG_USB_SDP) > 0) {
131 usb_phy->chg_type = SDP_TYPE;
132 usb_phy->chg_state = USB_CHARGER_PRESENT;
133 } else if (extcon_get_state(usb_phy->edev, EXTCON_CHG_USB_CDP) > 0) {
134 usb_phy->chg_type = CDP_TYPE;
135 usb_phy->chg_state = USB_CHARGER_PRESENT;
136 } else if (extcon_get_state(usb_phy->edev, EXTCON_CHG_USB_DCP) > 0) {
137 usb_phy->chg_type = DCP_TYPE;
138 usb_phy->chg_state = USB_CHARGER_PRESENT;
139 } else if (extcon_get_state(usb_phy->edev, EXTCON_CHG_USB_ACA) > 0) {
140 usb_phy->chg_type = ACA_TYPE;
141 usb_phy->chg_state = USB_CHARGER_PRESENT;
142 } else {
143 usb_phy->chg_type = UNKNOWN_TYPE;
144 usb_phy->chg_state = USB_CHARGER_ABSENT;
145 }
146
147 schedule_work(&usb_phy->chg_work);
148}
149
150/**
151 * usb_phy_get_charger_type - get charger type from extcon subsystem
152 * @nb -the notifier block to determine charger type
153 * @state - the cable state
154 * @data - private data
155 *
156 * Determin the charger type from extcon subsystem which also means the
157 * charger state has been chaned, then we should notify this event.
158 */
159static int usb_phy_get_charger_type(struct notifier_block *nb,
160 unsigned long state, void *data)
161{
162 struct usb_phy *usb_phy = container_of(nb, struct usb_phy, type_nb);
163
164 __usb_phy_get_charger_type(usb_phy);
165 return NOTIFY_OK;
166}
167
168/**
169 * usb_phy_set_charger_current - set the USB charger current
170 * @usb_phy - the USB phy to be used
171 * @mA - the current need to be set
172 *
173 * Usually we only change the charger default current when USB finished the
174 * enumeration as one SDP charger. As one SDP charger, usb_phy_set_power()
175 * will issue this function to change charger current when after setting USB
176 * configuration, or suspend/resume USB. For other type charger, we should
177 * use the default charger current and we do not suggest to issue this function
178 * to change the charger current.
179 *
180 * When USB charger current has been changed, we need to notify the power users.
181 */
182void usb_phy_set_charger_current(struct usb_phy *usb_phy, unsigned int mA)
183{
184 switch (usb_phy->chg_type) {
185 case SDP_TYPE:
186 if (usb_phy->chg_cur.sdp_max == mA)
187 return;
188
189 usb_phy->chg_cur.sdp_max = (mA > DEFAULT_SDP_CUR_MAX_SS) ?
190 DEFAULT_SDP_CUR_MAX_SS : mA;
191 break;
192 case DCP_TYPE:
193 if (usb_phy->chg_cur.dcp_max == mA)
194 return;
195
196 usb_phy->chg_cur.dcp_max = (mA > DEFAULT_DCP_CUR_MAX) ?
197 DEFAULT_DCP_CUR_MAX : mA;
198 break;
199 case CDP_TYPE:
200 if (usb_phy->chg_cur.cdp_max == mA)
201 return;
202
203 usb_phy->chg_cur.cdp_max = (mA > DEFAULT_CDP_CUR_MAX) ?
204 DEFAULT_CDP_CUR_MAX : mA;
205 break;
206 case ACA_TYPE:
207 if (usb_phy->chg_cur.aca_max == mA)
208 return;
209
210 usb_phy->chg_cur.aca_max = (mA > DEFAULT_ACA_CUR_MAX) ?
211 DEFAULT_ACA_CUR_MAX : mA;
212 break;
213 default:
214 return;
215 }
216
217 schedule_work(&usb_phy->chg_work);
218}
219EXPORT_SYMBOL_GPL(usb_phy_set_charger_current);
220
221/**
222 * usb_phy_get_charger_current - get the USB charger current
223 * @usb_phy - the USB phy to be used
224 * @min - the minimum current
225 * @max - the maximum current
226 *
227 * Usually we will notify the maximum current to power user, but for some
228 * special case, power user also need the minimum current value. Then the
229 * power user can issue this function to get the suitable current.
230 */
231void usb_phy_get_charger_current(struct usb_phy *usb_phy,
232 unsigned int *min, unsigned int *max)
233{
234 switch (usb_phy->chg_type) {
235 case SDP_TYPE:
236 *min = usb_phy->chg_cur.sdp_min;
237 *max = usb_phy->chg_cur.sdp_max;
238 break;
239 case DCP_TYPE:
240 *min = usb_phy->chg_cur.dcp_min;
241 *max = usb_phy->chg_cur.dcp_max;
242 break;
243 case CDP_TYPE:
244 *min = usb_phy->chg_cur.cdp_min;
245 *max = usb_phy->chg_cur.cdp_max;
246 break;
247 case ACA_TYPE:
248 *min = usb_phy->chg_cur.aca_min;
249 *max = usb_phy->chg_cur.aca_max;
250 break;
251 default:
252 *min = 0;
253 *max = 0;
254 break;
255 }
256}
257EXPORT_SYMBOL_GPL(usb_phy_get_charger_current);
258
259/**
260 * usb_phy_set_charger_state - set the USB charger state
261 * @usb_phy - the USB phy to be used
262 * @state - the new state need to be set for charger
263 *
264 * The usb phy driver can issue this function when the usb phy driver
265 * detected the charger state has been changed, in this case the charger
266 * type should be get from ->charger_detect().
267 */
268void usb_phy_set_charger_state(struct usb_phy *usb_phy,
269 enum usb_charger_state state)
270{
271 if (usb_phy->chg_state == state || !usb_phy->charger_detect)
272 return;
273
274 usb_phy->chg_state = state;
275 if (usb_phy->chg_state == USB_CHARGER_PRESENT)
276 usb_phy->chg_type = usb_phy->charger_detect(usb_phy);
277 else
278 usb_phy->chg_type = UNKNOWN_TYPE;
279
280 schedule_work(&usb_phy->chg_work);
281}
282EXPORT_SYMBOL_GPL(usb_phy_set_charger_state);
283
284static void devm_usb_phy_release(struct device *dev, void *res)
285{
286 struct usb_phy *phy = *(struct usb_phy **)res;
287
288 usb_put_phy(phy);
289}
290
291static void devm_usb_phy_release2(struct device *dev, void *_res)
292{
293 struct phy_devm *res = _res;
294
295 if (res->nb)
296 usb_unregister_notifier(res->phy, res->nb);
297 usb_put_phy(res->phy);
298}
299
300static int devm_usb_phy_match(struct device *dev, void *res, void *match_data)
301{
302 struct usb_phy **phy = res;
303
304 return *phy == match_data;
305}
306
307static void usb_charger_init(struct usb_phy *usb_phy)
308{
309 usb_phy->chg_type = UNKNOWN_TYPE;
310 usb_phy->chg_state = USB_CHARGER_DEFAULT;
311 usb_phy_set_default_current(usb_phy);
312 INIT_WORK(&usb_phy->chg_work, usb_phy_notify_charger_work);
313}
314
315static int usb_add_extcon(struct usb_phy *x)
316{
317 int ret;
318
319 if (of_property_read_bool(x->dev->of_node, "extcon")) {
320 x->edev = extcon_get_edev_by_phandle(x->dev, 0);
321 if (IS_ERR(x->edev))
322 return PTR_ERR(x->edev);
323
324 x->id_edev = extcon_get_edev_by_phandle(x->dev, 1);
325 if (IS_ERR(x->id_edev)) {
326 x->id_edev = NULL;
327 dev_info(x->dev, "No separate ID extcon device\n");
328 }
329
330 if (x->vbus_nb.notifier_call) {
331 ret = devm_extcon_register_notifier(x->dev, x->edev,
332 EXTCON_USB,
333 &x->vbus_nb);
334 if (ret < 0) {
335 dev_err(x->dev,
336 "register VBUS notifier failed\n");
337 return ret;
338 }
339 } else {
340 x->type_nb.notifier_call = usb_phy_get_charger_type;
341
342 ret = devm_extcon_register_notifier(x->dev, x->edev,
343 EXTCON_CHG_USB_SDP,
344 &x->type_nb);
345 if (ret) {
346 dev_err(x->dev,
347 "register extcon USB SDP failed.\n");
348 return ret;
349 }
350
351 ret = devm_extcon_register_notifier(x->dev, x->edev,
352 EXTCON_CHG_USB_CDP,
353 &x->type_nb);
354 if (ret) {
355 dev_err(x->dev,
356 "register extcon USB CDP failed.\n");
357 return ret;
358 }
359
360 ret = devm_extcon_register_notifier(x->dev, x->edev,
361 EXTCON_CHG_USB_DCP,
362 &x->type_nb);
363 if (ret) {
364 dev_err(x->dev,
365 "register extcon USB DCP failed.\n");
366 return ret;
367 }
368
369 ret = devm_extcon_register_notifier(x->dev, x->edev,
370 EXTCON_CHG_USB_ACA,
371 &x->type_nb);
372 if (ret) {
373 dev_err(x->dev,
374 "register extcon USB ACA failed.\n");
375 return ret;
376 }
377 }
378
379 if (x->id_nb.notifier_call) {
380 struct extcon_dev *id_ext;
381
382 if (x->id_edev)
383 id_ext = x->id_edev;
384 else
385 id_ext = x->edev;
386
387 ret = devm_extcon_register_notifier(x->dev, id_ext,
388 EXTCON_USB_HOST,
389 &x->id_nb);
390 if (ret < 0) {
391 dev_err(x->dev,
392 "register ID notifier failed\n");
393 return ret;
394 }
395 }
396 }
397
398 if (x->type_nb.notifier_call)
399 __usb_phy_get_charger_type(x);
400
401 return 0;
402}
403
404/**
405 * devm_usb_get_phy - find the USB PHY
406 * @dev - device that requests this phy
407 * @type - the type of the phy the controller requires
408 *
409 * Gets the phy using usb_get_phy(), and associates a device with it using
410 * devres. On driver detach, release function is invoked on the devres data,
411 * then, devres data is freed.
412 *
413 * For use by USB host and peripheral drivers.
414 */
415struct usb_phy *devm_usb_get_phy(struct device *dev, enum usb_phy_type type)
416{
417 struct usb_phy **ptr, *phy;
418
419 ptr = devres_alloc(devm_usb_phy_release, sizeof(*ptr), GFP_KERNEL);
420 if (!ptr)
421 return ERR_PTR(-ENOMEM);
422
423 phy = usb_get_phy(type);
424 if (!IS_ERR(phy)) {
425 *ptr = phy;
426 devres_add(dev, ptr);
427 } else
428 devres_free(ptr);
429
430 return phy;
431}
432EXPORT_SYMBOL_GPL(devm_usb_get_phy);
433
434/**
435 * usb_get_phy - find the USB PHY
436 * @type - the type of the phy the controller requires
437 *
438 * Returns the phy driver, after getting a refcount to it; or
439 * -ENODEV if there is no such phy. The caller is responsible for
440 * calling usb_put_phy() to release that count.
441 *
442 * For use by USB host and peripheral drivers.
443 */
444struct usb_phy *usb_get_phy(enum usb_phy_type type)
445{
446 struct usb_phy *phy = NULL;
447 unsigned long flags;
448
449 spin_lock_irqsave(&phy_lock, flags);
450
451 phy = __usb_find_phy(&phy_list, type);
452 if (IS_ERR(phy) || !try_module_get(phy->dev->driver->owner)) {
453 pr_debug("PHY: unable to find transceiver of type %s\n",
454 usb_phy_type_string(type));
455 if (!IS_ERR(phy))
456 phy = ERR_PTR(-ENODEV);
457
458 goto err0;
459 }
460
461 get_device(phy->dev);
462
463err0:
464 spin_unlock_irqrestore(&phy_lock, flags);
465
466 return phy;
467}
468EXPORT_SYMBOL_GPL(usb_get_phy);
469
470/**
471 * devm_usb_get_phy_by_node - find the USB PHY by device_node
472 * @dev - device that requests this phy
473 * @node - the device_node for the phy device.
474 * @nb - a notifier_block to register with the phy.
475 *
476 * Returns the phy driver associated with the given device_node,
477 * after getting a refcount to it, -ENODEV if there is no such phy or
478 * -EPROBE_DEFER if the device is not yet loaded. While at that, it
479 * also associates the device with
480 * the phy using devres. On driver detach, release function is invoked
481 * on the devres data, then, devres data is freed.
482 *
483 * For use by peripheral drivers for devices related to a phy,
484 * such as a charger.
485 */
486struct usb_phy *devm_usb_get_phy_by_node(struct device *dev,
487 struct device_node *node,
488 struct notifier_block *nb)
489{
490 struct usb_phy *phy = ERR_PTR(-ENOMEM);
491 struct phy_devm *ptr;
492 unsigned long flags;
493
494 ptr = devres_alloc(devm_usb_phy_release2, sizeof(*ptr), GFP_KERNEL);
495 if (!ptr) {
496 dev_dbg(dev, "failed to allocate memory for devres\n");
497 goto err0;
498 }
499
500 spin_lock_irqsave(&phy_lock, flags);
501
502 phy = __of_usb_find_phy(node);
503 if (IS_ERR(phy)) {
504 devres_free(ptr);
505 goto err1;
506 }
507
508 if (!try_module_get(phy->dev->driver->owner)) {
509 phy = ERR_PTR(-ENODEV);
510 devres_free(ptr);
511 goto err1;
512 }
513 if (nb)
514 usb_register_notifier(phy, nb);
515 ptr->phy = phy;
516 ptr->nb = nb;
517 devres_add(dev, ptr);
518
519 get_device(phy->dev);
520
521err1:
522 spin_unlock_irqrestore(&phy_lock, flags);
523
524err0:
525
526 return phy;
527}
528EXPORT_SYMBOL_GPL(devm_usb_get_phy_by_node);
529
530/**
531 * devm_usb_get_phy_by_phandle - find the USB PHY by phandle
532 * @dev - device that requests this phy
533 * @phandle - name of the property holding the phy phandle value
534 * @index - the index of the phy
535 *
536 * Returns the phy driver associated with the given phandle value,
537 * after getting a refcount to it, -ENODEV if there is no such phy or
538 * -EPROBE_DEFER if there is a phandle to the phy, but the device is
539 * not yet loaded. While at that, it also associates the device with
540 * the phy using devres. On driver detach, release function is invoked
541 * on the devres data, then, devres data is freed.
542 *
543 * For use by USB host and peripheral drivers.
544 */
545struct usb_phy *devm_usb_get_phy_by_phandle(struct device *dev,
546 const char *phandle, u8 index)
547{
548 struct device_node *node;
549 struct usb_phy *phy;
550
551 if (!dev->of_node) {
552 dev_dbg(dev, "device does not have a device node entry\n");
553 return ERR_PTR(-EINVAL);
554 }
555
556 node = of_parse_phandle(dev->of_node, phandle, index);
557 if (!node) {
558 dev_dbg(dev, "failed to get %s phandle in %pOF node\n", phandle,
559 dev->of_node);
560 return ERR_PTR(-ENODEV);
561 }
562 phy = devm_usb_get_phy_by_node(dev, node, NULL);
563 of_node_put(node);
564 return phy;
565}
566EXPORT_SYMBOL_GPL(devm_usb_get_phy_by_phandle);
567
568/**
569 * devm_usb_put_phy - release the USB PHY
570 * @dev - device that wants to release this phy
571 * @phy - the phy returned by devm_usb_get_phy()
572 *
573 * destroys the devres associated with this phy and invokes usb_put_phy
574 * to release the phy.
575 *
576 * For use by USB host and peripheral drivers.
577 */
578void devm_usb_put_phy(struct device *dev, struct usb_phy *phy)
579{
580 int r;
581
582 r = devres_destroy(dev, devm_usb_phy_release, devm_usb_phy_match, phy);
583 dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
584}
585EXPORT_SYMBOL_GPL(devm_usb_put_phy);
586
587/**
588 * usb_put_phy - release the USB PHY
589 * @x: the phy returned by usb_get_phy()
590 *
591 * Releases a refcount the caller received from usb_get_phy().
592 *
593 * For use by USB host and peripheral drivers.
594 */
595void usb_put_phy(struct usb_phy *x)
596{
597 if (x) {
598 struct module *owner = x->dev->driver->owner;
599
600 put_device(x->dev);
601 module_put(owner);
602 }
603}
604EXPORT_SYMBOL_GPL(usb_put_phy);
605
606/**
607 * usb_add_phy - declare the USB PHY
608 * @x: the USB phy to be used; or NULL
609 * @type - the type of this PHY
610 *
611 * This call is exclusively for use by phy drivers, which
612 * coordinate the activities of drivers for host and peripheral
613 * controllers, and in some cases for VBUS current regulation.
614 */
615int usb_add_phy(struct usb_phy *x, enum usb_phy_type type)
616{
617 int ret = 0;
618 unsigned long flags;
619 struct usb_phy *phy;
620
621 if (x->type != USB_PHY_TYPE_UNDEFINED) {
622 dev_err(x->dev, "not accepting initialized PHY %s\n", x->label);
623 return -EINVAL;
624 }
625
626 usb_charger_init(x);
627 ret = usb_add_extcon(x);
628 if (ret)
629 return ret;
630
631 ATOMIC_INIT_NOTIFIER_HEAD(&x->notifier);
632
633 spin_lock_irqsave(&phy_lock, flags);
634
635 list_for_each_entry(phy, &phy_list, head) {
636 if (phy->type == type) {
637 ret = -EBUSY;
638 dev_err(x->dev, "transceiver type %s already exists\n",
639 usb_phy_type_string(type));
640 goto out;
641 }
642 }
643
644 x->type = type;
645 list_add_tail(&x->head, &phy_list);
646
647out:
648 spin_unlock_irqrestore(&phy_lock, flags);
649 return ret;
650}
651EXPORT_SYMBOL_GPL(usb_add_phy);
652
653/**
654 * usb_add_phy_dev - declare the USB PHY
655 * @x: the USB phy to be used; or NULL
656 *
657 * This call is exclusively for use by phy drivers, which
658 * coordinate the activities of drivers for host and peripheral
659 * controllers, and in some cases for VBUS current regulation.
660 */
661int usb_add_phy_dev(struct usb_phy *x)
662{
663 unsigned long flags;
664 int ret;
665
666 if (!x->dev) {
667 dev_err(x->dev, "no device provided for PHY\n");
668 return -EINVAL;
669 }
670
671 usb_charger_init(x);
672 ret = usb_add_extcon(x);
673 if (ret)
674 return ret;
675
676 ATOMIC_INIT_NOTIFIER_HEAD(&x->notifier);
677
678 spin_lock_irqsave(&phy_lock, flags);
679 list_add_tail(&x->head, &phy_list);
680 spin_unlock_irqrestore(&phy_lock, flags);
681
682 return 0;
683}
684EXPORT_SYMBOL_GPL(usb_add_phy_dev);
685
686/**
687 * usb_remove_phy - remove the OTG PHY
688 * @x: the USB OTG PHY to be removed;
689 *
690 * This reverts the effects of usb_add_phy
691 */
692void usb_remove_phy(struct usb_phy *x)
693{
694 unsigned long flags;
695
696 spin_lock_irqsave(&phy_lock, flags);
697 if (x)
698 list_del(&x->head);
699 spin_unlock_irqrestore(&phy_lock, flags);
700}
701EXPORT_SYMBOL_GPL(usb_remove_phy);
702
703/**
704 * usb_phy_set_event - set event to phy event
705 * @x: the phy returned by usb_get_phy();
706 *
707 * This sets event to phy event
708 */
709void usb_phy_set_event(struct usb_phy *x, unsigned long event)
710{
711 x->last_event = event;
712}
713EXPORT_SYMBOL_GPL(usb_phy_set_event);