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