drivers/usb/phy/phy-ulpi.c

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