]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/usb/phy/phy-ab8500-usb.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'nfs-for-4.15-3' of git://git.linux-nfs.org/projects/anna/linux-nfs
[mirror_ubuntu-bionic-kernel.git] / drivers / usb / phy / phy-ab8500-usb.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * USB transceiver driver for AB8500 family chips
4 *
5 * Copyright (C) 2010-2013 ST-Ericsson AB
6 * Mian Yousaf Kaukab <mian.yousaf.kaukab@stericsson.com>
7 * Avinash Kumar <avinash.kumar@stericsson.com>
8 * Thirupathi Chippakurthy <thirupathi.chippakurthy@stericsson.com>
9 */
10
11 #include <linux/module.h>
12 #include <linux/platform_device.h>
13 #include <linux/usb/otg.h>
14 #include <linux/slab.h>
15 #include <linux/notifier.h>
16 #include <linux/interrupt.h>
17 #include <linux/delay.h>
18 #include <linux/clk.h>
19 #include <linux/err.h>
20 #include <linux/mfd/abx500.h>
21 #include <linux/mfd/abx500/ab8500.h>
22 #include <linux/usb/musb-ux500.h>
23 #include <linux/regulator/consumer.h>
24 #include <linux/pinctrl/consumer.h>
25
26 /* Bank AB8500_SYS_CTRL2_BLOCK */
27 #define AB8500_MAIN_WD_CTRL_REG 0x01
28
29 /* Bank AB8500_USB */
30 #define AB8500_USB_LINE_STAT_REG 0x80
31 #define AB8505_USB_LINE_STAT_REG 0x94
32 #define AB8540_USB_LINK_STAT_REG 0x94
33 #define AB9540_USB_LINK_STAT_REG 0x94
34 #define AB8540_USB_OTG_CTL_REG 0x87
35 #define AB8500_USB_PHY_CTRL_REG 0x8A
36 #define AB8540_VBUS_CTRL_REG 0x82
37
38 /* Bank AB8500_DEVELOPMENT */
39 #define AB8500_BANK12_ACCESS 0x00
40
41 /* Bank AB8500_DEBUG */
42 #define AB8540_DEBUG 0x32
43 #define AB8500_USB_PHY_TUNE1 0x05
44 #define AB8500_USB_PHY_TUNE2 0x06
45 #define AB8500_USB_PHY_TUNE3 0x07
46
47 /* Bank AB8500_INTERRUPT */
48 #define AB8500_IT_SOURCE2_REG 0x01
49
50 #define AB8500_BIT_OTG_STAT_ID (1 << 0)
51 #define AB8500_BIT_PHY_CTRL_HOST_EN (1 << 0)
52 #define AB8500_BIT_PHY_CTRL_DEVICE_EN (1 << 1)
53 #define AB8500_BIT_WD_CTRL_ENABLE (1 << 0)
54 #define AB8500_BIT_WD_CTRL_KICK (1 << 1)
55 #define AB8500_BIT_SOURCE2_VBUSDET (1 << 7)
56 #define AB8540_BIT_OTG_CTL_VBUS_VALID_ENA (1 << 0)
57 #define AB8540_BIT_OTG_CTL_ID_HOST_ENA (1 << 1)
58 #define AB8540_BIT_OTG_CTL_ID_DEV_ENA (1 << 5)
59 #define AB8540_BIT_VBUS_CTRL_CHARG_DET_ENA (1 << 0)
60
61 #define AB8500_WD_KICK_DELAY_US 100 /* usec */
62 #define AB8500_WD_V11_DISABLE_DELAY_US 100 /* usec */
63 #define AB8500_V20_31952_DISABLE_DELAY_US 100 /* usec */
64
65 /* Usb line status register */
66 enum ab8500_usb_link_status {
67 USB_LINK_NOT_CONFIGURED_8500 = 0,
68 USB_LINK_STD_HOST_NC_8500,
69 USB_LINK_STD_HOST_C_NS_8500,
70 USB_LINK_STD_HOST_C_S_8500,
71 USB_LINK_HOST_CHG_NM_8500,
72 USB_LINK_HOST_CHG_HS_8500,
73 USB_LINK_HOST_CHG_HS_CHIRP_8500,
74 USB_LINK_DEDICATED_CHG_8500,
75 USB_LINK_ACA_RID_A_8500,
76 USB_LINK_ACA_RID_B_8500,
77 USB_LINK_ACA_RID_C_NM_8500,
78 USB_LINK_ACA_RID_C_HS_8500,
79 USB_LINK_ACA_RID_C_HS_CHIRP_8500,
80 USB_LINK_HM_IDGND_8500,
81 USB_LINK_RESERVED_8500,
82 USB_LINK_NOT_VALID_LINK_8500,
83 };
84
85 enum ab8505_usb_link_status {
86 USB_LINK_NOT_CONFIGURED_8505 = 0,
87 USB_LINK_STD_HOST_NC_8505,
88 USB_LINK_STD_HOST_C_NS_8505,
89 USB_LINK_STD_HOST_C_S_8505,
90 USB_LINK_CDP_8505,
91 USB_LINK_RESERVED0_8505,
92 USB_LINK_RESERVED1_8505,
93 USB_LINK_DEDICATED_CHG_8505,
94 USB_LINK_ACA_RID_A_8505,
95 USB_LINK_ACA_RID_B_8505,
96 USB_LINK_ACA_RID_C_NM_8505,
97 USB_LINK_RESERVED2_8505,
98 USB_LINK_RESERVED3_8505,
99 USB_LINK_HM_IDGND_8505,
100 USB_LINK_CHARGERPORT_NOT_OK_8505,
101 USB_LINK_CHARGER_DM_HIGH_8505,
102 USB_LINK_PHYEN_NO_VBUS_NO_IDGND_8505,
103 USB_LINK_STD_UPSTREAM_NO_IDGNG_NO_VBUS_8505,
104 USB_LINK_STD_UPSTREAM_8505,
105 USB_LINK_CHARGER_SE1_8505,
106 USB_LINK_CARKIT_CHGR_1_8505,
107 USB_LINK_CARKIT_CHGR_2_8505,
108 USB_LINK_ACA_DOCK_CHGR_8505,
109 USB_LINK_SAMSUNG_BOOT_CBL_PHY_EN_8505,
110 USB_LINK_SAMSUNG_BOOT_CBL_PHY_DISB_8505,
111 USB_LINK_SAMSUNG_UART_CBL_PHY_EN_8505,
112 USB_LINK_SAMSUNG_UART_CBL_PHY_DISB_8505,
113 USB_LINK_MOTOROLA_FACTORY_CBL_PHY_EN_8505,
114 };
115
116 enum ab8540_usb_link_status {
117 USB_LINK_NOT_CONFIGURED_8540 = 0,
118 USB_LINK_STD_HOST_NC_8540,
119 USB_LINK_STD_HOST_C_NS_8540,
120 USB_LINK_STD_HOST_C_S_8540,
121 USB_LINK_CDP_8540,
122 USB_LINK_RESERVED0_8540,
123 USB_LINK_RESERVED1_8540,
124 USB_LINK_DEDICATED_CHG_8540,
125 USB_LINK_ACA_RID_A_8540,
126 USB_LINK_ACA_RID_B_8540,
127 USB_LINK_ACA_RID_C_NM_8540,
128 USB_LINK_RESERVED2_8540,
129 USB_LINK_RESERVED3_8540,
130 USB_LINK_HM_IDGND_8540,
131 USB_LINK_CHARGERPORT_NOT_OK_8540,
132 USB_LINK_CHARGER_DM_HIGH_8540,
133 USB_LINK_PHYEN_NO_VBUS_NO_IDGND_8540,
134 USB_LINK_STD_UPSTREAM_NO_IDGNG_VBUS_8540,
135 USB_LINK_STD_UPSTREAM_8540,
136 USB_LINK_CHARGER_SE1_8540,
137 USB_LINK_CARKIT_CHGR_1_8540,
138 USB_LINK_CARKIT_CHGR_2_8540,
139 USB_LINK_ACA_DOCK_CHGR_8540,
140 USB_LINK_SAMSUNG_BOOT_CBL_PHY_EN_8540,
141 USB_LINK_SAMSUNG_BOOT_CBL_PHY_DISB_8540,
142 USB_LINK_SAMSUNG_UART_CBL_PHY_EN_8540,
143 USB_LINK_SAMSUNG_UART_CBL_PHY_DISB_8540,
144 USB_LINK_MOTOROLA_FACTORY_CBL_PHY_EN_8540
145 };
146
147 enum ab9540_usb_link_status {
148 USB_LINK_NOT_CONFIGURED_9540 = 0,
149 USB_LINK_STD_HOST_NC_9540,
150 USB_LINK_STD_HOST_C_NS_9540,
151 USB_LINK_STD_HOST_C_S_9540,
152 USB_LINK_CDP_9540,
153 USB_LINK_RESERVED0_9540,
154 USB_LINK_RESERVED1_9540,
155 USB_LINK_DEDICATED_CHG_9540,
156 USB_LINK_ACA_RID_A_9540,
157 USB_LINK_ACA_RID_B_9540,
158 USB_LINK_ACA_RID_C_NM_9540,
159 USB_LINK_RESERVED2_9540,
160 USB_LINK_RESERVED3_9540,
161 USB_LINK_HM_IDGND_9540,
162 USB_LINK_CHARGERPORT_NOT_OK_9540,
163 USB_LINK_CHARGER_DM_HIGH_9540,
164 USB_LINK_PHYEN_NO_VBUS_NO_IDGND_9540,
165 USB_LINK_STD_UPSTREAM_NO_IDGNG_VBUS_9540,
166 USB_LINK_STD_UPSTREAM_9540,
167 USB_LINK_CHARGER_SE1_9540,
168 USB_LINK_CARKIT_CHGR_1_9540,
169 USB_LINK_CARKIT_CHGR_2_9540,
170 USB_LINK_ACA_DOCK_CHGR_9540,
171 USB_LINK_SAMSUNG_BOOT_CBL_PHY_EN_9540,
172 USB_LINK_SAMSUNG_BOOT_CBL_PHY_DISB_9540,
173 USB_LINK_SAMSUNG_UART_CBL_PHY_EN_9540,
174 USB_LINK_SAMSUNG_UART_CBL_PHY_DISB_9540,
175 USB_LINK_MOTOROLA_FACTORY_CBL_PHY_EN_9540
176 };
177
178 enum ab8500_usb_mode {
179 USB_IDLE = 0,
180 USB_PERIPHERAL,
181 USB_HOST,
182 USB_DEDICATED_CHG
183 };
184
185 /* Register USB_LINK_STATUS interrupt */
186 #define AB8500_USB_FLAG_USE_LINK_STATUS_IRQ (1 << 0)
187 /* Register ID_WAKEUP_F interrupt */
188 #define AB8500_USB_FLAG_USE_ID_WAKEUP_IRQ (1 << 1)
189 /* Register VBUS_DET_F interrupt */
190 #define AB8500_USB_FLAG_USE_VBUS_DET_IRQ (1 << 2)
191 /* Driver is using the ab-iddet driver*/
192 #define AB8500_USB_FLAG_USE_AB_IDDET (1 << 3)
193 /* Enable setting regulators voltage */
194 #define AB8500_USB_FLAG_REGULATOR_SET_VOLTAGE (1 << 4)
195 /* Enable the check_vbus_status workaround */
196 #define AB8500_USB_FLAG_USE_CHECK_VBUS_STATUS (1 << 5)
197 /* Enable the vbus host workaround */
198 #define AB8500_USB_FLAG_USE_VBUS_HOST_QUIRK (1 << 6)
199
200 struct ab8500_usb {
201 struct usb_phy phy;
202 struct device *dev;
203 struct ab8500 *ab8500;
204 unsigned vbus_draw;
205 struct work_struct phy_dis_work;
206 struct work_struct vbus_event_work;
207 enum ab8500_usb_mode mode;
208 struct clk *sysclk;
209 struct regulator *v_ape;
210 struct regulator *v_musb;
211 struct regulator *v_ulpi;
212 int saved_v_ulpi;
213 int previous_link_status_state;
214 struct pinctrl *pinctrl;
215 struct pinctrl_state *pins_sleep;
216 bool enabled_charging_detection;
217 unsigned int flags;
218 };
219
220 static inline struct ab8500_usb *phy_to_ab(struct usb_phy *x)
221 {
222 return container_of(x, struct ab8500_usb, phy);
223 }
224
225 static void ab8500_usb_wd_workaround(struct ab8500_usb *ab)
226 {
227 abx500_set_register_interruptible(ab->dev,
228 AB8500_SYS_CTRL2_BLOCK,
229 AB8500_MAIN_WD_CTRL_REG,
230 AB8500_BIT_WD_CTRL_ENABLE);
231
232 udelay(AB8500_WD_KICK_DELAY_US);
233
234 abx500_set_register_interruptible(ab->dev,
235 AB8500_SYS_CTRL2_BLOCK,
236 AB8500_MAIN_WD_CTRL_REG,
237 (AB8500_BIT_WD_CTRL_ENABLE
238 | AB8500_BIT_WD_CTRL_KICK));
239
240 udelay(AB8500_WD_V11_DISABLE_DELAY_US);
241
242 abx500_set_register_interruptible(ab->dev,
243 AB8500_SYS_CTRL2_BLOCK,
244 AB8500_MAIN_WD_CTRL_REG,
245 0);
246 }
247
248 static void ab8500_usb_regulator_enable(struct ab8500_usb *ab)
249 {
250 int ret, volt;
251
252 ret = regulator_enable(ab->v_ape);
253 if (ret)
254 dev_err(ab->dev, "Failed to enable v-ape\n");
255
256 if (ab->flags & AB8500_USB_FLAG_REGULATOR_SET_VOLTAGE) {
257 ab->saved_v_ulpi = regulator_get_voltage(ab->v_ulpi);
258 if (ab->saved_v_ulpi < 0)
259 dev_err(ab->dev, "Failed to get v_ulpi voltage\n");
260
261 ret = regulator_set_voltage(ab->v_ulpi, 1300000, 1350000);
262 if (ret < 0)
263 dev_err(ab->dev, "Failed to set the Vintcore to 1.3V, ret=%d\n",
264 ret);
265
266 ret = regulator_set_load(ab->v_ulpi, 28000);
267 if (ret < 0)
268 dev_err(ab->dev, "Failed to set optimum mode (ret=%d)\n",
269 ret);
270 }
271
272 ret = regulator_enable(ab->v_ulpi);
273 if (ret)
274 dev_err(ab->dev, "Failed to enable vddulpivio18\n");
275
276 if (ab->flags & AB8500_USB_FLAG_REGULATOR_SET_VOLTAGE) {
277 volt = regulator_get_voltage(ab->v_ulpi);
278 if ((volt != 1300000) && (volt != 1350000))
279 dev_err(ab->dev, "Vintcore is not set to 1.3V volt=%d\n",
280 volt);
281 }
282
283 ret = regulator_enable(ab->v_musb);
284 if (ret)
285 dev_err(ab->dev, "Failed to enable musb_1v8\n");
286 }
287
288 static void ab8500_usb_regulator_disable(struct ab8500_usb *ab)
289 {
290 int ret;
291
292 regulator_disable(ab->v_musb);
293
294 regulator_disable(ab->v_ulpi);
295
296 /* USB is not the only consumer of Vintcore, restore old settings */
297 if (ab->flags & AB8500_USB_FLAG_REGULATOR_SET_VOLTAGE) {
298 if (ab->saved_v_ulpi > 0) {
299 ret = regulator_set_voltage(ab->v_ulpi,
300 ab->saved_v_ulpi, ab->saved_v_ulpi);
301 if (ret < 0)
302 dev_err(ab->dev, "Failed to set the Vintcore to %duV, ret=%d\n",
303 ab->saved_v_ulpi, ret);
304 }
305
306 ret = regulator_set_load(ab->v_ulpi, 0);
307 if (ret < 0)
308 dev_err(ab->dev, "Failed to set optimum mode (ret=%d)\n",
309 ret);
310 }
311
312 regulator_disable(ab->v_ape);
313 }
314
315 static void ab8500_usb_wd_linkstatus(struct ab8500_usb *ab, u8 bit)
316 {
317 /* Workaround for v2.0 bug # 31952 */
318 if (is_ab8500_2p0(ab->ab8500)) {
319 abx500_mask_and_set_register_interruptible(ab->dev,
320 AB8500_USB, AB8500_USB_PHY_CTRL_REG,
321 bit, bit);
322 udelay(AB8500_V20_31952_DISABLE_DELAY_US);
323 }
324 }
325
326 static void ab8500_usb_phy_enable(struct ab8500_usb *ab, bool sel_host)
327 {
328 u8 bit;
329 bit = sel_host ? AB8500_BIT_PHY_CTRL_HOST_EN :
330 AB8500_BIT_PHY_CTRL_DEVICE_EN;
331
332 /* mux and configure USB pins to DEFAULT state */
333 ab->pinctrl = pinctrl_get_select(ab->dev, PINCTRL_STATE_DEFAULT);
334 if (IS_ERR(ab->pinctrl))
335 dev_err(ab->dev, "could not get/set default pinstate\n");
336
337 if (clk_prepare_enable(ab->sysclk))
338 dev_err(ab->dev, "can't prepare/enable clock\n");
339
340 ab8500_usb_regulator_enable(ab);
341
342 abx500_mask_and_set_register_interruptible(ab->dev,
343 AB8500_USB, AB8500_USB_PHY_CTRL_REG,
344 bit, bit);
345
346 if (ab->flags & AB8500_USB_FLAG_USE_VBUS_HOST_QUIRK) {
347 if (sel_host)
348 abx500_set_register_interruptible(ab->dev,
349 AB8500_USB, AB8540_USB_OTG_CTL_REG,
350 AB8540_BIT_OTG_CTL_VBUS_VALID_ENA |
351 AB8540_BIT_OTG_CTL_ID_HOST_ENA |
352 AB8540_BIT_OTG_CTL_ID_DEV_ENA);
353 }
354 }
355
356 static void ab8500_usb_phy_disable(struct ab8500_usb *ab, bool sel_host)
357 {
358 u8 bit;
359 bit = sel_host ? AB8500_BIT_PHY_CTRL_HOST_EN :
360 AB8500_BIT_PHY_CTRL_DEVICE_EN;
361
362 ab8500_usb_wd_linkstatus(ab, bit);
363
364 abx500_mask_and_set_register_interruptible(ab->dev,
365 AB8500_USB, AB8500_USB_PHY_CTRL_REG,
366 bit, 0);
367
368 /* Needed to disable the phy.*/
369 ab8500_usb_wd_workaround(ab);
370
371 clk_disable_unprepare(ab->sysclk);
372
373 ab8500_usb_regulator_disable(ab);
374
375 if (!IS_ERR(ab->pinctrl)) {
376 /* configure USB pins to SLEEP state */
377 ab->pins_sleep = pinctrl_lookup_state(ab->pinctrl,
378 PINCTRL_STATE_SLEEP);
379
380 if (IS_ERR(ab->pins_sleep))
381 dev_dbg(ab->dev, "could not get sleep pinstate\n");
382 else if (pinctrl_select_state(ab->pinctrl, ab->pins_sleep))
383 dev_err(ab->dev, "could not set pins to sleep state\n");
384
385 /*
386 * as USB pins are shared with iddet, release them to allow
387 * iddet to request them
388 */
389 pinctrl_put(ab->pinctrl);
390 }
391 }
392
393 #define ab8500_usb_host_phy_en(ab) ab8500_usb_phy_enable(ab, true)
394 #define ab8500_usb_host_phy_dis(ab) ab8500_usb_phy_disable(ab, true)
395 #define ab8500_usb_peri_phy_en(ab) ab8500_usb_phy_enable(ab, false)
396 #define ab8500_usb_peri_phy_dis(ab) ab8500_usb_phy_disable(ab, false)
397
398 static int ab9540_usb_link_status_update(struct ab8500_usb *ab,
399 enum ab9540_usb_link_status lsts)
400 {
401 enum ux500_musb_vbus_id_status event = 0;
402
403 dev_dbg(ab->dev, "ab9540_usb_link_status_update %d\n", lsts);
404
405 if (ab->previous_link_status_state == USB_LINK_HM_IDGND_9540 &&
406 (lsts == USB_LINK_STD_HOST_C_NS_9540 ||
407 lsts == USB_LINK_STD_HOST_NC_9540))
408 return 0;
409
410 if (ab->previous_link_status_state == USB_LINK_ACA_RID_A_9540 &&
411 (lsts == USB_LINK_STD_HOST_NC_9540))
412 return 0;
413
414 ab->previous_link_status_state = lsts;
415
416 switch (lsts) {
417 case USB_LINK_ACA_RID_B_9540:
418 event = UX500_MUSB_RIDB;
419 case USB_LINK_NOT_CONFIGURED_9540:
420 case USB_LINK_RESERVED0_9540:
421 case USB_LINK_RESERVED1_9540:
422 case USB_LINK_RESERVED2_9540:
423 case USB_LINK_RESERVED3_9540:
424 if (ab->mode == USB_PERIPHERAL)
425 atomic_notifier_call_chain(&ab->phy.notifier,
426 UX500_MUSB_CLEAN, &ab->vbus_draw);
427 ab->mode = USB_IDLE;
428 ab->phy.otg->default_a = false;
429 ab->vbus_draw = 0;
430 if (event != UX500_MUSB_RIDB)
431 event = UX500_MUSB_NONE;
432 /* Fallback to default B_IDLE as nothing is connected. */
433 ab->phy.otg->state = OTG_STATE_B_IDLE;
434 usb_phy_set_event(&ab->phy, USB_EVENT_NONE);
435 break;
436
437 case USB_LINK_ACA_RID_C_NM_9540:
438 event = UX500_MUSB_RIDC;
439 case USB_LINK_STD_HOST_NC_9540:
440 case USB_LINK_STD_HOST_C_NS_9540:
441 case USB_LINK_STD_HOST_C_S_9540:
442 case USB_LINK_CDP_9540:
443 if (ab->mode == USB_HOST) {
444 ab->mode = USB_PERIPHERAL;
445 ab8500_usb_host_phy_dis(ab);
446 ab8500_usb_peri_phy_en(ab);
447 atomic_notifier_call_chain(&ab->phy.notifier,
448 UX500_MUSB_PREPARE, &ab->vbus_draw);
449 usb_phy_set_event(&ab->phy, USB_EVENT_ENUMERATED);
450 }
451 if (ab->mode == USB_IDLE) {
452 ab->mode = USB_PERIPHERAL;
453 ab8500_usb_peri_phy_en(ab);
454 atomic_notifier_call_chain(&ab->phy.notifier,
455 UX500_MUSB_PREPARE, &ab->vbus_draw);
456 usb_phy_set_event(&ab->phy, USB_EVENT_ENUMERATED);
457 }
458 if (event != UX500_MUSB_RIDC)
459 event = UX500_MUSB_VBUS;
460 break;
461
462 case USB_LINK_ACA_RID_A_9540:
463 event = UX500_MUSB_RIDA;
464 case USB_LINK_HM_IDGND_9540:
465 case USB_LINK_STD_UPSTREAM_9540:
466 if (ab->mode == USB_PERIPHERAL) {
467 ab->mode = USB_HOST;
468 ab8500_usb_peri_phy_dis(ab);
469 ab8500_usb_host_phy_en(ab);
470 atomic_notifier_call_chain(&ab->phy.notifier,
471 UX500_MUSB_PREPARE, &ab->vbus_draw);
472 }
473 if (ab->mode == USB_IDLE) {
474 ab->mode = USB_HOST;
475 ab8500_usb_host_phy_en(ab);
476 atomic_notifier_call_chain(&ab->phy.notifier,
477 UX500_MUSB_PREPARE, &ab->vbus_draw);
478 }
479 ab->phy.otg->default_a = true;
480 if (event != UX500_MUSB_RIDA)
481 event = UX500_MUSB_ID;
482
483 atomic_notifier_call_chain(&ab->phy.notifier,
484 event, &ab->vbus_draw);
485 break;
486
487 case USB_LINK_DEDICATED_CHG_9540:
488 ab->mode = USB_DEDICATED_CHG;
489 event = UX500_MUSB_CHARGER;
490 atomic_notifier_call_chain(&ab->phy.notifier,
491 event, &ab->vbus_draw);
492 usb_phy_set_event(&ab->phy, USB_EVENT_CHARGER);
493 break;
494
495 case USB_LINK_PHYEN_NO_VBUS_NO_IDGND_9540:
496 case USB_LINK_STD_UPSTREAM_NO_IDGNG_VBUS_9540:
497 if (!(is_ab9540_2p0_or_earlier(ab->ab8500))) {
498 event = UX500_MUSB_NONE;
499 if (ab->mode == USB_HOST) {
500 ab->phy.otg->default_a = false;
501 ab->vbus_draw = 0;
502 atomic_notifier_call_chain(&ab->phy.notifier,
503 event, &ab->vbus_draw);
504 ab8500_usb_host_phy_dis(ab);
505 ab->mode = USB_IDLE;
506 }
507 if (ab->mode == USB_PERIPHERAL) {
508 atomic_notifier_call_chain(&ab->phy.notifier,
509 event, &ab->vbus_draw);
510 ab8500_usb_peri_phy_dis(ab);
511 atomic_notifier_call_chain(&ab->phy.notifier,
512 UX500_MUSB_CLEAN,
513 &ab->vbus_draw);
514 ab->mode = USB_IDLE;
515 ab->phy.otg->default_a = false;
516 ab->vbus_draw = 0;
517 usb_phy_set_event(&ab->phy, USB_EVENT_NONE);
518 }
519 }
520 break;
521
522 default:
523 break;
524 }
525
526 return 0;
527 }
528
529 static int ab8540_usb_link_status_update(struct ab8500_usb *ab,
530 enum ab8540_usb_link_status lsts)
531 {
532 enum ux500_musb_vbus_id_status event = 0;
533
534 dev_dbg(ab->dev, "ab8540_usb_link_status_update %d\n", lsts);
535
536 if (ab->enabled_charging_detection) {
537 /* Disable USB Charger detection */
538 abx500_mask_and_set_register_interruptible(ab->dev,
539 AB8500_USB, AB8540_VBUS_CTRL_REG,
540 AB8540_BIT_VBUS_CTRL_CHARG_DET_ENA, 0x00);
541 ab->enabled_charging_detection = false;
542 }
543
544 /*
545 * Spurious link_status interrupts are seen in case of a
546 * disconnection of a device in IDGND and RIDA stage
547 */
548 if (ab->previous_link_status_state == USB_LINK_HM_IDGND_8540 &&
549 (lsts == USB_LINK_STD_HOST_C_NS_8540 ||
550 lsts == USB_LINK_STD_HOST_NC_8540))
551 return 0;
552
553 if (ab->previous_link_status_state == USB_LINK_ACA_RID_A_8540 &&
554 (lsts == USB_LINK_STD_HOST_NC_8540))
555 return 0;
556
557 ab->previous_link_status_state = lsts;
558
559 switch (lsts) {
560 case USB_LINK_ACA_RID_B_8540:
561 event = UX500_MUSB_RIDB;
562 case USB_LINK_NOT_CONFIGURED_8540:
563 case USB_LINK_RESERVED0_8540:
564 case USB_LINK_RESERVED1_8540:
565 case USB_LINK_RESERVED2_8540:
566 case USB_LINK_RESERVED3_8540:
567 ab->mode = USB_IDLE;
568 ab->phy.otg->default_a = false;
569 ab->vbus_draw = 0;
570 if (event != UX500_MUSB_RIDB)
571 event = UX500_MUSB_NONE;
572 /*
573 * Fallback to default B_IDLE as nothing
574 * is connected
575 */
576 ab->phy.otg->state = OTG_STATE_B_IDLE;
577 usb_phy_set_event(&ab->phy, USB_EVENT_NONE);
578 break;
579
580 case USB_LINK_ACA_RID_C_NM_8540:
581 event = UX500_MUSB_RIDC;
582 case USB_LINK_STD_HOST_NC_8540:
583 case USB_LINK_STD_HOST_C_NS_8540:
584 case USB_LINK_STD_HOST_C_S_8540:
585 case USB_LINK_CDP_8540:
586 if (ab->mode == USB_IDLE) {
587 ab->mode = USB_PERIPHERAL;
588 ab8500_usb_peri_phy_en(ab);
589 atomic_notifier_call_chain(&ab->phy.notifier,
590 UX500_MUSB_PREPARE, &ab->vbus_draw);
591 usb_phy_set_event(&ab->phy, USB_EVENT_ENUMERATED);
592 }
593 if (event != UX500_MUSB_RIDC)
594 event = UX500_MUSB_VBUS;
595 break;
596
597 case USB_LINK_ACA_RID_A_8540:
598 case USB_LINK_ACA_DOCK_CHGR_8540:
599 event = UX500_MUSB_RIDA;
600 case USB_LINK_HM_IDGND_8540:
601 case USB_LINK_STD_UPSTREAM_8540:
602 if (ab->mode == USB_IDLE) {
603 ab->mode = USB_HOST;
604 ab8500_usb_host_phy_en(ab);
605 atomic_notifier_call_chain(&ab->phy.notifier,
606 UX500_MUSB_PREPARE, &ab->vbus_draw);
607 }
608 ab->phy.otg->default_a = true;
609 if (event != UX500_MUSB_RIDA)
610 event = UX500_MUSB_ID;
611 atomic_notifier_call_chain(&ab->phy.notifier,
612 event, &ab->vbus_draw);
613 break;
614
615 case USB_LINK_DEDICATED_CHG_8540:
616 ab->mode = USB_DEDICATED_CHG;
617 event = UX500_MUSB_CHARGER;
618 atomic_notifier_call_chain(&ab->phy.notifier,
619 event, &ab->vbus_draw);
620 usb_phy_set_event(&ab->phy, USB_EVENT_CHARGER);
621 break;
622
623 case USB_LINK_PHYEN_NO_VBUS_NO_IDGND_8540:
624 case USB_LINK_STD_UPSTREAM_NO_IDGNG_VBUS_8540:
625 event = UX500_MUSB_NONE;
626 if (ab->mode == USB_HOST) {
627 ab->phy.otg->default_a = false;
628 ab->vbus_draw = 0;
629 atomic_notifier_call_chain(&ab->phy.notifier,
630 event, &ab->vbus_draw);
631 ab8500_usb_host_phy_dis(ab);
632 ab->mode = USB_IDLE;
633 }
634 if (ab->mode == USB_PERIPHERAL) {
635 atomic_notifier_call_chain(&ab->phy.notifier,
636 event, &ab->vbus_draw);
637 ab8500_usb_peri_phy_dis(ab);
638 atomic_notifier_call_chain(&ab->phy.notifier,
639 UX500_MUSB_CLEAN, &ab->vbus_draw);
640 ab->mode = USB_IDLE;
641 ab->phy.otg->default_a = false;
642 ab->vbus_draw = 0;
643 usb_phy_set_event(&ab->phy, USB_EVENT_NONE);
644 }
645 break;
646
647 default:
648 event = UX500_MUSB_NONE;
649 break;
650 }
651
652 return 0;
653 }
654
655 static int ab8505_usb_link_status_update(struct ab8500_usb *ab,
656 enum ab8505_usb_link_status lsts)
657 {
658 enum ux500_musb_vbus_id_status event = 0;
659
660 dev_dbg(ab->dev, "ab8505_usb_link_status_update %d\n", lsts);
661
662 /*
663 * Spurious link_status interrupts are seen at the time of
664 * disconnection of a device in RIDA state
665 */
666 if (ab->previous_link_status_state == USB_LINK_ACA_RID_A_8505 &&
667 (lsts == USB_LINK_STD_HOST_NC_8505))
668 return 0;
669
670 ab->previous_link_status_state = lsts;
671
672 switch (lsts) {
673 case USB_LINK_ACA_RID_B_8505:
674 event = UX500_MUSB_RIDB;
675 case USB_LINK_NOT_CONFIGURED_8505:
676 case USB_LINK_RESERVED0_8505:
677 case USB_LINK_RESERVED1_8505:
678 case USB_LINK_RESERVED2_8505:
679 case USB_LINK_RESERVED3_8505:
680 ab->mode = USB_IDLE;
681 ab->phy.otg->default_a = false;
682 ab->vbus_draw = 0;
683 if (event != UX500_MUSB_RIDB)
684 event = UX500_MUSB_NONE;
685 /*
686 * Fallback to default B_IDLE as nothing
687 * is connected
688 */
689 ab->phy.otg->state = OTG_STATE_B_IDLE;
690 usb_phy_set_event(&ab->phy, USB_EVENT_NONE);
691 break;
692
693 case USB_LINK_ACA_RID_C_NM_8505:
694 event = UX500_MUSB_RIDC;
695 case USB_LINK_STD_HOST_NC_8505:
696 case USB_LINK_STD_HOST_C_NS_8505:
697 case USB_LINK_STD_HOST_C_S_8505:
698 case USB_LINK_CDP_8505:
699 if (ab->mode == USB_IDLE) {
700 ab->mode = USB_PERIPHERAL;
701 ab8500_usb_peri_phy_en(ab);
702 atomic_notifier_call_chain(&ab->phy.notifier,
703 UX500_MUSB_PREPARE, &ab->vbus_draw);
704 usb_phy_set_event(&ab->phy, USB_EVENT_ENUMERATED);
705 }
706 if (event != UX500_MUSB_RIDC)
707 event = UX500_MUSB_VBUS;
708 break;
709
710 case USB_LINK_ACA_RID_A_8505:
711 case USB_LINK_ACA_DOCK_CHGR_8505:
712 event = UX500_MUSB_RIDA;
713 case USB_LINK_HM_IDGND_8505:
714 if (ab->mode == USB_IDLE) {
715 ab->mode = USB_HOST;
716 ab8500_usb_host_phy_en(ab);
717 atomic_notifier_call_chain(&ab->phy.notifier,
718 UX500_MUSB_PREPARE, &ab->vbus_draw);
719 }
720 ab->phy.otg->default_a = true;
721 if (event != UX500_MUSB_RIDA)
722 event = UX500_MUSB_ID;
723 atomic_notifier_call_chain(&ab->phy.notifier,
724 event, &ab->vbus_draw);
725 break;
726
727 case USB_LINK_DEDICATED_CHG_8505:
728 ab->mode = USB_DEDICATED_CHG;
729 event = UX500_MUSB_CHARGER;
730 atomic_notifier_call_chain(&ab->phy.notifier,
731 event, &ab->vbus_draw);
732 usb_phy_set_event(&ab->phy, USB_EVENT_CHARGER);
733 break;
734
735 default:
736 break;
737 }
738
739 return 0;
740 }
741
742 static int ab8500_usb_link_status_update(struct ab8500_usb *ab,
743 enum ab8500_usb_link_status lsts)
744 {
745 enum ux500_musb_vbus_id_status event = 0;
746
747 dev_dbg(ab->dev, "ab8500_usb_link_status_update %d\n", lsts);
748
749 /*
750 * Spurious link_status interrupts are seen in case of a
751 * disconnection of a device in IDGND and RIDA stage
752 */
753 if (ab->previous_link_status_state == USB_LINK_HM_IDGND_8500 &&
754 (lsts == USB_LINK_STD_HOST_C_NS_8500 ||
755 lsts == USB_LINK_STD_HOST_NC_8500))
756 return 0;
757
758 if (ab->previous_link_status_state == USB_LINK_ACA_RID_A_8500 &&
759 lsts == USB_LINK_STD_HOST_NC_8500)
760 return 0;
761
762 ab->previous_link_status_state = lsts;
763
764 switch (lsts) {
765 case USB_LINK_ACA_RID_B_8500:
766 event = UX500_MUSB_RIDB;
767 case USB_LINK_NOT_CONFIGURED_8500:
768 case USB_LINK_NOT_VALID_LINK_8500:
769 ab->mode = USB_IDLE;
770 ab->phy.otg->default_a = false;
771 ab->vbus_draw = 0;
772 if (event != UX500_MUSB_RIDB)
773 event = UX500_MUSB_NONE;
774 /* Fallback to default B_IDLE as nothing is connected */
775 ab->phy.otg->state = OTG_STATE_B_IDLE;
776 usb_phy_set_event(&ab->phy, USB_EVENT_NONE);
777 break;
778
779 case USB_LINK_ACA_RID_C_NM_8500:
780 case USB_LINK_ACA_RID_C_HS_8500:
781 case USB_LINK_ACA_RID_C_HS_CHIRP_8500:
782 event = UX500_MUSB_RIDC;
783 case USB_LINK_STD_HOST_NC_8500:
784 case USB_LINK_STD_HOST_C_NS_8500:
785 case USB_LINK_STD_HOST_C_S_8500:
786 case USB_LINK_HOST_CHG_NM_8500:
787 case USB_LINK_HOST_CHG_HS_8500:
788 case USB_LINK_HOST_CHG_HS_CHIRP_8500:
789 if (ab->mode == USB_IDLE) {
790 ab->mode = USB_PERIPHERAL;
791 ab8500_usb_peri_phy_en(ab);
792 atomic_notifier_call_chain(&ab->phy.notifier,
793 UX500_MUSB_PREPARE, &ab->vbus_draw);
794 usb_phy_set_event(&ab->phy, USB_EVENT_ENUMERATED);
795 }
796 if (event != UX500_MUSB_RIDC)
797 event = UX500_MUSB_VBUS;
798 break;
799
800 case USB_LINK_ACA_RID_A_8500:
801 event = UX500_MUSB_RIDA;
802 case USB_LINK_HM_IDGND_8500:
803 if (ab->mode == USB_IDLE) {
804 ab->mode = USB_HOST;
805 ab8500_usb_host_phy_en(ab);
806 atomic_notifier_call_chain(&ab->phy.notifier,
807 UX500_MUSB_PREPARE, &ab->vbus_draw);
808 }
809 ab->phy.otg->default_a = true;
810 if (event != UX500_MUSB_RIDA)
811 event = UX500_MUSB_ID;
812 atomic_notifier_call_chain(&ab->phy.notifier,
813 event, &ab->vbus_draw);
814 break;
815
816 case USB_LINK_DEDICATED_CHG_8500:
817 ab->mode = USB_DEDICATED_CHG;
818 event = UX500_MUSB_CHARGER;
819 atomic_notifier_call_chain(&ab->phy.notifier,
820 event, &ab->vbus_draw);
821 usb_phy_set_event(&ab->phy, USB_EVENT_CHARGER);
822 break;
823
824 case USB_LINK_RESERVED_8500:
825 break;
826 }
827
828 return 0;
829 }
830
831 /*
832 * Connection Sequence:
833 * 1. Link Status Interrupt
834 * 2. Enable AB clock
835 * 3. Enable AB regulators
836 * 4. Enable USB phy
837 * 5. Reset the musb controller
838 * 6. Switch the ULPI GPIO pins to fucntion mode
839 * 7. Enable the musb Peripheral5 clock
840 * 8. Restore MUSB context
841 */
842 static int abx500_usb_link_status_update(struct ab8500_usb *ab)
843 {
844 u8 reg;
845 int ret = 0;
846
847 if (is_ab8500(ab->ab8500)) {
848 enum ab8500_usb_link_status lsts;
849
850 abx500_get_register_interruptible(ab->dev,
851 AB8500_USB, AB8500_USB_LINE_STAT_REG, &reg);
852 lsts = (reg >> 3) & 0x0F;
853 ret = ab8500_usb_link_status_update(ab, lsts);
854 } else if (is_ab8505(ab->ab8500)) {
855 enum ab8505_usb_link_status lsts;
856
857 abx500_get_register_interruptible(ab->dev,
858 AB8500_USB, AB8505_USB_LINE_STAT_REG, &reg);
859 lsts = (reg >> 3) & 0x1F;
860 ret = ab8505_usb_link_status_update(ab, lsts);
861 } else if (is_ab8540(ab->ab8500)) {
862 enum ab8540_usb_link_status lsts;
863
864 abx500_get_register_interruptible(ab->dev,
865 AB8500_USB, AB8540_USB_LINK_STAT_REG, &reg);
866 lsts = (reg >> 3) & 0xFF;
867 ret = ab8540_usb_link_status_update(ab, lsts);
868 } else if (is_ab9540(ab->ab8500)) {
869 enum ab9540_usb_link_status lsts;
870
871 abx500_get_register_interruptible(ab->dev,
872 AB8500_USB, AB9540_USB_LINK_STAT_REG, &reg);
873 lsts = (reg >> 3) & 0xFF;
874 ret = ab9540_usb_link_status_update(ab, lsts);
875 }
876
877 return ret;
878 }
879
880 /*
881 * Disconnection Sequence:
882 * 1. Disconnect Interrupt
883 * 2. Disable regulators
884 * 3. Disable AB clock
885 * 4. Disable the Phy
886 * 5. Link Status Interrupt
887 * 6. Disable Musb Clock
888 */
889 static irqreturn_t ab8500_usb_disconnect_irq(int irq, void *data)
890 {
891 struct ab8500_usb *ab = (struct ab8500_usb *) data;
892 enum usb_phy_events event = UX500_MUSB_NONE;
893
894 /* Link status will not be updated till phy is disabled. */
895 if (ab->mode == USB_HOST) {
896 ab->phy.otg->default_a = false;
897 ab->vbus_draw = 0;
898 atomic_notifier_call_chain(&ab->phy.notifier,
899 event, &ab->vbus_draw);
900 ab8500_usb_host_phy_dis(ab);
901 ab->mode = USB_IDLE;
902 }
903
904 if (ab->mode == USB_PERIPHERAL) {
905 atomic_notifier_call_chain(&ab->phy.notifier,
906 event, &ab->vbus_draw);
907 ab8500_usb_peri_phy_dis(ab);
908 atomic_notifier_call_chain(&ab->phy.notifier,
909 UX500_MUSB_CLEAN, &ab->vbus_draw);
910 ab->mode = USB_IDLE;
911 ab->phy.otg->default_a = false;
912 ab->vbus_draw = 0;
913 }
914
915 if (is_ab8500_2p0(ab->ab8500)) {
916 if (ab->mode == USB_DEDICATED_CHG) {
917 ab8500_usb_wd_linkstatus(ab,
918 AB8500_BIT_PHY_CTRL_DEVICE_EN);
919 abx500_mask_and_set_register_interruptible(ab->dev,
920 AB8500_USB, AB8500_USB_PHY_CTRL_REG,
921 AB8500_BIT_PHY_CTRL_DEVICE_EN, 0);
922 }
923 }
924
925 return IRQ_HANDLED;
926 }
927
928 static irqreturn_t ab8500_usb_link_status_irq(int irq, void *data)
929 {
930 struct ab8500_usb *ab = (struct ab8500_usb *)data;
931
932 abx500_usb_link_status_update(ab);
933
934 return IRQ_HANDLED;
935 }
936
937 static void ab8500_usb_phy_disable_work(struct work_struct *work)
938 {
939 struct ab8500_usb *ab = container_of(work, struct ab8500_usb,
940 phy_dis_work);
941
942 if (!ab->phy.otg->host)
943 ab8500_usb_host_phy_dis(ab);
944
945 if (!ab->phy.otg->gadget)
946 ab8500_usb_peri_phy_dis(ab);
947 }
948
949 /* Check if VBUS is set and linkstatus has not detected a cable. */
950 static bool ab8500_usb_check_vbus_status(struct ab8500_usb *ab)
951 {
952 u8 isource2;
953 u8 reg;
954 enum ab8540_usb_link_status lsts;
955
956 abx500_get_register_interruptible(ab->dev,
957 AB8500_INTERRUPT, AB8500_IT_SOURCE2_REG,
958 &isource2);
959
960 /* If Vbus is below 3.6V abort */
961 if (!(isource2 & AB8500_BIT_SOURCE2_VBUSDET))
962 return false;
963
964 abx500_get_register_interruptible(ab->dev,
965 AB8500_USB, AB8540_USB_LINK_STAT_REG,
966 &reg);
967
968 lsts = (reg >> 3) & 0xFF;
969
970 /* Check if linkstatus has detected a cable */
971 if (lsts)
972 return false;
973
974 return true;
975 }
976
977 /* re-trigger charger detection again with watchdog re-kick. */
978 static void ab8500_usb_vbus_turn_on_event_work(struct work_struct *work)
979 {
980 struct ab8500_usb *ab = container_of(work, struct ab8500_usb,
981 vbus_event_work);
982
983 if (ab->mode != USB_IDLE)
984 return;
985
986 abx500_set_register_interruptible(ab->dev,
987 AB8500_SYS_CTRL2_BLOCK, AB8500_MAIN_WD_CTRL_REG,
988 AB8500_BIT_WD_CTRL_ENABLE);
989
990 udelay(100);
991
992 abx500_set_register_interruptible(ab->dev,
993 AB8500_SYS_CTRL2_BLOCK, AB8500_MAIN_WD_CTRL_REG,
994 AB8500_BIT_WD_CTRL_ENABLE | AB8500_BIT_WD_CTRL_KICK);
995
996 udelay(100);
997
998 /* Disable Main watchdog */
999 abx500_set_register_interruptible(ab->dev,
1000 AB8500_SYS_CTRL2_BLOCK, AB8500_MAIN_WD_CTRL_REG,
1001 0x0);
1002
1003 /* Enable USB Charger detection */
1004 abx500_mask_and_set_register_interruptible(ab->dev,
1005 AB8500_USB, AB8540_VBUS_CTRL_REG,
1006 AB8540_BIT_VBUS_CTRL_CHARG_DET_ENA,
1007 AB8540_BIT_VBUS_CTRL_CHARG_DET_ENA);
1008
1009 ab->enabled_charging_detection = true;
1010 }
1011
1012 static int ab8500_usb_set_suspend(struct usb_phy *x, int suspend)
1013 {
1014 /* TODO */
1015 return 0;
1016 }
1017
1018 static int ab8500_usb_set_peripheral(struct usb_otg *otg,
1019 struct usb_gadget *gadget)
1020 {
1021 struct ab8500_usb *ab;
1022
1023 if (!otg)
1024 return -ENODEV;
1025
1026 ab = phy_to_ab(otg->usb_phy);
1027
1028 ab->phy.otg->gadget = gadget;
1029
1030 /* Some drivers call this function in atomic context.
1031 * Do not update ab8500 registers directly till this
1032 * is fixed.
1033 */
1034
1035 if ((ab->mode != USB_IDLE) && !gadget) {
1036 ab->mode = USB_IDLE;
1037 schedule_work(&ab->phy_dis_work);
1038 }
1039
1040 return 0;
1041 }
1042
1043 static int ab8500_usb_set_host(struct usb_otg *otg, struct usb_bus *host)
1044 {
1045 struct ab8500_usb *ab;
1046
1047 if (!otg)
1048 return -ENODEV;
1049
1050 ab = phy_to_ab(otg->usb_phy);
1051
1052 ab->phy.otg->host = host;
1053
1054 /* Some drivers call this function in atomic context.
1055 * Do not update ab8500 registers directly till this
1056 * is fixed.
1057 */
1058
1059 if ((ab->mode != USB_IDLE) && !host) {
1060 ab->mode = USB_IDLE;
1061 schedule_work(&ab->phy_dis_work);
1062 }
1063
1064 return 0;
1065 }
1066
1067 static void ab8500_usb_restart_phy(struct ab8500_usb *ab)
1068 {
1069 abx500_mask_and_set_register_interruptible(ab->dev,
1070 AB8500_USB, AB8500_USB_PHY_CTRL_REG,
1071 AB8500_BIT_PHY_CTRL_DEVICE_EN,
1072 AB8500_BIT_PHY_CTRL_DEVICE_EN);
1073
1074 udelay(100);
1075
1076 abx500_mask_and_set_register_interruptible(ab->dev,
1077 AB8500_USB, AB8500_USB_PHY_CTRL_REG,
1078 AB8500_BIT_PHY_CTRL_DEVICE_EN,
1079 0);
1080
1081 abx500_mask_and_set_register_interruptible(ab->dev,
1082 AB8500_USB, AB8500_USB_PHY_CTRL_REG,
1083 AB8500_BIT_PHY_CTRL_HOST_EN,
1084 AB8500_BIT_PHY_CTRL_HOST_EN);
1085
1086 udelay(100);
1087
1088 abx500_mask_and_set_register_interruptible(ab->dev,
1089 AB8500_USB, AB8500_USB_PHY_CTRL_REG,
1090 AB8500_BIT_PHY_CTRL_HOST_EN,
1091 0);
1092 }
1093
1094 static int ab8500_usb_regulator_get(struct ab8500_usb *ab)
1095 {
1096 int err;
1097
1098 ab->v_ape = devm_regulator_get(ab->dev, "v-ape");
1099 if (IS_ERR(ab->v_ape)) {
1100 dev_err(ab->dev, "Could not get v-ape supply\n");
1101 err = PTR_ERR(ab->v_ape);
1102 return err;
1103 }
1104
1105 ab->v_ulpi = devm_regulator_get(ab->dev, "vddulpivio18");
1106 if (IS_ERR(ab->v_ulpi)) {
1107 dev_err(ab->dev, "Could not get vddulpivio18 supply\n");
1108 err = PTR_ERR(ab->v_ulpi);
1109 return err;
1110 }
1111
1112 ab->v_musb = devm_regulator_get(ab->dev, "musb_1v8");
1113 if (IS_ERR(ab->v_musb)) {
1114 dev_err(ab->dev, "Could not get musb_1v8 supply\n");
1115 err = PTR_ERR(ab->v_musb);
1116 return err;
1117 }
1118
1119 return 0;
1120 }
1121
1122 static int ab8500_usb_irq_setup(struct platform_device *pdev,
1123 struct ab8500_usb *ab)
1124 {
1125 int err;
1126 int irq;
1127
1128 if (ab->flags & AB8500_USB_FLAG_USE_LINK_STATUS_IRQ) {
1129 irq = platform_get_irq_byname(pdev, "USB_LINK_STATUS");
1130 if (irq < 0) {
1131 dev_err(&pdev->dev, "Link status irq not found\n");
1132 return irq;
1133 }
1134 err = devm_request_threaded_irq(&pdev->dev, irq, NULL,
1135 ab8500_usb_link_status_irq,
1136 IRQF_NO_SUSPEND | IRQF_SHARED | IRQF_ONESHOT,
1137 "usb-link-status", ab);
1138 if (err < 0) {
1139 dev_err(ab->dev, "request_irq failed for link status irq\n");
1140 return err;
1141 }
1142 }
1143
1144 if (ab->flags & AB8500_USB_FLAG_USE_ID_WAKEUP_IRQ) {
1145 irq = platform_get_irq_byname(pdev, "ID_WAKEUP_F");
1146 if (irq < 0) {
1147 dev_err(&pdev->dev, "ID fall irq not found\n");
1148 return irq;
1149 }
1150 err = devm_request_threaded_irq(&pdev->dev, irq, NULL,
1151 ab8500_usb_disconnect_irq,
1152 IRQF_NO_SUSPEND | IRQF_SHARED | IRQF_ONESHOT,
1153 "usb-id-fall", ab);
1154 if (err < 0) {
1155 dev_err(ab->dev, "request_irq failed for ID fall irq\n");
1156 return err;
1157 }
1158 }
1159
1160 if (ab->flags & AB8500_USB_FLAG_USE_VBUS_DET_IRQ) {
1161 irq = platform_get_irq_byname(pdev, "VBUS_DET_F");
1162 if (irq < 0) {
1163 dev_err(&pdev->dev, "VBUS fall irq not found\n");
1164 return irq;
1165 }
1166 err = devm_request_threaded_irq(&pdev->dev, irq, NULL,
1167 ab8500_usb_disconnect_irq,
1168 IRQF_NO_SUSPEND | IRQF_SHARED | IRQF_ONESHOT,
1169 "usb-vbus-fall", ab);
1170 if (err < 0) {
1171 dev_err(ab->dev, "request_irq failed for Vbus fall irq\n");
1172 return err;
1173 }
1174 }
1175
1176 return 0;
1177 }
1178
1179 static void ab8500_usb_set_ab8500_tuning_values(struct ab8500_usb *ab)
1180 {
1181 int err;
1182
1183 /* Enable the PBT/Bank 0x12 access */
1184 err = abx500_set_register_interruptible(ab->dev,
1185 AB8500_DEVELOPMENT, AB8500_BANK12_ACCESS, 0x01);
1186 if (err < 0)
1187 dev_err(ab->dev, "Failed to enable bank12 access err=%d\n",
1188 err);
1189
1190 err = abx500_set_register_interruptible(ab->dev,
1191 AB8500_DEBUG, AB8500_USB_PHY_TUNE1, 0xC8);
1192 if (err < 0)
1193 dev_err(ab->dev, "Failed to set PHY_TUNE1 register err=%d\n",
1194 err);
1195
1196 err = abx500_set_register_interruptible(ab->dev,
1197 AB8500_DEBUG, AB8500_USB_PHY_TUNE2, 0x00);
1198 if (err < 0)
1199 dev_err(ab->dev, "Failed to set PHY_TUNE2 register err=%d\n",
1200 err);
1201
1202 err = abx500_set_register_interruptible(ab->dev,
1203 AB8500_DEBUG, AB8500_USB_PHY_TUNE3, 0x78);
1204 if (err < 0)
1205 dev_err(ab->dev, "Failed to set PHY_TUNE3 register err=%d\n",
1206 err);
1207
1208 /* Switch to normal mode/disable Bank 0x12 access */
1209 err = abx500_set_register_interruptible(ab->dev,
1210 AB8500_DEVELOPMENT, AB8500_BANK12_ACCESS, 0x00);
1211 if (err < 0)
1212 dev_err(ab->dev, "Failed to switch bank12 access err=%d\n",
1213 err);
1214 }
1215
1216 static void ab8500_usb_set_ab8505_tuning_values(struct ab8500_usb *ab)
1217 {
1218 int err;
1219
1220 /* Enable the PBT/Bank 0x12 access */
1221 err = abx500_mask_and_set_register_interruptible(ab->dev,
1222 AB8500_DEVELOPMENT, AB8500_BANK12_ACCESS,
1223 0x01, 0x01);
1224 if (err < 0)
1225 dev_err(ab->dev, "Failed to enable bank12 access err=%d\n",
1226 err);
1227
1228 err = abx500_mask_and_set_register_interruptible(ab->dev,
1229 AB8500_DEBUG, AB8500_USB_PHY_TUNE1,
1230 0xC8, 0xC8);
1231 if (err < 0)
1232 dev_err(ab->dev, "Failed to set PHY_TUNE1 register err=%d\n",
1233 err);
1234
1235 err = abx500_mask_and_set_register_interruptible(ab->dev,
1236 AB8500_DEBUG, AB8500_USB_PHY_TUNE2,
1237 0x60, 0x60);
1238 if (err < 0)
1239 dev_err(ab->dev, "Failed to set PHY_TUNE2 register err=%d\n",
1240 err);
1241
1242 err = abx500_mask_and_set_register_interruptible(ab->dev,
1243 AB8500_DEBUG, AB8500_USB_PHY_TUNE3,
1244 0xFC, 0x80);
1245
1246 if (err < 0)
1247 dev_err(ab->dev, "Failed to set PHY_TUNE3 register err=%d\n",
1248 err);
1249
1250 /* Switch to normal mode/disable Bank 0x12 access */
1251 err = abx500_mask_and_set_register_interruptible(ab->dev,
1252 AB8500_DEVELOPMENT, AB8500_BANK12_ACCESS,
1253 0x00, 0x00);
1254 if (err < 0)
1255 dev_err(ab->dev, "Failed to switch bank12 access err=%d\n",
1256 err);
1257 }
1258
1259 static void ab8500_usb_set_ab8540_tuning_values(struct ab8500_usb *ab)
1260 {
1261 int err;
1262
1263 err = abx500_set_register_interruptible(ab->dev,
1264 AB8540_DEBUG, AB8500_USB_PHY_TUNE1, 0xCC);
1265 if (err < 0)
1266 dev_err(ab->dev, "Failed to set PHY_TUNE1 register ret=%d\n",
1267 err);
1268
1269 err = abx500_set_register_interruptible(ab->dev,
1270 AB8540_DEBUG, AB8500_USB_PHY_TUNE2, 0x60);
1271 if (err < 0)
1272 dev_err(ab->dev, "Failed to set PHY_TUNE2 register ret=%d\n",
1273 err);
1274
1275 err = abx500_set_register_interruptible(ab->dev,
1276 AB8540_DEBUG, AB8500_USB_PHY_TUNE3, 0x90);
1277 if (err < 0)
1278 dev_err(ab->dev, "Failed to set PHY_TUNE3 register ret=%d\n",
1279 err);
1280 }
1281
1282 static void ab8500_usb_set_ab9540_tuning_values(struct ab8500_usb *ab)
1283 {
1284 int err;
1285
1286 /* Enable the PBT/Bank 0x12 access */
1287 err = abx500_set_register_interruptible(ab->dev,
1288 AB8500_DEVELOPMENT, AB8500_BANK12_ACCESS, 0x01);
1289 if (err < 0)
1290 dev_err(ab->dev, "Failed to enable bank12 access err=%d\n",
1291 err);
1292
1293 err = abx500_set_register_interruptible(ab->dev,
1294 AB8500_DEBUG, AB8500_USB_PHY_TUNE1, 0xC8);
1295 if (err < 0)
1296 dev_err(ab->dev, "Failed to set PHY_TUNE1 register err=%d\n",
1297 err);
1298
1299 err = abx500_set_register_interruptible(ab->dev,
1300 AB8500_DEBUG, AB8500_USB_PHY_TUNE2, 0x60);
1301 if (err < 0)
1302 dev_err(ab->dev, "Failed to set PHY_TUNE2 register err=%d\n",
1303 err);
1304
1305 err = abx500_set_register_interruptible(ab->dev,
1306 AB8500_DEBUG, AB8500_USB_PHY_TUNE3, 0x80);
1307 if (err < 0)
1308 dev_err(ab->dev, "Failed to set PHY_TUNE3 register err=%d\n",
1309 err);
1310
1311 /* Switch to normal mode/disable Bank 0x12 access */
1312 err = abx500_set_register_interruptible(ab->dev,
1313 AB8500_DEVELOPMENT, AB8500_BANK12_ACCESS, 0x00);
1314 if (err < 0)
1315 dev_err(ab->dev, "Failed to switch bank12 access err=%d\n",
1316 err);
1317 }
1318
1319 static int ab8500_usb_probe(struct platform_device *pdev)
1320 {
1321 struct ab8500_usb *ab;
1322 struct ab8500 *ab8500;
1323 struct usb_otg *otg;
1324 int err;
1325 int rev;
1326
1327 ab8500 = dev_get_drvdata(pdev->dev.parent);
1328 rev = abx500_get_chip_id(&pdev->dev);
1329
1330 if (is_ab8500_1p1_or_earlier(ab8500)) {
1331 dev_err(&pdev->dev, "Unsupported AB8500 chip rev=%d\n", rev);
1332 return -ENODEV;
1333 }
1334
1335 ab = devm_kzalloc(&pdev->dev, sizeof(*ab), GFP_KERNEL);
1336 if (!ab)
1337 return -ENOMEM;
1338
1339 otg = devm_kzalloc(&pdev->dev, sizeof(*otg), GFP_KERNEL);
1340 if (!otg)
1341 return -ENOMEM;
1342
1343 ab->dev = &pdev->dev;
1344 ab->ab8500 = ab8500;
1345 ab->phy.dev = ab->dev;
1346 ab->phy.otg = otg;
1347 ab->phy.label = "ab8500";
1348 ab->phy.set_suspend = ab8500_usb_set_suspend;
1349 ab->phy.otg->state = OTG_STATE_UNDEFINED;
1350
1351 otg->usb_phy = &ab->phy;
1352 otg->set_host = ab8500_usb_set_host;
1353 otg->set_peripheral = ab8500_usb_set_peripheral;
1354
1355 if (is_ab8500(ab->ab8500)) {
1356 ab->flags |= AB8500_USB_FLAG_USE_LINK_STATUS_IRQ |
1357 AB8500_USB_FLAG_USE_ID_WAKEUP_IRQ |
1358 AB8500_USB_FLAG_USE_VBUS_DET_IRQ |
1359 AB8500_USB_FLAG_REGULATOR_SET_VOLTAGE;
1360 } else if (is_ab8505(ab->ab8500)) {
1361 ab->flags |= AB8500_USB_FLAG_USE_LINK_STATUS_IRQ |
1362 AB8500_USB_FLAG_USE_ID_WAKEUP_IRQ |
1363 AB8500_USB_FLAG_USE_VBUS_DET_IRQ |
1364 AB8500_USB_FLAG_REGULATOR_SET_VOLTAGE;
1365 } else if (is_ab8540(ab->ab8500)) {
1366 ab->flags |= AB8500_USB_FLAG_USE_LINK_STATUS_IRQ |
1367 AB8500_USB_FLAG_USE_CHECK_VBUS_STATUS |
1368 AB8500_USB_FLAG_USE_VBUS_HOST_QUIRK |
1369 AB8500_USB_FLAG_REGULATOR_SET_VOLTAGE;
1370 } else if (is_ab9540(ab->ab8500)) {
1371 ab->flags |= AB8500_USB_FLAG_USE_LINK_STATUS_IRQ |
1372 AB8500_USB_FLAG_REGULATOR_SET_VOLTAGE;
1373 if (is_ab9540_2p0_or_earlier(ab->ab8500))
1374 ab->flags |= AB8500_USB_FLAG_USE_ID_WAKEUP_IRQ |
1375 AB8500_USB_FLAG_USE_VBUS_DET_IRQ;
1376 }
1377
1378 /* Disable regulator voltage setting for AB8500 <= v2.0 */
1379 if (is_ab8500_2p0_or_earlier(ab->ab8500))
1380 ab->flags &= ~AB8500_USB_FLAG_REGULATOR_SET_VOLTAGE;
1381
1382 platform_set_drvdata(pdev, ab);
1383
1384 /* all: Disable phy when called from set_host and set_peripheral */
1385 INIT_WORK(&ab->phy_dis_work, ab8500_usb_phy_disable_work);
1386
1387 INIT_WORK(&ab->vbus_event_work, ab8500_usb_vbus_turn_on_event_work);
1388
1389 err = ab8500_usb_regulator_get(ab);
1390 if (err)
1391 return err;
1392
1393 ab->sysclk = devm_clk_get(ab->dev, "sysclk");
1394 if (IS_ERR(ab->sysclk)) {
1395 dev_err(ab->dev, "Could not get sysclk.\n");
1396 return PTR_ERR(ab->sysclk);
1397 }
1398
1399 err = ab8500_usb_irq_setup(pdev, ab);
1400 if (err < 0)
1401 return err;
1402
1403 err = usb_add_phy(&ab->phy, USB_PHY_TYPE_USB2);
1404 if (err) {
1405 dev_err(&pdev->dev, "Can't register transceiver\n");
1406 return err;
1407 }
1408
1409 if (is_ab8500(ab->ab8500) && !is_ab8500_2p0_or_earlier(ab->ab8500))
1410 /* Phy tuning values for AB8500 > v2.0 */
1411 ab8500_usb_set_ab8500_tuning_values(ab);
1412 else if (is_ab8505(ab->ab8500))
1413 /* Phy tuning values for AB8505 */
1414 ab8500_usb_set_ab8505_tuning_values(ab);
1415 else if (is_ab8540(ab->ab8500))
1416 /* Phy tuning values for AB8540 */
1417 ab8500_usb_set_ab8540_tuning_values(ab);
1418 else if (is_ab9540(ab->ab8500))
1419 /* Phy tuning values for AB9540 */
1420 ab8500_usb_set_ab9540_tuning_values(ab);
1421
1422 /* Needed to enable ID detection. */
1423 ab8500_usb_wd_workaround(ab);
1424
1425 /*
1426 * This is required for usb-link-status to work properly when a
1427 * cable is connected at boot time.
1428 */
1429 ab8500_usb_restart_phy(ab);
1430
1431 if (ab->flags & AB8500_USB_FLAG_USE_CHECK_VBUS_STATUS) {
1432 if (ab8500_usb_check_vbus_status(ab))
1433 schedule_work(&ab->vbus_event_work);
1434 }
1435
1436 abx500_usb_link_status_update(ab);
1437
1438 dev_info(&pdev->dev, "revision 0x%2x driver initialized\n", rev);
1439
1440 return 0;
1441 }
1442
1443 static int ab8500_usb_remove(struct platform_device *pdev)
1444 {
1445 struct ab8500_usb *ab = platform_get_drvdata(pdev);
1446
1447 cancel_work_sync(&ab->phy_dis_work);
1448 cancel_work_sync(&ab->vbus_event_work);
1449
1450 usb_remove_phy(&ab->phy);
1451
1452 if (ab->mode == USB_HOST)
1453 ab8500_usb_host_phy_dis(ab);
1454 else if (ab->mode == USB_PERIPHERAL)
1455 ab8500_usb_peri_phy_dis(ab);
1456
1457 return 0;
1458 }
1459
1460 static const struct platform_device_id ab8500_usb_devtype[] = {
1461 { .name = "ab8500-usb", },
1462 { .name = "ab8540-usb", },
1463 { .name = "ab9540-usb", },
1464 { /* sentinel */ }
1465 };
1466 MODULE_DEVICE_TABLE(platform, ab8500_usb_devtype);
1467
1468 static struct platform_driver ab8500_usb_driver = {
1469 .probe = ab8500_usb_probe,
1470 .remove = ab8500_usb_remove,
1471 .id_table = ab8500_usb_devtype,
1472 .driver = {
1473 .name = "abx5x0-usb",
1474 },
1475 };
1476
1477 static int __init ab8500_usb_init(void)
1478 {
1479 return platform_driver_register(&ab8500_usb_driver);
1480 }
1481 subsys_initcall(ab8500_usb_init);
1482
1483 static void __exit ab8500_usb_exit(void)
1484 {
1485 platform_driver_unregister(&ab8500_usb_driver);
1486 }
1487 module_exit(ab8500_usb_exit);
1488
1489 MODULE_AUTHOR("ST-Ericsson AB");
1490 MODULE_DESCRIPTION("AB8500 family usb transceiver driver");
1491 MODULE_LICENSE("GPL");
ubuntu-bionic-kernel mirror