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