1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Copyright (c) 2014-2022, NVIDIA CORPORATION. All rights reserved. |
4 | */ |
5 | |
6 | #include <linux/delay.h> |
7 | #include <linux/io.h> |
8 | #include <linux/mailbox_client.h> |
9 | #include <linux/module.h> |
10 | #include <linux/of.h> |
11 | #include <linux/of_platform.h> |
12 | #include <linux/phy/phy.h> |
13 | #include <linux/phy/tegra/xusb.h> |
14 | #include <linux/platform_device.h> |
15 | #include <linux/regulator/consumer.h> |
16 | #include <linux/reset.h> |
17 | #include <linux/slab.h> |
18 | #include <linux/workqueue.h> |
19 | |
20 | #include <soc/tegra/fuse.h> |
21 | |
22 | #include "xusb.h" |
23 | |
24 | static struct phy *tegra_xusb_pad_of_xlate(struct device *dev, |
25 | struct of_phandle_args *args) |
26 | { |
27 | struct tegra_xusb_pad *pad = dev_get_drvdata(dev); |
28 | struct phy *phy = NULL; |
29 | unsigned int i; |
30 | |
31 | if (args->args_count != 0) |
32 | return ERR_PTR(error: -EINVAL); |
33 | |
34 | for (i = 0; i < pad->soc->num_lanes; i++) { |
35 | if (!pad->lanes[i]) |
36 | continue; |
37 | |
38 | if (pad->lanes[i]->dev.of_node == args->np) { |
39 | phy = pad->lanes[i]; |
40 | break; |
41 | } |
42 | } |
43 | |
44 | if (phy == NULL) |
45 | phy = ERR_PTR(error: -ENODEV); |
46 | |
47 | return phy; |
48 | } |
49 | |
50 | static const struct of_device_id tegra_xusb_padctl_of_match[] = { |
51 | #if defined(CONFIG_ARCH_TEGRA_124_SOC) || defined(CONFIG_ARCH_TEGRA_132_SOC) |
52 | { |
53 | .compatible = "nvidia,tegra124-xusb-padctl" , |
54 | .data = &tegra124_xusb_padctl_soc, |
55 | }, |
56 | #endif |
57 | #if defined(CONFIG_ARCH_TEGRA_210_SOC) |
58 | { |
59 | .compatible = "nvidia,tegra210-xusb-padctl" , |
60 | .data = &tegra210_xusb_padctl_soc, |
61 | }, |
62 | #endif |
63 | #if defined(CONFIG_ARCH_TEGRA_186_SOC) |
64 | { |
65 | .compatible = "nvidia,tegra186-xusb-padctl" , |
66 | .data = &tegra186_xusb_padctl_soc, |
67 | }, |
68 | #endif |
69 | #if defined(CONFIG_ARCH_TEGRA_194_SOC) |
70 | { |
71 | .compatible = "nvidia,tegra194-xusb-padctl" , |
72 | .data = &tegra194_xusb_padctl_soc, |
73 | }, |
74 | #endif |
75 | #if defined(CONFIG_ARCH_TEGRA_234_SOC) |
76 | { |
77 | .compatible = "nvidia,tegra234-xusb-padctl" , |
78 | .data = &tegra234_xusb_padctl_soc, |
79 | }, |
80 | #endif |
81 | { } |
82 | }; |
83 | MODULE_DEVICE_TABLE(of, tegra_xusb_padctl_of_match); |
84 | |
85 | static struct device_node * |
86 | tegra_xusb_find_pad_node(struct tegra_xusb_padctl *padctl, const char *name) |
87 | { |
88 | struct device_node *pads, *np; |
89 | |
90 | pads = of_get_child_by_name(node: padctl->dev->of_node, name: "pads" ); |
91 | if (!pads) |
92 | return NULL; |
93 | |
94 | np = of_get_child_by_name(node: pads, name); |
95 | of_node_put(node: pads); |
96 | |
97 | return np; |
98 | } |
99 | |
100 | static struct device_node * |
101 | tegra_xusb_pad_find_phy_node(struct tegra_xusb_pad *pad, unsigned int index) |
102 | { |
103 | struct device_node *np, *lanes; |
104 | |
105 | lanes = of_get_child_by_name(node: pad->dev.of_node, name: "lanes" ); |
106 | if (!lanes) |
107 | return NULL; |
108 | |
109 | np = of_get_child_by_name(node: lanes, name: pad->soc->lanes[index].name); |
110 | of_node_put(node: lanes); |
111 | |
112 | return np; |
113 | } |
114 | |
115 | int tegra_xusb_lane_parse_dt(struct tegra_xusb_lane *lane, |
116 | struct device_node *np) |
117 | { |
118 | struct device *dev = &lane->pad->dev; |
119 | const char *function; |
120 | int err; |
121 | |
122 | err = of_property_read_string(np, propname: "nvidia,function" , out_string: &function); |
123 | if (err < 0) |
124 | return err; |
125 | |
126 | err = match_string(array: lane->soc->funcs, n: lane->soc->num_funcs, string: function); |
127 | if (err < 0) { |
128 | dev_err(dev, "invalid function \"%s\" for lane \"%pOFn\"\n" , |
129 | function, np); |
130 | return err; |
131 | } |
132 | |
133 | lane->function = err; |
134 | |
135 | return 0; |
136 | } |
137 | |
138 | static void tegra_xusb_lane_destroy(struct phy *phy) |
139 | { |
140 | if (phy) { |
141 | struct tegra_xusb_lane *lane = phy_get_drvdata(phy); |
142 | |
143 | lane->pad->ops->remove(lane); |
144 | phy_destroy(phy); |
145 | } |
146 | } |
147 | |
148 | static void tegra_xusb_pad_release(struct device *dev) |
149 | { |
150 | struct tegra_xusb_pad *pad = to_tegra_xusb_pad(dev); |
151 | |
152 | pad->soc->ops->remove(pad); |
153 | } |
154 | |
155 | static const struct device_type tegra_xusb_pad_type = { |
156 | .release = tegra_xusb_pad_release, |
157 | }; |
158 | |
159 | int tegra_xusb_pad_init(struct tegra_xusb_pad *pad, |
160 | struct tegra_xusb_padctl *padctl, |
161 | struct device_node *np) |
162 | { |
163 | int err; |
164 | |
165 | device_initialize(dev: &pad->dev); |
166 | INIT_LIST_HEAD(list: &pad->list); |
167 | pad->dev.parent = padctl->dev; |
168 | pad->dev.type = &tegra_xusb_pad_type; |
169 | pad->dev.of_node = np; |
170 | pad->padctl = padctl; |
171 | |
172 | err = dev_set_name(dev: &pad->dev, name: "%s" , pad->soc->name); |
173 | if (err < 0) |
174 | goto unregister; |
175 | |
176 | err = device_add(dev: &pad->dev); |
177 | if (err < 0) |
178 | goto unregister; |
179 | |
180 | return 0; |
181 | |
182 | unregister: |
183 | device_unregister(dev: &pad->dev); |
184 | return err; |
185 | } |
186 | |
187 | int tegra_xusb_pad_register(struct tegra_xusb_pad *pad, |
188 | const struct phy_ops *ops) |
189 | { |
190 | struct device_node *children; |
191 | struct phy *lane; |
192 | unsigned int i; |
193 | int err; |
194 | |
195 | children = of_get_child_by_name(node: pad->dev.of_node, name: "lanes" ); |
196 | if (!children) |
197 | return -ENODEV; |
198 | |
199 | pad->lanes = devm_kcalloc(dev: &pad->dev, n: pad->soc->num_lanes, size: sizeof(lane), |
200 | GFP_KERNEL); |
201 | if (!pad->lanes) { |
202 | of_node_put(node: children); |
203 | return -ENOMEM; |
204 | } |
205 | |
206 | for (i = 0; i < pad->soc->num_lanes; i++) { |
207 | struct device_node *np = tegra_xusb_pad_find_phy_node(pad, index: i); |
208 | struct tegra_xusb_lane *lane; |
209 | |
210 | /* skip disabled lanes */ |
211 | if (!np || !of_device_is_available(device: np)) { |
212 | of_node_put(node: np); |
213 | continue; |
214 | } |
215 | |
216 | pad->lanes[i] = phy_create(dev: &pad->dev, node: np, ops); |
217 | if (IS_ERR(ptr: pad->lanes[i])) { |
218 | err = PTR_ERR(ptr: pad->lanes[i]); |
219 | of_node_put(node: np); |
220 | goto remove; |
221 | } |
222 | |
223 | lane = pad->ops->probe(pad, np, i); |
224 | if (IS_ERR(ptr: lane)) { |
225 | phy_destroy(phy: pad->lanes[i]); |
226 | err = PTR_ERR(ptr: lane); |
227 | goto remove; |
228 | } |
229 | |
230 | list_add_tail(new: &lane->list, head: &pad->padctl->lanes); |
231 | phy_set_drvdata(phy: pad->lanes[i], data: lane); |
232 | } |
233 | |
234 | pad->provider = of_phy_provider_register_full(&pad->dev, children, |
235 | tegra_xusb_pad_of_xlate); |
236 | if (IS_ERR(ptr: pad->provider)) { |
237 | err = PTR_ERR(ptr: pad->provider); |
238 | goto remove; |
239 | } |
240 | |
241 | return 0; |
242 | |
243 | remove: |
244 | while (i--) |
245 | tegra_xusb_lane_destroy(phy: pad->lanes[i]); |
246 | |
247 | of_node_put(node: children); |
248 | |
249 | return err; |
250 | } |
251 | |
252 | void tegra_xusb_pad_unregister(struct tegra_xusb_pad *pad) |
253 | { |
254 | unsigned int i = pad->soc->num_lanes; |
255 | |
256 | of_phy_provider_unregister(phy_provider: pad->provider); |
257 | |
258 | while (i--) |
259 | tegra_xusb_lane_destroy(phy: pad->lanes[i]); |
260 | |
261 | device_unregister(dev: &pad->dev); |
262 | } |
263 | |
264 | static struct tegra_xusb_pad * |
265 | tegra_xusb_pad_create(struct tegra_xusb_padctl *padctl, |
266 | const struct tegra_xusb_pad_soc *soc) |
267 | { |
268 | struct tegra_xusb_pad *pad; |
269 | struct device_node *np; |
270 | int err; |
271 | |
272 | np = tegra_xusb_find_pad_node(padctl, name: soc->name); |
273 | if (!np || !of_device_is_available(device: np)) |
274 | return NULL; |
275 | |
276 | pad = soc->ops->probe(padctl, soc, np); |
277 | if (IS_ERR(ptr: pad)) { |
278 | err = PTR_ERR(ptr: pad); |
279 | dev_err(padctl->dev, "failed to create pad %s: %d\n" , |
280 | soc->name, err); |
281 | return ERR_PTR(error: err); |
282 | } |
283 | |
284 | /* XXX move this into ->probe() to avoid string comparison */ |
285 | if (strcmp(soc->name, "pcie" ) == 0) |
286 | padctl->pcie = pad; |
287 | |
288 | if (strcmp(soc->name, "sata" ) == 0) |
289 | padctl->sata = pad; |
290 | |
291 | if (strcmp(soc->name, "usb2" ) == 0) |
292 | padctl->usb2 = pad; |
293 | |
294 | if (strcmp(soc->name, "ulpi" ) == 0) |
295 | padctl->ulpi = pad; |
296 | |
297 | if (strcmp(soc->name, "hsic" ) == 0) |
298 | padctl->hsic = pad; |
299 | |
300 | return pad; |
301 | } |
302 | |
303 | static void __tegra_xusb_remove_pads(struct tegra_xusb_padctl *padctl) |
304 | { |
305 | struct tegra_xusb_pad *pad, *tmp; |
306 | |
307 | list_for_each_entry_safe_reverse(pad, tmp, &padctl->pads, list) { |
308 | list_del(entry: &pad->list); |
309 | tegra_xusb_pad_unregister(pad); |
310 | } |
311 | } |
312 | |
313 | static void tegra_xusb_remove_pads(struct tegra_xusb_padctl *padctl) |
314 | { |
315 | mutex_lock(&padctl->lock); |
316 | __tegra_xusb_remove_pads(padctl); |
317 | mutex_unlock(lock: &padctl->lock); |
318 | } |
319 | |
320 | static void tegra_xusb_lane_program(struct tegra_xusb_lane *lane) |
321 | { |
322 | struct tegra_xusb_padctl *padctl = lane->pad->padctl; |
323 | const struct tegra_xusb_lane_soc *soc = lane->soc; |
324 | u32 value; |
325 | |
326 | /* skip single function lanes */ |
327 | if (soc->num_funcs < 2) |
328 | return; |
329 | |
330 | if (lane->pad->ops->iddq_enable) |
331 | lane->pad->ops->iddq_enable(lane); |
332 | |
333 | /* choose function */ |
334 | value = padctl_readl(padctl, offset: soc->offset); |
335 | value &= ~(soc->mask << soc->shift); |
336 | value |= lane->function << soc->shift; |
337 | padctl_writel(padctl, value, offset: soc->offset); |
338 | |
339 | if (lane->pad->ops->iddq_disable) |
340 | lane->pad->ops->iddq_disable(lane); |
341 | } |
342 | |
343 | static void tegra_xusb_pad_program(struct tegra_xusb_pad *pad) |
344 | { |
345 | unsigned int i; |
346 | |
347 | for (i = 0; i < pad->soc->num_lanes; i++) { |
348 | struct tegra_xusb_lane *lane; |
349 | |
350 | if (pad->lanes[i]) { |
351 | lane = phy_get_drvdata(phy: pad->lanes[i]); |
352 | tegra_xusb_lane_program(lane); |
353 | } |
354 | } |
355 | } |
356 | |
357 | static int tegra_xusb_setup_pads(struct tegra_xusb_padctl *padctl) |
358 | { |
359 | struct tegra_xusb_pad *pad; |
360 | unsigned int i; |
361 | |
362 | mutex_lock(&padctl->lock); |
363 | |
364 | for (i = 0; i < padctl->soc->num_pads; i++) { |
365 | const struct tegra_xusb_pad_soc *soc = padctl->soc->pads[i]; |
366 | int err; |
367 | |
368 | pad = tegra_xusb_pad_create(padctl, soc); |
369 | if (IS_ERR(ptr: pad)) { |
370 | err = PTR_ERR(ptr: pad); |
371 | dev_err(padctl->dev, "failed to create pad %s: %d\n" , |
372 | soc->name, err); |
373 | __tegra_xusb_remove_pads(padctl); |
374 | mutex_unlock(lock: &padctl->lock); |
375 | return err; |
376 | } |
377 | |
378 | if (!pad) |
379 | continue; |
380 | |
381 | list_add_tail(new: &pad->list, head: &padctl->pads); |
382 | } |
383 | |
384 | list_for_each_entry(pad, &padctl->pads, list) |
385 | tegra_xusb_pad_program(pad); |
386 | |
387 | mutex_unlock(lock: &padctl->lock); |
388 | return 0; |
389 | } |
390 | |
391 | bool tegra_xusb_lane_check(struct tegra_xusb_lane *lane, |
392 | const char *function) |
393 | { |
394 | const char *func = lane->soc->funcs[lane->function]; |
395 | |
396 | return strcmp(function, func) == 0; |
397 | } |
398 | |
399 | struct tegra_xusb_lane *tegra_xusb_find_lane(struct tegra_xusb_padctl *padctl, |
400 | const char *type, |
401 | unsigned int index) |
402 | { |
403 | struct tegra_xusb_lane *lane, *hit = ERR_PTR(error: -ENODEV); |
404 | char *name; |
405 | |
406 | name = kasprintf(GFP_KERNEL, fmt: "%s-%u" , type, index); |
407 | if (!name) |
408 | return ERR_PTR(error: -ENOMEM); |
409 | |
410 | list_for_each_entry(lane, &padctl->lanes, list) { |
411 | if (strcmp(lane->soc->name, name) == 0) { |
412 | hit = lane; |
413 | break; |
414 | } |
415 | } |
416 | |
417 | kfree(objp: name); |
418 | return hit; |
419 | } |
420 | |
421 | struct tegra_xusb_lane * |
422 | tegra_xusb_port_find_lane(struct tegra_xusb_port *port, |
423 | const struct tegra_xusb_lane_map *map, |
424 | const char *function) |
425 | { |
426 | struct tegra_xusb_lane *lane, *match = ERR_PTR(error: -ENODEV); |
427 | |
428 | for (; map->type; map++) { |
429 | if (port->index != map->port) |
430 | continue; |
431 | |
432 | lane = tegra_xusb_find_lane(padctl: port->padctl, type: map->type, |
433 | index: map->index); |
434 | if (IS_ERR(ptr: lane)) |
435 | continue; |
436 | |
437 | if (!tegra_xusb_lane_check(lane, function)) |
438 | continue; |
439 | |
440 | if (!IS_ERR(ptr: match)) |
441 | dev_err(&port->dev, "conflicting match: %s-%u / %s\n" , |
442 | map->type, map->index, match->soc->name); |
443 | else |
444 | match = lane; |
445 | } |
446 | |
447 | return match; |
448 | } |
449 | |
450 | static struct device_node * |
451 | tegra_xusb_find_port_node(struct tegra_xusb_padctl *padctl, const char *type, |
452 | unsigned int index) |
453 | { |
454 | struct device_node *ports, *np; |
455 | char *name; |
456 | |
457 | ports = of_get_child_by_name(node: padctl->dev->of_node, name: "ports" ); |
458 | if (!ports) |
459 | return NULL; |
460 | |
461 | name = kasprintf(GFP_KERNEL, fmt: "%s-%u" , type, index); |
462 | if (!name) { |
463 | of_node_put(node: ports); |
464 | return NULL; |
465 | } |
466 | np = of_get_child_by_name(node: ports, name); |
467 | kfree(objp: name); |
468 | of_node_put(node: ports); |
469 | |
470 | return np; |
471 | } |
472 | |
473 | struct tegra_xusb_port * |
474 | tegra_xusb_find_port(struct tegra_xusb_padctl *padctl, const char *type, |
475 | unsigned int index) |
476 | { |
477 | struct tegra_xusb_port *port; |
478 | struct device_node *np; |
479 | |
480 | np = tegra_xusb_find_port_node(padctl, type, index); |
481 | if (!np) |
482 | return NULL; |
483 | |
484 | list_for_each_entry(port, &padctl->ports, list) { |
485 | if (np == port->dev.of_node) { |
486 | of_node_put(node: np); |
487 | return port; |
488 | } |
489 | } |
490 | |
491 | of_node_put(node: np); |
492 | |
493 | return NULL; |
494 | } |
495 | |
496 | struct tegra_xusb_usb2_port * |
497 | tegra_xusb_find_usb2_port(struct tegra_xusb_padctl *padctl, unsigned int index) |
498 | { |
499 | struct tegra_xusb_port *port; |
500 | |
501 | port = tegra_xusb_find_port(padctl, type: "usb2" , index); |
502 | if (port) |
503 | return to_usb2_port(port); |
504 | |
505 | return NULL; |
506 | } |
507 | |
508 | struct tegra_xusb_usb3_port * |
509 | tegra_xusb_find_usb3_port(struct tegra_xusb_padctl *padctl, unsigned int index) |
510 | { |
511 | struct tegra_xusb_port *port; |
512 | |
513 | port = tegra_xusb_find_port(padctl, type: "usb3" , index); |
514 | if (port) |
515 | return to_usb3_port(port); |
516 | |
517 | return NULL; |
518 | } |
519 | |
520 | static void tegra_xusb_port_release(struct device *dev) |
521 | { |
522 | struct tegra_xusb_port *port = to_tegra_xusb_port(dev); |
523 | |
524 | if (port->ops->release) |
525 | port->ops->release(port); |
526 | } |
527 | |
528 | static const struct device_type tegra_xusb_port_type = { |
529 | .release = tegra_xusb_port_release, |
530 | }; |
531 | |
532 | static int tegra_xusb_port_init(struct tegra_xusb_port *port, |
533 | struct tegra_xusb_padctl *padctl, |
534 | struct device_node *np, |
535 | const char *name, |
536 | unsigned int index) |
537 | { |
538 | int err; |
539 | |
540 | INIT_LIST_HEAD(list: &port->list); |
541 | port->padctl = padctl; |
542 | port->index = index; |
543 | |
544 | device_initialize(dev: &port->dev); |
545 | port->dev.type = &tegra_xusb_port_type; |
546 | port->dev.of_node = of_node_get(node: np); |
547 | port->dev.parent = padctl->dev; |
548 | |
549 | err = dev_set_name(dev: &port->dev, name: "%s-%u" , name, index); |
550 | if (err < 0) |
551 | goto unregister; |
552 | |
553 | err = device_add(dev: &port->dev); |
554 | if (err < 0) |
555 | goto unregister; |
556 | |
557 | return 0; |
558 | |
559 | unregister: |
560 | device_unregister(dev: &port->dev); |
561 | return err; |
562 | } |
563 | |
564 | static void tegra_xusb_port_unregister(struct tegra_xusb_port *port) |
565 | { |
566 | if (!IS_ERR_OR_NULL(ptr: port->usb_role_sw)) { |
567 | of_platform_depopulate(parent: &port->dev); |
568 | usb_role_switch_unregister(sw: port->usb_role_sw); |
569 | cancel_work_sync(work: &port->usb_phy_work); |
570 | usb_remove_phy(&port->usb_phy); |
571 | port->usb_phy.dev->driver = NULL; |
572 | } |
573 | |
574 | if (port->ops->remove) |
575 | port->ops->remove(port); |
576 | |
577 | device_unregister(dev: &port->dev); |
578 | } |
579 | |
580 | static const char *const modes[] = { |
581 | [USB_DR_MODE_UNKNOWN] = "" , |
582 | [USB_DR_MODE_HOST] = "host" , |
583 | [USB_DR_MODE_PERIPHERAL] = "peripheral" , |
584 | [USB_DR_MODE_OTG] = "otg" , |
585 | }; |
586 | |
587 | static const char * const usb_roles[] = { |
588 | [USB_ROLE_NONE] = "none" , |
589 | [USB_ROLE_HOST] = "host" , |
590 | [USB_ROLE_DEVICE] = "device" , |
591 | }; |
592 | |
593 | static enum usb_phy_events to_usb_phy_event(enum usb_role role) |
594 | { |
595 | switch (role) { |
596 | case USB_ROLE_DEVICE: |
597 | return USB_EVENT_VBUS; |
598 | |
599 | case USB_ROLE_HOST: |
600 | return USB_EVENT_ID; |
601 | |
602 | default: |
603 | return USB_EVENT_NONE; |
604 | } |
605 | } |
606 | |
607 | static void tegra_xusb_usb_phy_work(struct work_struct *work) |
608 | { |
609 | struct tegra_xusb_port *port = container_of(work, |
610 | struct tegra_xusb_port, |
611 | usb_phy_work); |
612 | enum usb_role role = usb_role_switch_get_role(sw: port->usb_role_sw); |
613 | |
614 | usb_phy_set_event(x: &port->usb_phy, event: to_usb_phy_event(role)); |
615 | |
616 | dev_dbg(&port->dev, "%s(): calling notifier for role %s\n" , __func__, |
617 | usb_roles[role]); |
618 | |
619 | atomic_notifier_call_chain(nh: &port->usb_phy.notifier, val: 0, v: &port->usb_phy); |
620 | } |
621 | |
622 | static int tegra_xusb_role_sw_set(struct usb_role_switch *sw, |
623 | enum usb_role role) |
624 | { |
625 | struct tegra_xusb_port *port = usb_role_switch_get_drvdata(sw); |
626 | |
627 | dev_dbg(&port->dev, "%s(): role %s\n" , __func__, usb_roles[role]); |
628 | |
629 | schedule_work(work: &port->usb_phy_work); |
630 | |
631 | return 0; |
632 | } |
633 | |
634 | static int tegra_xusb_set_peripheral(struct usb_otg *otg, |
635 | struct usb_gadget *gadget) |
636 | { |
637 | struct tegra_xusb_port *port = container_of(otg->usb_phy, |
638 | struct tegra_xusb_port, |
639 | usb_phy); |
640 | |
641 | if (gadget != NULL) |
642 | schedule_work(work: &port->usb_phy_work); |
643 | |
644 | return 0; |
645 | } |
646 | |
647 | static int tegra_xusb_set_host(struct usb_otg *otg, struct usb_bus *host) |
648 | { |
649 | struct tegra_xusb_port *port = container_of(otg->usb_phy, |
650 | struct tegra_xusb_port, |
651 | usb_phy); |
652 | |
653 | if (host != NULL) |
654 | schedule_work(work: &port->usb_phy_work); |
655 | |
656 | return 0; |
657 | } |
658 | |
659 | |
660 | static int tegra_xusb_setup_usb_role_switch(struct tegra_xusb_port *port) |
661 | { |
662 | struct tegra_xusb_lane *lane; |
663 | struct usb_role_switch_desc role_sx_desc = { |
664 | .fwnode = dev_fwnode(&port->dev), |
665 | .set = tegra_xusb_role_sw_set, |
666 | .allow_userspace_control = true, |
667 | }; |
668 | int err = 0; |
669 | |
670 | /* |
671 | * USB role switch driver needs parent driver owner info. This is a |
672 | * suboptimal solution. TODO: Need to revisit this in a follow-up patch |
673 | * where an optimal solution is possible with changes to USB role |
674 | * switch driver. |
675 | */ |
676 | port->dev.driver = devm_kzalloc(dev: &port->dev, |
677 | size: sizeof(struct device_driver), |
678 | GFP_KERNEL); |
679 | if (!port->dev.driver) |
680 | return -ENOMEM; |
681 | |
682 | port->dev.driver->owner = THIS_MODULE; |
683 | |
684 | port->usb_role_sw = usb_role_switch_register(parent: &port->dev, |
685 | desc: &role_sx_desc); |
686 | if (IS_ERR(ptr: port->usb_role_sw)) { |
687 | err = PTR_ERR(ptr: port->usb_role_sw); |
688 | dev_err(&port->dev, "failed to register USB role switch: %d" , |
689 | err); |
690 | return err; |
691 | } |
692 | |
693 | INIT_WORK(&port->usb_phy_work, tegra_xusb_usb_phy_work); |
694 | usb_role_switch_set_drvdata(sw: port->usb_role_sw, data: port); |
695 | |
696 | port->usb_phy.otg = devm_kzalloc(dev: &port->dev, size: sizeof(struct usb_otg), |
697 | GFP_KERNEL); |
698 | if (!port->usb_phy.otg) |
699 | return -ENOMEM; |
700 | |
701 | lane = tegra_xusb_find_lane(padctl: port->padctl, type: "usb2" , index: port->index); |
702 | |
703 | /* |
704 | * Assign phy dev to usb-phy dev. Host/device drivers can use phy |
705 | * reference to retrieve usb-phy details. |
706 | */ |
707 | port->usb_phy.dev = &lane->pad->lanes[port->index]->dev; |
708 | port->usb_phy.dev->driver = port->dev.driver; |
709 | port->usb_phy.otg->usb_phy = &port->usb_phy; |
710 | port->usb_phy.otg->set_peripheral = tegra_xusb_set_peripheral; |
711 | port->usb_phy.otg->set_host = tegra_xusb_set_host; |
712 | |
713 | err = usb_add_phy_dev(&port->usb_phy); |
714 | if (err < 0) { |
715 | dev_err(&port->dev, "Failed to add USB PHY: %d\n" , err); |
716 | return err; |
717 | } |
718 | |
719 | /* populate connector entry */ |
720 | of_platform_populate(root: port->dev.of_node, NULL, NULL, parent: &port->dev); |
721 | |
722 | return err; |
723 | } |
724 | |
725 | static void tegra_xusb_parse_usb_role_default_mode(struct tegra_xusb_port *port) |
726 | { |
727 | enum usb_role role = USB_ROLE_NONE; |
728 | enum usb_dr_mode mode = usb_get_role_switch_default_mode(dev: &port->dev); |
729 | |
730 | if (mode == USB_DR_MODE_HOST) |
731 | role = USB_ROLE_HOST; |
732 | else if (mode == USB_DR_MODE_PERIPHERAL) |
733 | role = USB_ROLE_DEVICE; |
734 | |
735 | if (role != USB_ROLE_NONE) { |
736 | usb_role_switch_set_role(sw: port->usb_role_sw, role); |
737 | dev_dbg(&port->dev, "usb role default mode is %s" , modes[mode]); |
738 | } |
739 | } |
740 | |
741 | static int tegra_xusb_usb2_port_parse_dt(struct tegra_xusb_usb2_port *usb2) |
742 | { |
743 | struct tegra_xusb_port *port = &usb2->base; |
744 | struct device_node *np = port->dev.of_node; |
745 | const char *mode; |
746 | int err; |
747 | |
748 | usb2->internal = of_property_read_bool(np, propname: "nvidia,internal" ); |
749 | |
750 | if (!of_property_read_string(np, propname: "mode" , out_string: &mode)) { |
751 | int err = match_string(array: modes, ARRAY_SIZE(modes), string: mode); |
752 | if (err < 0) { |
753 | dev_err(&port->dev, "invalid value %s for \"mode\"\n" , |
754 | mode); |
755 | usb2->mode = USB_DR_MODE_UNKNOWN; |
756 | } else { |
757 | usb2->mode = err; |
758 | } |
759 | } else { |
760 | usb2->mode = USB_DR_MODE_HOST; |
761 | } |
762 | |
763 | /* usb-role-switch property is mandatory for OTG/Peripheral modes */ |
764 | if (usb2->mode == USB_DR_MODE_PERIPHERAL || |
765 | usb2->mode == USB_DR_MODE_OTG) { |
766 | if (of_property_read_bool(np, propname: "usb-role-switch" )) { |
767 | err = tegra_xusb_setup_usb_role_switch(port); |
768 | if (err < 0) |
769 | return err; |
770 | tegra_xusb_parse_usb_role_default_mode(port); |
771 | } else { |
772 | dev_err(&port->dev, "usb-role-switch not found for %s mode" , |
773 | modes[usb2->mode]); |
774 | return -EINVAL; |
775 | } |
776 | } |
777 | |
778 | usb2->supply = regulator_get(dev: &port->dev, id: "vbus" ); |
779 | return PTR_ERR_OR_ZERO(ptr: usb2->supply); |
780 | } |
781 | |
782 | static int tegra_xusb_add_usb2_port(struct tegra_xusb_padctl *padctl, |
783 | unsigned int index) |
784 | { |
785 | struct tegra_xusb_usb2_port *usb2; |
786 | struct device_node *np; |
787 | int err = 0; |
788 | |
789 | /* |
790 | * USB2 ports don't require additional properties, but if the port is |
791 | * marked as disabled there is no reason to register it. |
792 | */ |
793 | np = tegra_xusb_find_port_node(padctl, type: "usb2" , index); |
794 | if (!np || !of_device_is_available(device: np)) |
795 | goto out; |
796 | |
797 | usb2 = kzalloc(size: sizeof(*usb2), GFP_KERNEL); |
798 | if (!usb2) { |
799 | err = -ENOMEM; |
800 | goto out; |
801 | } |
802 | |
803 | err = tegra_xusb_port_init(port: &usb2->base, padctl, np, name: "usb2" , index); |
804 | if (err < 0) |
805 | goto out; |
806 | |
807 | usb2->base.ops = padctl->soc->ports.usb2.ops; |
808 | |
809 | usb2->base.lane = usb2->base.ops->map(&usb2->base); |
810 | if (IS_ERR(ptr: usb2->base.lane)) { |
811 | err = PTR_ERR(ptr: usb2->base.lane); |
812 | tegra_xusb_port_unregister(port: &usb2->base); |
813 | goto out; |
814 | } |
815 | |
816 | err = tegra_xusb_usb2_port_parse_dt(usb2); |
817 | if (err < 0) { |
818 | tegra_xusb_port_unregister(port: &usb2->base); |
819 | goto out; |
820 | } |
821 | |
822 | list_add_tail(new: &usb2->base.list, head: &padctl->ports); |
823 | |
824 | out: |
825 | of_node_put(node: np); |
826 | return err; |
827 | } |
828 | |
829 | void tegra_xusb_usb2_port_release(struct tegra_xusb_port *port) |
830 | { |
831 | struct tegra_xusb_usb2_port *usb2 = to_usb2_port(port); |
832 | |
833 | kfree(objp: usb2); |
834 | } |
835 | |
836 | void tegra_xusb_usb2_port_remove(struct tegra_xusb_port *port) |
837 | { |
838 | struct tegra_xusb_usb2_port *usb2 = to_usb2_port(port); |
839 | |
840 | regulator_put(regulator: usb2->supply); |
841 | } |
842 | |
843 | static int tegra_xusb_ulpi_port_parse_dt(struct tegra_xusb_ulpi_port *ulpi) |
844 | { |
845 | struct tegra_xusb_port *port = &ulpi->base; |
846 | struct device_node *np = port->dev.of_node; |
847 | |
848 | ulpi->internal = of_property_read_bool(np, propname: "nvidia,internal" ); |
849 | |
850 | return 0; |
851 | } |
852 | |
853 | static int tegra_xusb_add_ulpi_port(struct tegra_xusb_padctl *padctl, |
854 | unsigned int index) |
855 | { |
856 | struct tegra_xusb_ulpi_port *ulpi; |
857 | struct device_node *np; |
858 | int err = 0; |
859 | |
860 | np = tegra_xusb_find_port_node(padctl, type: "ulpi" , index); |
861 | if (!np || !of_device_is_available(device: np)) |
862 | goto out; |
863 | |
864 | ulpi = kzalloc(size: sizeof(*ulpi), GFP_KERNEL); |
865 | if (!ulpi) { |
866 | err = -ENOMEM; |
867 | goto out; |
868 | } |
869 | |
870 | err = tegra_xusb_port_init(port: &ulpi->base, padctl, np, name: "ulpi" , index); |
871 | if (err < 0) |
872 | goto out; |
873 | |
874 | ulpi->base.ops = padctl->soc->ports.ulpi.ops; |
875 | |
876 | ulpi->base.lane = ulpi->base.ops->map(&ulpi->base); |
877 | if (IS_ERR(ptr: ulpi->base.lane)) { |
878 | err = PTR_ERR(ptr: ulpi->base.lane); |
879 | tegra_xusb_port_unregister(port: &ulpi->base); |
880 | goto out; |
881 | } |
882 | |
883 | err = tegra_xusb_ulpi_port_parse_dt(ulpi); |
884 | if (err < 0) { |
885 | tegra_xusb_port_unregister(port: &ulpi->base); |
886 | goto out; |
887 | } |
888 | |
889 | list_add_tail(new: &ulpi->base.list, head: &padctl->ports); |
890 | |
891 | out: |
892 | of_node_put(node: np); |
893 | return err; |
894 | } |
895 | |
896 | void tegra_xusb_ulpi_port_release(struct tegra_xusb_port *port) |
897 | { |
898 | struct tegra_xusb_ulpi_port *ulpi = to_ulpi_port(port); |
899 | |
900 | kfree(objp: ulpi); |
901 | } |
902 | |
903 | static int tegra_xusb_hsic_port_parse_dt(struct tegra_xusb_hsic_port *hsic) |
904 | { |
905 | /* XXX */ |
906 | return 0; |
907 | } |
908 | |
909 | static int tegra_xusb_add_hsic_port(struct tegra_xusb_padctl *padctl, |
910 | unsigned int index) |
911 | { |
912 | struct tegra_xusb_hsic_port *hsic; |
913 | struct device_node *np; |
914 | int err = 0; |
915 | |
916 | np = tegra_xusb_find_port_node(padctl, type: "hsic" , index); |
917 | if (!np || !of_device_is_available(device: np)) |
918 | goto out; |
919 | |
920 | hsic = kzalloc(size: sizeof(*hsic), GFP_KERNEL); |
921 | if (!hsic) { |
922 | err = -ENOMEM; |
923 | goto out; |
924 | } |
925 | |
926 | err = tegra_xusb_port_init(port: &hsic->base, padctl, np, name: "hsic" , index); |
927 | if (err < 0) |
928 | goto out; |
929 | |
930 | hsic->base.ops = padctl->soc->ports.hsic.ops; |
931 | |
932 | hsic->base.lane = hsic->base.ops->map(&hsic->base); |
933 | if (IS_ERR(ptr: hsic->base.lane)) { |
934 | err = PTR_ERR(ptr: hsic->base.lane); |
935 | goto out; |
936 | } |
937 | |
938 | err = tegra_xusb_hsic_port_parse_dt(hsic); |
939 | if (err < 0) { |
940 | tegra_xusb_port_unregister(port: &hsic->base); |
941 | goto out; |
942 | } |
943 | |
944 | list_add_tail(new: &hsic->base.list, head: &padctl->ports); |
945 | |
946 | out: |
947 | of_node_put(node: np); |
948 | return err; |
949 | } |
950 | |
951 | void tegra_xusb_hsic_port_release(struct tegra_xusb_port *port) |
952 | { |
953 | struct tegra_xusb_hsic_port *hsic = to_hsic_port(port); |
954 | |
955 | kfree(objp: hsic); |
956 | } |
957 | |
958 | static int tegra_xusb_usb3_port_parse_dt(struct tegra_xusb_usb3_port *usb3) |
959 | { |
960 | struct tegra_xusb_port *port = &usb3->base; |
961 | struct device_node *np = port->dev.of_node; |
962 | enum usb_device_speed maximum_speed; |
963 | u32 value; |
964 | int err; |
965 | |
966 | err = of_property_read_u32(np, propname: "nvidia,usb2-companion" , out_value: &value); |
967 | if (err < 0) { |
968 | dev_err(&port->dev, "failed to read port: %d\n" , err); |
969 | return err; |
970 | } |
971 | |
972 | usb3->port = value; |
973 | |
974 | usb3->internal = of_property_read_bool(np, propname: "nvidia,internal" ); |
975 | |
976 | if (device_property_present(dev: &port->dev, propname: "maximum-speed" )) { |
977 | maximum_speed = usb_get_maximum_speed(dev: &port->dev); |
978 | if (maximum_speed == USB_SPEED_SUPER) |
979 | usb3->disable_gen2 = true; |
980 | else if (maximum_speed == USB_SPEED_SUPER_PLUS) |
981 | usb3->disable_gen2 = false; |
982 | else |
983 | return -EINVAL; |
984 | } |
985 | |
986 | return 0; |
987 | } |
988 | |
989 | static int tegra_xusb_add_usb3_port(struct tegra_xusb_padctl *padctl, |
990 | unsigned int index) |
991 | { |
992 | struct tegra_xusb_usb3_port *usb3; |
993 | struct device_node *np; |
994 | int err = 0; |
995 | |
996 | /* |
997 | * If there is no supplemental configuration in the device tree the |
998 | * port is unusable. But it is valid to configure only a single port, |
999 | * hence return 0 instead of an error to allow ports to be optional. |
1000 | */ |
1001 | np = tegra_xusb_find_port_node(padctl, type: "usb3" , index); |
1002 | if (!np || !of_device_is_available(device: np)) |
1003 | goto out; |
1004 | |
1005 | usb3 = kzalloc(size: sizeof(*usb3), GFP_KERNEL); |
1006 | if (!usb3) { |
1007 | err = -ENOMEM; |
1008 | goto out; |
1009 | } |
1010 | |
1011 | err = tegra_xusb_port_init(port: &usb3->base, padctl, np, name: "usb3" , index); |
1012 | if (err < 0) |
1013 | goto out; |
1014 | |
1015 | usb3->base.ops = padctl->soc->ports.usb3.ops; |
1016 | |
1017 | usb3->base.lane = usb3->base.ops->map(&usb3->base); |
1018 | if (IS_ERR(ptr: usb3->base.lane)) { |
1019 | err = PTR_ERR(ptr: usb3->base.lane); |
1020 | goto out; |
1021 | } |
1022 | |
1023 | err = tegra_xusb_usb3_port_parse_dt(usb3); |
1024 | if (err < 0) { |
1025 | tegra_xusb_port_unregister(port: &usb3->base); |
1026 | goto out; |
1027 | } |
1028 | |
1029 | list_add_tail(new: &usb3->base.list, head: &padctl->ports); |
1030 | |
1031 | out: |
1032 | of_node_put(node: np); |
1033 | return err; |
1034 | } |
1035 | |
1036 | void tegra_xusb_usb3_port_release(struct tegra_xusb_port *port) |
1037 | { |
1038 | struct tegra_xusb_usb3_port *usb3 = to_usb3_port(port); |
1039 | |
1040 | kfree(objp: usb3); |
1041 | } |
1042 | |
1043 | static void __tegra_xusb_remove_ports(struct tegra_xusb_padctl *padctl) |
1044 | { |
1045 | struct tegra_xusb_port *port, *tmp; |
1046 | |
1047 | list_for_each_entry_safe_reverse(port, tmp, &padctl->ports, list) { |
1048 | list_del(entry: &port->list); |
1049 | tegra_xusb_port_unregister(port); |
1050 | } |
1051 | } |
1052 | |
1053 | static int tegra_xusb_find_unused_usb3_port(struct tegra_xusb_padctl *padctl) |
1054 | { |
1055 | struct device_node *np; |
1056 | unsigned int i; |
1057 | |
1058 | for (i = 0; i < padctl->soc->ports.usb3.count; i++) { |
1059 | np = tegra_xusb_find_port_node(padctl, type: "usb3" , index: i); |
1060 | if (!np || !of_device_is_available(device: np)) |
1061 | return i; |
1062 | } |
1063 | |
1064 | return -ENODEV; |
1065 | } |
1066 | |
1067 | static bool tegra_xusb_port_is_companion(struct tegra_xusb_usb2_port *usb2) |
1068 | { |
1069 | unsigned int i; |
1070 | struct tegra_xusb_usb3_port *usb3; |
1071 | struct tegra_xusb_padctl *padctl = usb2->base.padctl; |
1072 | |
1073 | for (i = 0; i < padctl->soc->ports.usb3.count; i++) { |
1074 | usb3 = tegra_xusb_find_usb3_port(padctl, index: i); |
1075 | if (usb3 && usb3->port == usb2->base.index) |
1076 | return true; |
1077 | } |
1078 | |
1079 | return false; |
1080 | } |
1081 | |
1082 | static int tegra_xusb_update_usb3_fake_port(struct tegra_xusb_usb2_port *usb2) |
1083 | { |
1084 | int fake; |
1085 | |
1086 | /* Disable usb3_port_fake usage by default and assign if needed */ |
1087 | usb2->usb3_port_fake = -1; |
1088 | |
1089 | if ((usb2->mode == USB_DR_MODE_OTG || |
1090 | usb2->mode == USB_DR_MODE_PERIPHERAL) && |
1091 | !tegra_xusb_port_is_companion(usb2)) { |
1092 | fake = tegra_xusb_find_unused_usb3_port(padctl: usb2->base.padctl); |
1093 | if (fake < 0) { |
1094 | dev_err(&usb2->base.dev, "no unused USB3 ports available\n" ); |
1095 | return -ENODEV; |
1096 | } |
1097 | |
1098 | dev_dbg(&usb2->base.dev, "Found unused usb3 port: %d\n" , fake); |
1099 | usb2->usb3_port_fake = fake; |
1100 | } |
1101 | |
1102 | return 0; |
1103 | } |
1104 | |
1105 | static int tegra_xusb_setup_ports(struct tegra_xusb_padctl *padctl) |
1106 | { |
1107 | struct tegra_xusb_port *port; |
1108 | struct tegra_xusb_usb2_port *usb2; |
1109 | unsigned int i; |
1110 | int err = 0; |
1111 | |
1112 | mutex_lock(&padctl->lock); |
1113 | |
1114 | for (i = 0; i < padctl->soc->ports.usb2.count; i++) { |
1115 | err = tegra_xusb_add_usb2_port(padctl, index: i); |
1116 | if (err < 0) |
1117 | goto remove_ports; |
1118 | } |
1119 | |
1120 | for (i = 0; i < padctl->soc->ports.ulpi.count; i++) { |
1121 | err = tegra_xusb_add_ulpi_port(padctl, index: i); |
1122 | if (err < 0) |
1123 | goto remove_ports; |
1124 | } |
1125 | |
1126 | for (i = 0; i < padctl->soc->ports.hsic.count; i++) { |
1127 | err = tegra_xusb_add_hsic_port(padctl, index: i); |
1128 | if (err < 0) |
1129 | goto remove_ports; |
1130 | } |
1131 | |
1132 | for (i = 0; i < padctl->soc->ports.usb3.count; i++) { |
1133 | err = tegra_xusb_add_usb3_port(padctl, index: i); |
1134 | if (err < 0) |
1135 | goto remove_ports; |
1136 | } |
1137 | |
1138 | if (padctl->soc->need_fake_usb3_port) { |
1139 | for (i = 0; i < padctl->soc->ports.usb2.count; i++) { |
1140 | usb2 = tegra_xusb_find_usb2_port(padctl, index: i); |
1141 | if (!usb2) |
1142 | continue; |
1143 | |
1144 | err = tegra_xusb_update_usb3_fake_port(usb2); |
1145 | if (err < 0) |
1146 | goto remove_ports; |
1147 | } |
1148 | } |
1149 | |
1150 | list_for_each_entry(port, &padctl->ports, list) { |
1151 | err = port->ops->enable(port); |
1152 | if (err < 0) |
1153 | dev_err(padctl->dev, "failed to enable port %s: %d\n" , |
1154 | dev_name(&port->dev), err); |
1155 | } |
1156 | |
1157 | goto unlock; |
1158 | |
1159 | remove_ports: |
1160 | __tegra_xusb_remove_ports(padctl); |
1161 | unlock: |
1162 | mutex_unlock(lock: &padctl->lock); |
1163 | return err; |
1164 | } |
1165 | |
1166 | static void tegra_xusb_remove_ports(struct tegra_xusb_padctl *padctl) |
1167 | { |
1168 | mutex_lock(&padctl->lock); |
1169 | __tegra_xusb_remove_ports(padctl); |
1170 | mutex_unlock(lock: &padctl->lock); |
1171 | } |
1172 | |
1173 | static int tegra_xusb_padctl_probe(struct platform_device *pdev) |
1174 | { |
1175 | struct device_node *np = pdev->dev.of_node; |
1176 | const struct tegra_xusb_padctl_soc *soc; |
1177 | struct tegra_xusb_padctl *padctl; |
1178 | const struct of_device_id *match; |
1179 | int err; |
1180 | |
1181 | /* for backwards compatibility with old device trees */ |
1182 | np = of_get_child_by_name(node: np, name: "pads" ); |
1183 | if (!np) { |
1184 | dev_warn(&pdev->dev, "deprecated DT, using legacy driver\n" ); |
1185 | return tegra_xusb_padctl_legacy_probe(pdev); |
1186 | } |
1187 | |
1188 | of_node_put(node: np); |
1189 | |
1190 | match = of_match_node(matches: tegra_xusb_padctl_of_match, node: pdev->dev.of_node); |
1191 | soc = match->data; |
1192 | |
1193 | padctl = soc->ops->probe(&pdev->dev, soc); |
1194 | if (IS_ERR(ptr: padctl)) |
1195 | return PTR_ERR(ptr: padctl); |
1196 | |
1197 | platform_set_drvdata(pdev, data: padctl); |
1198 | INIT_LIST_HEAD(list: &padctl->ports); |
1199 | INIT_LIST_HEAD(list: &padctl->lanes); |
1200 | INIT_LIST_HEAD(list: &padctl->pads); |
1201 | mutex_init(&padctl->lock); |
1202 | |
1203 | padctl->regs = devm_platform_ioremap_resource(pdev, index: 0); |
1204 | if (IS_ERR(ptr: padctl->regs)) { |
1205 | err = PTR_ERR(ptr: padctl->regs); |
1206 | goto remove; |
1207 | } |
1208 | |
1209 | padctl->rst = devm_reset_control_get(dev: &pdev->dev, NULL); |
1210 | if (IS_ERR(ptr: padctl->rst)) { |
1211 | err = PTR_ERR(ptr: padctl->rst); |
1212 | goto remove; |
1213 | } |
1214 | |
1215 | padctl->supplies = devm_kcalloc(dev: &pdev->dev, n: padctl->soc->num_supplies, |
1216 | size: sizeof(*padctl->supplies), GFP_KERNEL); |
1217 | if (!padctl->supplies) { |
1218 | err = -ENOMEM; |
1219 | goto remove; |
1220 | } |
1221 | |
1222 | regulator_bulk_set_supply_names(consumers: padctl->supplies, |
1223 | supply_names: padctl->soc->supply_names, |
1224 | num_supplies: padctl->soc->num_supplies); |
1225 | |
1226 | err = devm_regulator_bulk_get(dev: &pdev->dev, num_consumers: padctl->soc->num_supplies, |
1227 | consumers: padctl->supplies); |
1228 | if (err < 0) { |
1229 | dev_err_probe(dev: &pdev->dev, err, fmt: "failed to get regulators\n" ); |
1230 | goto remove; |
1231 | } |
1232 | |
1233 | err = reset_control_deassert(rstc: padctl->rst); |
1234 | if (err < 0) |
1235 | goto remove; |
1236 | |
1237 | err = regulator_bulk_enable(num_consumers: padctl->soc->num_supplies, |
1238 | consumers: padctl->supplies); |
1239 | if (err < 0) { |
1240 | dev_err(&pdev->dev, "failed to enable supplies: %d\n" , err); |
1241 | goto reset; |
1242 | } |
1243 | |
1244 | err = tegra_xusb_setup_pads(padctl); |
1245 | if (err < 0) { |
1246 | dev_err(&pdev->dev, "failed to setup pads: %d\n" , err); |
1247 | goto power_down; |
1248 | } |
1249 | |
1250 | err = tegra_xusb_setup_ports(padctl); |
1251 | if (err) { |
1252 | const char *level = KERN_ERR; |
1253 | |
1254 | if (err == -EPROBE_DEFER) |
1255 | level = KERN_DEBUG; |
1256 | |
1257 | dev_printk(level, &pdev->dev, |
1258 | dev_fmt("failed to setup XUSB ports: %d\n" ), err); |
1259 | goto remove_pads; |
1260 | } |
1261 | |
1262 | return 0; |
1263 | |
1264 | remove_pads: |
1265 | tegra_xusb_remove_pads(padctl); |
1266 | power_down: |
1267 | regulator_bulk_disable(num_consumers: padctl->soc->num_supplies, consumers: padctl->supplies); |
1268 | reset: |
1269 | reset_control_assert(rstc: padctl->rst); |
1270 | remove: |
1271 | platform_set_drvdata(pdev, NULL); |
1272 | soc->ops->remove(padctl); |
1273 | return err; |
1274 | } |
1275 | |
1276 | static void tegra_xusb_padctl_remove(struct platform_device *pdev) |
1277 | { |
1278 | struct tegra_xusb_padctl *padctl = platform_get_drvdata(pdev); |
1279 | int err; |
1280 | |
1281 | tegra_xusb_remove_ports(padctl); |
1282 | tegra_xusb_remove_pads(padctl); |
1283 | |
1284 | err = regulator_bulk_disable(num_consumers: padctl->soc->num_supplies, |
1285 | consumers: padctl->supplies); |
1286 | if (err < 0) |
1287 | dev_err(&pdev->dev, "failed to disable supplies: %d\n" , err); |
1288 | |
1289 | err = reset_control_assert(rstc: padctl->rst); |
1290 | if (err < 0) |
1291 | dev_err(&pdev->dev, "failed to assert reset: %d\n" , err); |
1292 | |
1293 | padctl->soc->ops->remove(padctl); |
1294 | } |
1295 | |
1296 | static __maybe_unused int tegra_xusb_padctl_suspend_noirq(struct device *dev) |
1297 | { |
1298 | struct tegra_xusb_padctl *padctl = dev_get_drvdata(dev); |
1299 | |
1300 | if (padctl->soc && padctl->soc->ops && padctl->soc->ops->suspend_noirq) |
1301 | return padctl->soc->ops->suspend_noirq(padctl); |
1302 | |
1303 | return 0; |
1304 | } |
1305 | |
1306 | static __maybe_unused int tegra_xusb_padctl_resume_noirq(struct device *dev) |
1307 | { |
1308 | struct tegra_xusb_padctl *padctl = dev_get_drvdata(dev); |
1309 | |
1310 | if (padctl->soc && padctl->soc->ops && padctl->soc->ops->resume_noirq) |
1311 | return padctl->soc->ops->resume_noirq(padctl); |
1312 | |
1313 | return 0; |
1314 | } |
1315 | |
1316 | static const struct dev_pm_ops tegra_xusb_padctl_pm_ops = { |
1317 | SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(tegra_xusb_padctl_suspend_noirq, |
1318 | tegra_xusb_padctl_resume_noirq) |
1319 | }; |
1320 | |
1321 | static struct platform_driver tegra_xusb_padctl_driver = { |
1322 | .driver = { |
1323 | .name = "tegra-xusb-padctl" , |
1324 | .of_match_table = tegra_xusb_padctl_of_match, |
1325 | .pm = &tegra_xusb_padctl_pm_ops, |
1326 | }, |
1327 | .probe = tegra_xusb_padctl_probe, |
1328 | .remove_new = tegra_xusb_padctl_remove, |
1329 | }; |
1330 | module_platform_driver(tegra_xusb_padctl_driver); |
1331 | |
1332 | struct tegra_xusb_padctl *tegra_xusb_padctl_get(struct device *dev) |
1333 | { |
1334 | struct tegra_xusb_padctl *padctl; |
1335 | struct platform_device *pdev; |
1336 | struct device_node *np; |
1337 | |
1338 | np = of_parse_phandle(np: dev->of_node, phandle_name: "nvidia,xusb-padctl" , index: 0); |
1339 | if (!np) |
1340 | return ERR_PTR(error: -EINVAL); |
1341 | |
1342 | /* |
1343 | * This is slightly ugly. A better implementation would be to keep a |
1344 | * registry of pad controllers, but since there will almost certainly |
1345 | * only ever be one per SoC that would be a little overkill. |
1346 | */ |
1347 | pdev = of_find_device_by_node(np); |
1348 | if (!pdev) { |
1349 | of_node_put(node: np); |
1350 | return ERR_PTR(error: -ENODEV); |
1351 | } |
1352 | |
1353 | of_node_put(node: np); |
1354 | |
1355 | padctl = platform_get_drvdata(pdev); |
1356 | if (!padctl) { |
1357 | put_device(dev: &pdev->dev); |
1358 | return ERR_PTR(error: -EPROBE_DEFER); |
1359 | } |
1360 | |
1361 | return padctl; |
1362 | } |
1363 | EXPORT_SYMBOL_GPL(tegra_xusb_padctl_get); |
1364 | |
1365 | void tegra_xusb_padctl_put(struct tegra_xusb_padctl *padctl) |
1366 | { |
1367 | if (padctl) |
1368 | put_device(dev: padctl->dev); |
1369 | } |
1370 | EXPORT_SYMBOL_GPL(tegra_xusb_padctl_put); |
1371 | |
1372 | int tegra_xusb_padctl_usb3_save_context(struct tegra_xusb_padctl *padctl, |
1373 | unsigned int port) |
1374 | { |
1375 | if (padctl->soc->ops->usb3_save_context) |
1376 | return padctl->soc->ops->usb3_save_context(padctl, port); |
1377 | |
1378 | return -ENOSYS; |
1379 | } |
1380 | EXPORT_SYMBOL_GPL(tegra_xusb_padctl_usb3_save_context); |
1381 | |
1382 | int tegra_xusb_padctl_hsic_set_idle(struct tegra_xusb_padctl *padctl, |
1383 | unsigned int port, bool idle) |
1384 | { |
1385 | if (padctl->soc->ops->hsic_set_idle) |
1386 | return padctl->soc->ops->hsic_set_idle(padctl, port, idle); |
1387 | |
1388 | return -ENOSYS; |
1389 | } |
1390 | EXPORT_SYMBOL_GPL(tegra_xusb_padctl_hsic_set_idle); |
1391 | |
1392 | int tegra_xusb_padctl_enable_phy_sleepwalk(struct tegra_xusb_padctl *padctl, struct phy *phy, |
1393 | enum usb_device_speed speed) |
1394 | { |
1395 | struct tegra_xusb_lane *lane = phy_get_drvdata(phy); |
1396 | |
1397 | if (lane->pad->ops->enable_phy_sleepwalk) |
1398 | return lane->pad->ops->enable_phy_sleepwalk(lane, speed); |
1399 | |
1400 | return -EOPNOTSUPP; |
1401 | } |
1402 | EXPORT_SYMBOL_GPL(tegra_xusb_padctl_enable_phy_sleepwalk); |
1403 | |
1404 | int tegra_xusb_padctl_disable_phy_sleepwalk(struct tegra_xusb_padctl *padctl, struct phy *phy) |
1405 | { |
1406 | struct tegra_xusb_lane *lane = phy_get_drvdata(phy); |
1407 | |
1408 | if (lane->pad->ops->disable_phy_sleepwalk) |
1409 | return lane->pad->ops->disable_phy_sleepwalk(lane); |
1410 | |
1411 | return -EOPNOTSUPP; |
1412 | } |
1413 | EXPORT_SYMBOL_GPL(tegra_xusb_padctl_disable_phy_sleepwalk); |
1414 | |
1415 | int tegra_xusb_padctl_enable_phy_wake(struct tegra_xusb_padctl *padctl, struct phy *phy) |
1416 | { |
1417 | struct tegra_xusb_lane *lane = phy_get_drvdata(phy); |
1418 | |
1419 | if (lane->pad->ops->enable_phy_wake) |
1420 | return lane->pad->ops->enable_phy_wake(lane); |
1421 | |
1422 | return -EOPNOTSUPP; |
1423 | } |
1424 | EXPORT_SYMBOL_GPL(tegra_xusb_padctl_enable_phy_wake); |
1425 | |
1426 | int tegra_xusb_padctl_disable_phy_wake(struct tegra_xusb_padctl *padctl, struct phy *phy) |
1427 | { |
1428 | struct tegra_xusb_lane *lane = phy_get_drvdata(phy); |
1429 | |
1430 | if (lane->pad->ops->disable_phy_wake) |
1431 | return lane->pad->ops->disable_phy_wake(lane); |
1432 | |
1433 | return -EOPNOTSUPP; |
1434 | } |
1435 | EXPORT_SYMBOL_GPL(tegra_xusb_padctl_disable_phy_wake); |
1436 | |
1437 | bool tegra_xusb_padctl_remote_wake_detected(struct tegra_xusb_padctl *padctl, struct phy *phy) |
1438 | { |
1439 | struct tegra_xusb_lane *lane = phy_get_drvdata(phy); |
1440 | |
1441 | if (lane->pad->ops->remote_wake_detected) |
1442 | return lane->pad->ops->remote_wake_detected(lane); |
1443 | |
1444 | return false; |
1445 | } |
1446 | EXPORT_SYMBOL_GPL(tegra_xusb_padctl_remote_wake_detected); |
1447 | |
1448 | int tegra_xusb_padctl_usb3_set_lfps_detect(struct tegra_xusb_padctl *padctl, |
1449 | unsigned int port, bool enable) |
1450 | { |
1451 | if (padctl->soc->ops->usb3_set_lfps_detect) |
1452 | return padctl->soc->ops->usb3_set_lfps_detect(padctl, port, |
1453 | enable); |
1454 | |
1455 | return -ENOSYS; |
1456 | } |
1457 | EXPORT_SYMBOL_GPL(tegra_xusb_padctl_usb3_set_lfps_detect); |
1458 | |
1459 | int tegra_xusb_padctl_set_vbus_override(struct tegra_xusb_padctl *padctl, |
1460 | bool val) |
1461 | { |
1462 | if (padctl->soc->ops->vbus_override) |
1463 | return padctl->soc->ops->vbus_override(padctl, val); |
1464 | |
1465 | return -ENOTSUPP; |
1466 | } |
1467 | EXPORT_SYMBOL_GPL(tegra_xusb_padctl_set_vbus_override); |
1468 | |
1469 | int tegra_phy_xusb_utmi_port_reset(struct phy *phy) |
1470 | { |
1471 | struct tegra_xusb_lane *lane = phy_get_drvdata(phy); |
1472 | struct tegra_xusb_padctl *padctl = lane->pad->padctl; |
1473 | |
1474 | if (padctl->soc->ops->utmi_port_reset) |
1475 | return padctl->soc->ops->utmi_port_reset(phy); |
1476 | |
1477 | return -ENOTSUPP; |
1478 | } |
1479 | EXPORT_SYMBOL_GPL(tegra_phy_xusb_utmi_port_reset); |
1480 | |
1481 | void tegra_phy_xusb_utmi_pad_power_on(struct phy *phy) |
1482 | { |
1483 | struct tegra_xusb_lane *lane; |
1484 | struct tegra_xusb_padctl *padctl; |
1485 | |
1486 | if (!phy) |
1487 | return; |
1488 | |
1489 | lane = phy_get_drvdata(phy); |
1490 | padctl = lane->pad->padctl; |
1491 | |
1492 | if (padctl->soc->ops->utmi_pad_power_on) |
1493 | padctl->soc->ops->utmi_pad_power_on(phy); |
1494 | } |
1495 | EXPORT_SYMBOL_GPL(tegra_phy_xusb_utmi_pad_power_on); |
1496 | |
1497 | void tegra_phy_xusb_utmi_pad_power_down(struct phy *phy) |
1498 | { |
1499 | struct tegra_xusb_lane *lane; |
1500 | struct tegra_xusb_padctl *padctl; |
1501 | |
1502 | if (!phy) |
1503 | return; |
1504 | |
1505 | lane = phy_get_drvdata(phy); |
1506 | padctl = lane->pad->padctl; |
1507 | |
1508 | if (padctl->soc->ops->utmi_pad_power_down) |
1509 | padctl->soc->ops->utmi_pad_power_down(phy); |
1510 | } |
1511 | EXPORT_SYMBOL_GPL(tegra_phy_xusb_utmi_pad_power_down); |
1512 | |
1513 | int tegra_xusb_padctl_get_usb3_companion(struct tegra_xusb_padctl *padctl, |
1514 | unsigned int port) |
1515 | { |
1516 | struct tegra_xusb_usb2_port *usb2; |
1517 | struct tegra_xusb_usb3_port *usb3; |
1518 | int i; |
1519 | |
1520 | usb2 = tegra_xusb_find_usb2_port(padctl, index: port); |
1521 | if (!usb2) |
1522 | return -EINVAL; |
1523 | |
1524 | for (i = 0; i < padctl->soc->ports.usb3.count; i++) { |
1525 | usb3 = tegra_xusb_find_usb3_port(padctl, index: i); |
1526 | if (usb3 && usb3->port == usb2->base.index) |
1527 | return usb3->base.index; |
1528 | } |
1529 | |
1530 | return -ENODEV; |
1531 | } |
1532 | EXPORT_SYMBOL_GPL(tegra_xusb_padctl_get_usb3_companion); |
1533 | |
1534 | MODULE_AUTHOR("Thierry Reding <treding@nvidia.com>" ); |
1535 | MODULE_DESCRIPTION("Tegra XUSB Pad Controller driver" ); |
1536 | MODULE_LICENSE("GPL v2" ); |
1537 | |