drivers/usb/phy/phy-ulpi.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Generic ULPI USB transceiver support
   4  *
   5  * Copyright (C) 2009 Daniel Mack <daniel@caiaq.de>
   6  *
   7  * Based on sources from
   8  *
   9  *   Sascha Hauer <s.hauer@pengutronix.de>
  10  *   Freescale Semiconductors
  11  */
  12
  13 #include <linux/kernel.h>
  14 #include <linux/slab.h>
  15 #include <linux/export.h>
  16 #include <linux/usb.h>
  17 #include <linux/usb/otg.h>
  18 #include <linux/usb/ulpi.h>
  19
  20
  21 struct ulpi_info {
  22         unsigned int    id;
  23         char            *name;
  24 };
  25
  26 #define ULPI_ID(vendor, product) (((vendor) << 16) | (product))
  27 #define ULPI_INFO(_id, _name)           \
  28         {                               \
  29                 .id     = (_id),        \
  30                 .name   = (_name),      \
  31         }
  32
  33 /* ULPI hardcoded IDs, used for probing */
  34 static struct ulpi_info ulpi_ids[] = {
  35         ULPI_INFO(ULPI_ID(0x04cc, 0x1504), "NXP ISP1504"),
  36         ULPI_INFO(ULPI_ID(0x0424, 0x0006), "SMSC USB331x"),
  37         ULPI_INFO(ULPI_ID(0x0424, 0x0007), "SMSC USB3320"),
  38         ULPI_INFO(ULPI_ID(0x0424, 0x0009), "SMSC USB334x"),
  39         ULPI_INFO(ULPI_ID(0x0451, 0x1507), "TI TUSB1210"),
  40 };
  41
  42 static int ulpi_set_otg_flags(struct usb_phy *phy)
  43 {
  44         unsigned int flags = ULPI_OTG_CTRL_DP_PULLDOWN |
  45                              ULPI_OTG_CTRL_DM_PULLDOWN;
  46
  47         if (phy->flags & ULPI_OTG_ID_PULLUP)
  48                 flags |= ULPI_OTG_CTRL_ID_PULLUP;
  49
  50         /*
  51          * ULPI Specification rev.1.1 default
  52          * for Dp/DmPulldown is enabled.
  53          */
  54         if (phy->flags & ULPI_OTG_DP_PULLDOWN_DIS)
  55                 flags &= ~ULPI_OTG_CTRL_DP_PULLDOWN;
  56
  57         if (phy->flags & ULPI_OTG_DM_PULLDOWN_DIS)
  58                 flags &= ~ULPI_OTG_CTRL_DM_PULLDOWN;
  59
  60         if (phy->flags & ULPI_OTG_EXTVBUSIND)
  61                 flags |= ULPI_OTG_CTRL_EXTVBUSIND;
  62
  63         return usb_phy_io_write(phy, flags, ULPI_OTG_CTRL);
  64 }
  65
  66 static int ulpi_set_fc_flags(struct usb_phy *phy)
  67 {
  68         unsigned int flags = 0;
  69
  70         /*
  71          * ULPI Specification rev.1.1 default
  72          * for XcvrSelect is Full Speed.
  73          */
  74         if (phy->flags & ULPI_FC_HS)
  75                 flags |= ULPI_FUNC_CTRL_HIGH_SPEED;
  76         else if (phy->flags & ULPI_FC_LS)
  77                 flags |= ULPI_FUNC_CTRL_LOW_SPEED;
  78         else if (phy->flags & ULPI_FC_FS4LS)
  79                 flags |= ULPI_FUNC_CTRL_FS4LS;
  80         else
  81                 flags |= ULPI_FUNC_CTRL_FULL_SPEED;
  82
  83         if (phy->flags & ULPI_FC_TERMSEL)
  84                 flags |= ULPI_FUNC_CTRL_TERMSELECT;
  85
  86         /*
  87          * ULPI Specification rev.1.1 default
  88          * for OpMode is Normal Operation.
  89          */
  90         if (phy->flags & ULPI_FC_OP_NODRV)
  91                 flags |= ULPI_FUNC_CTRL_OPMODE_NONDRIVING;
  92         else if (phy->flags & ULPI_FC_OP_DIS_NRZI)
  93                 flags |= ULPI_FUNC_CTRL_OPMODE_DISABLE_NRZI;
  94         else if (phy->flags & ULPI_FC_OP_NSYNC_NEOP)
  95                 flags |= ULPI_FUNC_CTRL_OPMODE_NOSYNC_NOEOP;
  96         else
  97                 flags |= ULPI_FUNC_CTRL_OPMODE_NORMAL;
  98
  99         /*
 100          * ULPI Specification rev.1.1 default
 101          * for SuspendM is Powered.
 102          */
 103         flags |= ULPI_FUNC_CTRL_SUSPENDM;
 104
 105         return usb_phy_io_write(phy, flags, ULPI_FUNC_CTRL);
 106 }
 107
 108 static int ulpi_set_ic_flags(struct usb_phy *phy)
 109 {
 110         unsigned int flags = 0;
 111
 112         if (phy->flags & ULPI_IC_AUTORESUME)
 113                 flags |= ULPI_IFC_CTRL_AUTORESUME;
 114
 115         if (phy->flags & ULPI_IC_EXTVBUS_INDINV)
 116                 flags |= ULPI_IFC_CTRL_EXTERNAL_VBUS;
 117
 118         if (phy->flags & ULPI_IC_IND_PASSTHRU)
 119                 flags |= ULPI_IFC_CTRL_PASSTHRU;
 120
 121         if (phy->flags & ULPI_IC_PROTECT_DIS)
 122                 flags |= ULPI_IFC_CTRL_PROTECT_IFC_DISABLE;
 123
 124         return usb_phy_io_write(phy, flags, ULPI_IFC_CTRL);
 125 }
 126
 127 static int ulpi_set_flags(struct usb_phy *phy)
 128 {
 129         int ret;
 130
 131         ret = ulpi_set_otg_flags(phy);
 132         if (ret)
 133                 return ret;
 134
 135         ret = ulpi_set_ic_flags(phy);
 136         if (ret)
 137                 return ret;
 138
 139         return ulpi_set_fc_flags(phy);
 140 }
 141
 142 static int ulpi_check_integrity(struct usb_phy *phy)
 143 {
 144         int ret, i;
 145         unsigned int val = 0x55;
 146
 147         for (i = 0; i < 2; i++) {
 148                 ret = usb_phy_io_write(phy, val, ULPI_SCRATCH);
 149                 if (ret < 0)
 150                         return ret;
 151
 152                 ret = usb_phy_io_read(phy, ULPI_SCRATCH);
 153                 if (ret < 0)
 154                         return ret;
 155
 156                 if (ret != val) {
 157                         pr_err("ULPI integrity check: failed!");
 158                         return -ENODEV;
 159                 }
 160                 val = val << 1;
 161         }
 162
 163         pr_info("ULPI integrity check: passed.\n");
 164
 165         return 0;
 166 }
 167
 168 static int ulpi_init(struct usb_phy *phy)
 169 {
 170         int i, vid, pid, ret;
 171         u32 ulpi_id = 0;
 172
 173         for (i = 0; i < 4; i++) {
 174                 ret = usb_phy_io_read(phy, ULPI_PRODUCT_ID_HIGH - i);
 175                 if (ret < 0)
 176                         return ret;
 177                 ulpi_id = (ulpi_id << 8) | ret;
 178         }
 179         vid = ulpi_id & 0xffff;
 180         pid = ulpi_id >> 16;
 181
 182         pr_info("ULPI transceiver vendor/product ID 0x%04x/0x%04x\n", vid, pid);
 183
 184         for (i = 0; i < ARRAY_SIZE(ulpi_ids); i++) {
 185                 if (ulpi_ids[i].id == ULPI_ID(vid, pid)) {
 186                         pr_info("Found %s ULPI transceiver.\n",
 187                                 ulpi_ids[i].name);
 188                         break;
 189                 }
 190         }
 191
 192         ret = ulpi_check_integrity(phy);
 193         if (ret)
 194                 return ret;
 195
 196         return ulpi_set_flags(phy);
 197 }
 198
 199 static int ulpi_set_host(struct usb_otg *otg, struct usb_bus *host)
 200 {
 201         struct usb_phy *phy = otg->usb_phy;
 202         unsigned int flags = usb_phy_io_read(phy, ULPI_IFC_CTRL);
 203
 204         if (!host) {
 205                 otg->host = NULL;
 206                 return 0;
 207         }
 208
 209         otg->host = host;
 210
 211         flags &= ~(ULPI_IFC_CTRL_6_PIN_SERIAL_MODE |
 212                    ULPI_IFC_CTRL_3_PIN_SERIAL_MODE |
 213                    ULPI_IFC_CTRL_CARKITMODE);
 214
 215         if (phy->flags & ULPI_IC_6PIN_SERIAL)
 216                 flags |= ULPI_IFC_CTRL_6_PIN_SERIAL_MODE;
 217         else if (phy->flags & ULPI_IC_3PIN_SERIAL)
 218                 flags |= ULPI_IFC_CTRL_3_PIN_SERIAL_MODE;
 219         else if (phy->flags & ULPI_IC_CARKIT)
 220                 flags |= ULPI_IFC_CTRL_CARKITMODE;
 221
 222         return usb_phy_io_write(phy, flags, ULPI_IFC_CTRL);
 223 }
 224
 225 static int ulpi_set_vbus(struct usb_otg *otg, bool on)
 226 {
 227         struct usb_phy *phy = otg->usb_phy;
 228         unsigned int flags = usb_phy_io_read(phy, ULPI_OTG_CTRL);
 229
 230         flags &= ~(ULPI_OTG_CTRL_DRVVBUS | ULPI_OTG_CTRL_DRVVBUS_EXT);
 231
 232         if (on) {
 233                 if (phy->flags & ULPI_OTG_DRVVBUS)
 234                         flags |= ULPI_OTG_CTRL_DRVVBUS;
 235
 236                 if (phy->flags & ULPI_OTG_DRVVBUS_EXT)
 237                         flags |= ULPI_OTG_CTRL_DRVVBUS_EXT;
 238         }
 239
 240         return usb_phy_io_write(phy, flags, ULPI_OTG_CTRL);
 241 }
 242
 243 static void otg_ulpi_init(struct usb_phy *phy, struct usb_otg *otg,
 244                           struct usb_phy_io_ops *ops,
 245                           unsigned int flags)
 246 {
 247         phy->label      = "ULPI";
 248         phy->flags      = flags;
 249         phy->io_ops     = ops;
 250         phy->otg        = otg;
 251         phy->init       = ulpi_init;
 252
 253         otg->usb_phy    = phy;
 254         otg->set_host   = ulpi_set_host;
 255         otg->set_vbus   = ulpi_set_vbus;
 256 }
 257
 258 struct usb_phy *
 259 otg_ulpi_create(struct usb_phy_io_ops *ops,
 260                 unsigned int flags)
 261 {
 262         struct usb_phy *phy;
 263         struct usb_otg *otg;
 264
 265         phy = kzalloc(sizeof(*phy), GFP_KERNEL);
 266         if (!phy)
 267                 return NULL;
 268
 269         otg = kzalloc(sizeof(*otg), GFP_KERNEL);
 270         if (!otg) {
 271                 kfree(phy);
 272                 return NULL;
 273         }
 274
 275         otg_ulpi_init(phy, otg, ops, flags);
 276
 277         return phy;
 278 }
 279 EXPORT_SYMBOL_GPL(otg_ulpi_create);
 280
 281 struct usb_phy *
 282 devm_otg_ulpi_create(struct device *dev,
 283                      struct usb_phy_io_ops *ops,
 284                      unsigned int flags)
 285 {
 286         struct usb_phy *phy;
 287         struct usb_otg *otg;
 288
 289         phy = devm_kzalloc(dev, sizeof(*phy), GFP_KERNEL);
 290         if (!phy)
 291                 return NULL;
 292
 293         otg = devm_kzalloc(dev, sizeof(*otg), GFP_KERNEL);
 294         if (!otg) {
 295                 devm_kfree(dev, phy);
 296                 return NULL;
 297         }
 298
 299         otg_ulpi_init(phy, otg, ops, flags);
 300
 301         return phy;
 302 }
 303 EXPORT_SYMBOL_GPL(devm_otg_ulpi_create);