Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * STMicroelectronics STUSB160x Type-C controller family driver
0004  *
0005  * Copyright (C) 2020, STMicroelectronics
0006  * Author(s): Amelie Delaunay <amelie.delaunay@st.com>
0007  */
0008 
0009 #include <linux/bitfield.h>
0010 #include <linux/i2c.h>
0011 #include <linux/interrupt.h>
0012 #include <linux/kernel.h>
0013 #include <linux/module.h>
0014 #include <linux/regmap.h>
0015 #include <linux/regulator/consumer.h>
0016 #include <linux/usb/role.h>
0017 #include <linux/usb/typec.h>
0018 
0019 #define STUSB160X_ALERT_STATUS          0x0B /* RC */
0020 #define STUSB160X_ALERT_STATUS_MASK_CTRL    0x0C /* RW */
0021 #define STUSB160X_CC_CONNECTION_STATUS_TRANS    0x0D /* RC */
0022 #define STUSB160X_CC_CONNECTION_STATUS      0x0E /* RO */
0023 #define STUSB160X_MONITORING_STATUS_TRANS   0x0F /* RC */
0024 #define STUSB160X_MONITORING_STATUS     0x10 /* RO */
0025 #define STUSB160X_CC_OPERATION_STATUS       0x11 /* RO */
0026 #define STUSB160X_HW_FAULT_STATUS_TRANS     0x12 /* RC */
0027 #define STUSB160X_HW_FAULT_STATUS       0x13 /* RO */
0028 #define STUSB160X_CC_CAPABILITY_CTRL        0x18 /* RW */
0029 #define STUSB160X_CC_VCONN_SWITCH_CTRL      0x1E /* RW */
0030 #define STUSB160X_VCONN_MONITORING_CTRL     0x20 /* RW */
0031 #define STUSB160X_VBUS_MONITORING_RANGE_CTRL    0x22 /* RW */
0032 #define STUSB160X_RESET_CTRL            0x23 /* RW */
0033 #define STUSB160X_VBUS_DISCHARGE_TIME_CTRL  0x25 /* RW */
0034 #define STUSB160X_VBUS_DISCHARGE_STATUS     0x26 /* RO */
0035 #define STUSB160X_VBUS_ENABLE_STATUS        0x27 /* RO */
0036 #define STUSB160X_CC_POWER_MODE_CTRL        0x28 /* RW */
0037 #define STUSB160X_VBUS_MONITORING_CTRL      0x2E /* RW */
0038 #define STUSB1600_REG_MAX           0x2F /* RO - Reserved */
0039 
0040 /* STUSB160X_ALERT_STATUS/STUSB160X_ALERT_STATUS_MASK_CTRL bitfields */
0041 #define STUSB160X_HW_FAULT          BIT(4)
0042 #define STUSB160X_MONITORING            BIT(5)
0043 #define STUSB160X_CC_CONNECTION         BIT(6)
0044 #define STUSB160X_ALL_ALERTS            GENMASK(6, 4)
0045 
0046 /* STUSB160X_CC_CONNECTION_STATUS_TRANS bitfields */
0047 #define STUSB160X_CC_ATTACH_TRANS       BIT(0)
0048 
0049 /* STUSB160X_CC_CONNECTION_STATUS bitfields */
0050 #define STUSB160X_CC_ATTACH         BIT(0)
0051 #define STUSB160X_CC_VCONN_SUPPLY       BIT(1)
0052 #define STUSB160X_CC_DATA_ROLE(s)       (!!((s) & BIT(2)))
0053 #define STUSB160X_CC_POWER_ROLE(s)      (!!((s) & BIT(3)))
0054 #define STUSB160X_CC_ATTACHED_MODE      GENMASK(7, 5)
0055 
0056 /* STUSB160X_MONITORING_STATUS_TRANS bitfields */
0057 #define STUSB160X_VCONN_PRESENCE_TRANS      BIT(0)
0058 #define STUSB160X_VBUS_PRESENCE_TRANS       BIT(1)
0059 #define STUSB160X_VBUS_VSAFE0V_TRANS        BIT(2)
0060 #define STUSB160X_VBUS_VALID_TRANS      BIT(3)
0061 
0062 /* STUSB160X_MONITORING_STATUS bitfields */
0063 #define STUSB160X_VCONN_PRESENCE        BIT(0)
0064 #define STUSB160X_VBUS_PRESENCE         BIT(1)
0065 #define STUSB160X_VBUS_VSAFE0V          BIT(2)
0066 #define STUSB160X_VBUS_VALID            BIT(3)
0067 
0068 /* STUSB160X_CC_OPERATION_STATUS bitfields */
0069 #define STUSB160X_TYPEC_FSM_STATE       GENMASK(4, 0)
0070 #define STUSB160X_SINK_POWER_STATE      GENMASK(6, 5)
0071 #define STUSB160X_CC_ATTACHED           BIT(7)
0072 
0073 /* STUSB160X_HW_FAULT_STATUS_TRANS bitfields */
0074 #define STUSB160X_VCONN_SW_OVP_FAULT_TRANS  BIT(0)
0075 #define STUSB160X_VCONN_SW_OCP_FAULT_TRANS  BIT(1)
0076 #define STUSB160X_VCONN_SW_RVP_FAULT_TRANS  BIT(2)
0077 #define STUSB160X_VPU_VALID_TRANS       BIT(4)
0078 #define STUSB160X_VPU_OVP_FAULT_TRANS       BIT(5)
0079 #define STUSB160X_THERMAL_FAULT         BIT(7)
0080 
0081 /* STUSB160X_HW_FAULT_STATUS bitfields */
0082 #define STUSB160X_VCONN_SW_OVP_FAULT_CC2    BIT(0)
0083 #define STUSB160X_VCONN_SW_OVP_FAULT_CC1    BIT(1)
0084 #define STUSB160X_VCONN_SW_OCP_FAULT_CC2    BIT(2)
0085 #define STUSB160X_VCONN_SW_OCP_FAULT_CC1    BIT(3)
0086 #define STUSB160X_VCONN_SW_RVP_FAULT_CC2    BIT(4)
0087 #define STUSB160X_VCONN_SW_RVP_FAULT_CC1    BIT(5)
0088 #define STUSB160X_VPU_VALID         BIT(6)
0089 #define STUSB160X_VPU_OVP_FAULT         BIT(7)
0090 
0091 /* STUSB160X_CC_CAPABILITY_CTRL bitfields */
0092 #define STUSB160X_CC_VCONN_SUPPLY_EN        BIT(0)
0093 #define STUSB160X_CC_VCONN_DISCHARGE_EN     BIT(4)
0094 #define STUSB160X_CC_CURRENT_ADVERTISED     GENMASK(7, 6)
0095 
0096 /* STUSB160X_VCONN_SWITCH_CTRL bitfields */
0097 #define STUSB160X_CC_VCONN_SWITCH_ILIM      GENMASK(3, 0)
0098 
0099 /* STUSB160X_VCONN_MONITORING_CTRL bitfields */
0100 #define STUSB160X_VCONN_UVLO_THRESHOLD      BIT(6)
0101 #define STUSB160X_VCONN_MONITORING_EN       BIT(7)
0102 
0103 /* STUSB160X_VBUS_MONITORING_RANGE_CTRL bitfields */
0104 #define STUSB160X_SHIFT_LOW_VBUS_LIMIT      GENMASK(3, 0)
0105 #define STUSB160X_SHIFT_HIGH_VBUS_LIMIT     GENMASK(7, 4)
0106 
0107 /* STUSB160X_RESET_CTRL bitfields */
0108 #define STUSB160X_SW_RESET_EN           BIT(0)
0109 
0110 /* STUSB160X_VBUS_DISCHARGE_TIME_CTRL bitfields */
0111 #define STUSBXX02_VBUS_DISCHARGE_TIME_TO_PDO    GENMASK(3, 0)
0112 #define STUSB160X_VBUS_DISCHARGE_TIME_TO_0V GENMASK(7, 4)
0113 
0114 /* STUSB160X_VBUS_DISCHARGE_STATUS bitfields */
0115 #define STUSB160X_VBUS_DISCHARGE_EN     BIT(7)
0116 
0117 /* STUSB160X_VBUS_ENABLE_STATUS bitfields */
0118 #define STUSB160X_VBUS_SOURCE_EN        BIT(0)
0119 #define STUSB160X_VBUS_SINK_EN          BIT(1)
0120 
0121 /* STUSB160X_CC_POWER_MODE_CTRL bitfields */
0122 #define STUSB160X_CC_POWER_MODE         GENMASK(2, 0)
0123 
0124 /* STUSB160X_VBUS_MONITORING_CTRL bitfields */
0125 #define STUSB160X_VDD_UVLO_DISABLE      BIT(0)
0126 #define STUSB160X_VBUS_VSAFE0V_THRESHOLD    GENMASK(2, 1)
0127 #define STUSB160X_VBUS_RANGE_DISABLE        BIT(4)
0128 #define STUSB160X_VDD_OVLO_DISABLE      BIT(6)
0129 
0130 enum stusb160x_pwr_mode {
0131     SOURCE_WITH_ACCESSORY,
0132     SINK_WITH_ACCESSORY,
0133     SINK_WITHOUT_ACCESSORY,
0134     DUAL_WITH_ACCESSORY,
0135     DUAL_WITH_ACCESSORY_AND_TRY_SRC,
0136     DUAL_WITH_ACCESSORY_AND_TRY_SNK,
0137 };
0138 
0139 enum stusb160x_attached_mode {
0140     NO_DEVICE_ATTACHED,
0141     SINK_ATTACHED,
0142     SOURCE_ATTACHED,
0143     DEBUG_ACCESSORY_ATTACHED,
0144     AUDIO_ACCESSORY_ATTACHED,
0145 };
0146 
0147 struct stusb160x {
0148     struct device       *dev;
0149     struct regmap       *regmap;
0150     struct regulator    *vdd_supply;
0151     struct regulator    *vsys_supply;
0152     struct regulator    *vconn_supply;
0153     struct regulator    *main_supply;
0154 
0155     struct typec_port   *port;
0156     struct typec_capability capability;
0157     struct typec_partner    *partner;
0158 
0159     enum typec_port_type    port_type;
0160     enum typec_pwr_opmode   pwr_opmode;
0161     bool            vbus_on;
0162 
0163     struct usb_role_switch  *role_sw;
0164 };
0165 
0166 static bool stusb160x_reg_writeable(struct device *dev, unsigned int reg)
0167 {
0168     switch (reg) {
0169     case STUSB160X_ALERT_STATUS_MASK_CTRL:
0170     case STUSB160X_CC_CAPABILITY_CTRL:
0171     case STUSB160X_CC_VCONN_SWITCH_CTRL:
0172     case STUSB160X_VCONN_MONITORING_CTRL:
0173     case STUSB160X_VBUS_MONITORING_RANGE_CTRL:
0174     case STUSB160X_RESET_CTRL:
0175     case STUSB160X_VBUS_DISCHARGE_TIME_CTRL:
0176     case STUSB160X_CC_POWER_MODE_CTRL:
0177     case STUSB160X_VBUS_MONITORING_CTRL:
0178         return true;
0179     default:
0180         return false;
0181     }
0182 }
0183 
0184 static bool stusb160x_reg_readable(struct device *dev, unsigned int reg)
0185 {
0186     if (reg <= 0x0A ||
0187         (reg >= 0x14 && reg <= 0x17) ||
0188         (reg >= 0x19 && reg <= 0x1D) ||
0189         (reg >= 0x29 && reg <= 0x2D) ||
0190         (reg == 0x1F || reg == 0x21 || reg == 0x24 || reg == 0x2F))
0191         return false;
0192     else
0193         return true;
0194 }
0195 
0196 static bool stusb160x_reg_volatile(struct device *dev, unsigned int reg)
0197 {
0198     switch (reg) {
0199     case STUSB160X_ALERT_STATUS:
0200     case STUSB160X_CC_CONNECTION_STATUS_TRANS:
0201     case STUSB160X_CC_CONNECTION_STATUS:
0202     case STUSB160X_MONITORING_STATUS_TRANS:
0203     case STUSB160X_MONITORING_STATUS:
0204     case STUSB160X_CC_OPERATION_STATUS:
0205     case STUSB160X_HW_FAULT_STATUS_TRANS:
0206     case STUSB160X_HW_FAULT_STATUS:
0207     case STUSB160X_VBUS_DISCHARGE_STATUS:
0208     case STUSB160X_VBUS_ENABLE_STATUS:
0209         return true;
0210     default:
0211         return false;
0212     }
0213 }
0214 
0215 static bool stusb160x_reg_precious(struct device *dev, unsigned int reg)
0216 {
0217     switch (reg) {
0218     case STUSB160X_ALERT_STATUS:
0219     case STUSB160X_CC_CONNECTION_STATUS_TRANS:
0220     case STUSB160X_MONITORING_STATUS_TRANS:
0221     case STUSB160X_HW_FAULT_STATUS_TRANS:
0222         return true;
0223     default:
0224         return false;
0225     }
0226 }
0227 
0228 static const struct regmap_config stusb1600_regmap_config = {
0229     .reg_bits   = 8,
0230     .reg_stride = 1,
0231     .val_bits   = 8,
0232     .max_register   = STUSB1600_REG_MAX,
0233     .writeable_reg  = stusb160x_reg_writeable,
0234     .readable_reg   = stusb160x_reg_readable,
0235     .volatile_reg   = stusb160x_reg_volatile,
0236     .precious_reg   = stusb160x_reg_precious,
0237     .cache_type = REGCACHE_RBTREE,
0238 };
0239 
0240 static bool stusb160x_get_vconn(struct stusb160x *chip)
0241 {
0242     u32 val;
0243     int ret;
0244 
0245     ret = regmap_read(chip->regmap, STUSB160X_CC_CAPABILITY_CTRL, &val);
0246     if (ret) {
0247         dev_err(chip->dev, "Unable to get Vconn status: %d\n", ret);
0248         return false;
0249     }
0250 
0251     return !!FIELD_GET(STUSB160X_CC_VCONN_SUPPLY_EN, val);
0252 }
0253 
0254 static int stusb160x_set_vconn(struct stusb160x *chip, bool on)
0255 {
0256     int ret;
0257 
0258     /* Manage VCONN input supply */
0259     if (chip->vconn_supply) {
0260         if (on) {
0261             ret = regulator_enable(chip->vconn_supply);
0262             if (ret) {
0263                 dev_err(chip->dev,
0264                     "failed to enable vconn supply: %d\n",
0265                     ret);
0266                 return ret;
0267             }
0268         } else {
0269             regulator_disable(chip->vconn_supply);
0270         }
0271     }
0272 
0273     /* Manage VCONN monitoring and power path */
0274     ret = regmap_update_bits(chip->regmap, STUSB160X_VCONN_MONITORING_CTRL,
0275                  STUSB160X_VCONN_MONITORING_EN,
0276                  on ? STUSB160X_VCONN_MONITORING_EN : 0);
0277     if (ret)
0278         goto vconn_reg_disable;
0279 
0280     return 0;
0281 
0282 vconn_reg_disable:
0283     if (chip->vconn_supply && on)
0284         regulator_disable(chip->vconn_supply);
0285 
0286     return ret;
0287 }
0288 
0289 static enum typec_pwr_opmode stusb160x_get_pwr_opmode(struct stusb160x *chip)
0290 {
0291     u32 val;
0292     int ret;
0293 
0294     ret = regmap_read(chip->regmap, STUSB160X_CC_CAPABILITY_CTRL, &val);
0295     if (ret) {
0296         dev_err(chip->dev, "Unable to get pwr opmode: %d\n", ret);
0297         return TYPEC_PWR_MODE_USB;
0298     }
0299 
0300     return FIELD_GET(STUSB160X_CC_CURRENT_ADVERTISED, val);
0301 }
0302 
0303 static enum typec_accessory stusb160x_get_accessory(u32 status)
0304 {
0305     enum stusb160x_attached_mode mode;
0306 
0307     mode = FIELD_GET(STUSB160X_CC_ATTACHED_MODE, status);
0308 
0309     switch (mode) {
0310     case DEBUG_ACCESSORY_ATTACHED:
0311         return TYPEC_ACCESSORY_DEBUG;
0312     case AUDIO_ACCESSORY_ATTACHED:
0313         return TYPEC_ACCESSORY_AUDIO;
0314     default:
0315         return TYPEC_ACCESSORY_NONE;
0316     }
0317 }
0318 
0319 static enum typec_role stusb160x_get_vconn_role(u32 status)
0320 {
0321     if (FIELD_GET(STUSB160X_CC_VCONN_SUPPLY, status))
0322         return TYPEC_SOURCE;
0323 
0324     return TYPEC_SINK;
0325 }
0326 
0327 static void stusb160x_set_data_role(struct stusb160x *chip,
0328                     enum typec_data_role data_role,
0329                     bool attached)
0330 {
0331     enum usb_role usb_role = USB_ROLE_NONE;
0332 
0333     if (attached) {
0334         if (data_role == TYPEC_HOST)
0335             usb_role = USB_ROLE_HOST;
0336         else
0337             usb_role = USB_ROLE_DEVICE;
0338     }
0339 
0340     usb_role_switch_set_role(chip->role_sw, usb_role);
0341     typec_set_data_role(chip->port, data_role);
0342 }
0343 
0344 static int stusb160x_attach(struct stusb160x *chip, u32 status)
0345 {
0346     struct typec_partner_desc desc;
0347     int ret;
0348 
0349     if ((STUSB160X_CC_POWER_ROLE(status) == TYPEC_SOURCE) &&
0350         chip->vdd_supply) {
0351         ret = regulator_enable(chip->vdd_supply);
0352         if (ret) {
0353             dev_err(chip->dev,
0354                 "Failed to enable Vbus supply: %d\n", ret);
0355             return ret;
0356         }
0357         chip->vbus_on = true;
0358     }
0359 
0360     desc.usb_pd = false;
0361     desc.accessory = stusb160x_get_accessory(status);
0362     desc.identity = NULL;
0363 
0364     chip->partner = typec_register_partner(chip->port, &desc);
0365     if (IS_ERR(chip->partner)) {
0366         ret = PTR_ERR(chip->partner);
0367         goto vbus_disable;
0368     }
0369 
0370     typec_set_pwr_role(chip->port, STUSB160X_CC_POWER_ROLE(status));
0371     typec_set_pwr_opmode(chip->port, stusb160x_get_pwr_opmode(chip));
0372     typec_set_vconn_role(chip->port, stusb160x_get_vconn_role(status));
0373     stusb160x_set_data_role(chip, STUSB160X_CC_DATA_ROLE(status), true);
0374 
0375     return 0;
0376 
0377 vbus_disable:
0378     if (chip->vbus_on) {
0379         regulator_disable(chip->vdd_supply);
0380         chip->vbus_on = false;
0381     }
0382 
0383     return ret;
0384 }
0385 
0386 static void stusb160x_detach(struct stusb160x *chip, u32 status)
0387 {
0388     typec_unregister_partner(chip->partner);
0389     chip->partner = NULL;
0390 
0391     typec_set_pwr_role(chip->port, STUSB160X_CC_POWER_ROLE(status));
0392     typec_set_pwr_opmode(chip->port, TYPEC_PWR_MODE_USB);
0393     typec_set_vconn_role(chip->port, stusb160x_get_vconn_role(status));
0394     stusb160x_set_data_role(chip, STUSB160X_CC_DATA_ROLE(status), false);
0395 
0396     if (chip->vbus_on) {
0397         regulator_disable(chip->vdd_supply);
0398         chip->vbus_on = false;
0399     }
0400 }
0401 
0402 static irqreturn_t stusb160x_irq_handler(int irq, void *data)
0403 {
0404     struct stusb160x *chip = data;
0405     u32 pending, trans, status;
0406     int ret;
0407 
0408     ret = regmap_read(chip->regmap, STUSB160X_ALERT_STATUS, &pending);
0409     if (ret)
0410         goto err;
0411 
0412     if (pending & STUSB160X_CC_CONNECTION) {
0413         ret = regmap_read(chip->regmap,
0414                   STUSB160X_CC_CONNECTION_STATUS_TRANS, &trans);
0415         if (ret)
0416             goto err;
0417         ret = regmap_read(chip->regmap,
0418                   STUSB160X_CC_CONNECTION_STATUS, &status);
0419         if (ret)
0420             goto err;
0421 
0422         if (trans & STUSB160X_CC_ATTACH_TRANS) {
0423             if (status & STUSB160X_CC_ATTACH) {
0424                 ret = stusb160x_attach(chip, status);
0425                 if (ret)
0426                     goto err;
0427             } else {
0428                 stusb160x_detach(chip, status);
0429             }
0430         }
0431     }
0432 err:
0433     return IRQ_HANDLED;
0434 }
0435 
0436 static int stusb160x_irq_init(struct stusb160x *chip, int irq)
0437 {
0438     u32 status;
0439     int ret;
0440 
0441     ret = regmap_read(chip->regmap,
0442               STUSB160X_CC_CONNECTION_STATUS, &status);
0443     if (ret)
0444         return ret;
0445 
0446     if (status & STUSB160X_CC_ATTACH) {
0447         ret = stusb160x_attach(chip, status);
0448         if (ret)
0449             dev_err(chip->dev, "attach failed: %d\n", ret);
0450     }
0451 
0452     ret = devm_request_threaded_irq(chip->dev, irq, NULL,
0453                     stusb160x_irq_handler, IRQF_ONESHOT,
0454                     dev_name(chip->dev), chip);
0455     if (ret)
0456         goto partner_unregister;
0457 
0458     /* Unmask CC_CONNECTION events */
0459     ret = regmap_write_bits(chip->regmap, STUSB160X_ALERT_STATUS_MASK_CTRL,
0460                 STUSB160X_CC_CONNECTION, 0);
0461     if (ret)
0462         goto partner_unregister;
0463 
0464     return 0;
0465 
0466 partner_unregister:
0467     if (chip->partner) {
0468         typec_unregister_partner(chip->partner);
0469         chip->partner = NULL;
0470     }
0471 
0472     return ret;
0473 }
0474 
0475 static int stusb160x_chip_init(struct stusb160x *chip)
0476 {
0477     u32 val;
0478     int ret;
0479 
0480     /* Change the default Type-C power mode */
0481     if (chip->port_type == TYPEC_PORT_SRC)
0482         ret = regmap_update_bits(chip->regmap,
0483                      STUSB160X_CC_POWER_MODE_CTRL,
0484                      STUSB160X_CC_POWER_MODE,
0485                      SOURCE_WITH_ACCESSORY);
0486     else if (chip->port_type == TYPEC_PORT_SNK)
0487         ret = regmap_update_bits(chip->regmap,
0488                      STUSB160X_CC_POWER_MODE_CTRL,
0489                      STUSB160X_CC_POWER_MODE,
0490                      SINK_WITH_ACCESSORY);
0491     else /* (chip->port_type == TYPEC_PORT_DRP) */
0492         ret = regmap_update_bits(chip->regmap,
0493                      STUSB160X_CC_POWER_MODE_CTRL,
0494                      STUSB160X_CC_POWER_MODE,
0495                      DUAL_WITH_ACCESSORY);
0496     if (ret)
0497         return ret;
0498 
0499     if (chip->port_type == TYPEC_PORT_SNK)
0500         goto skip_src;
0501 
0502     /* Change the default Type-C Source power operation mode capability */
0503     ret = regmap_update_bits(chip->regmap, STUSB160X_CC_CAPABILITY_CTRL,
0504                  STUSB160X_CC_CURRENT_ADVERTISED,
0505                  FIELD_PREP(STUSB160X_CC_CURRENT_ADVERTISED,
0506                         chip->pwr_opmode));
0507     if (ret)
0508         return ret;
0509 
0510     /* Manage Type-C Source Vconn supply */
0511     if (stusb160x_get_vconn(chip)) {
0512         ret = stusb160x_set_vconn(chip, true);
0513         if (ret)
0514             return ret;
0515     }
0516 
0517 skip_src:
0518     /* Mask all events interrupts - to be unmasked with interrupt support */
0519     ret = regmap_update_bits(chip->regmap, STUSB160X_ALERT_STATUS_MASK_CTRL,
0520                  STUSB160X_ALL_ALERTS, STUSB160X_ALL_ALERTS);
0521     if (ret)
0522         return ret;
0523 
0524     /* Read status at least once to clear any stale interrupts */
0525     regmap_read(chip->regmap, STUSB160X_ALERT_STATUS, &val);
0526     regmap_read(chip->regmap, STUSB160X_CC_CONNECTION_STATUS_TRANS, &val);
0527     regmap_read(chip->regmap, STUSB160X_MONITORING_STATUS_TRANS, &val);
0528     regmap_read(chip->regmap, STUSB160X_HW_FAULT_STATUS_TRANS, &val);
0529 
0530     return 0;
0531 }
0532 
0533 static int stusb160x_get_fw_caps(struct stusb160x *chip,
0534                  struct fwnode_handle *fwnode)
0535 {
0536     const char *cap_str;
0537     int ret;
0538 
0539     chip->capability.fwnode = fwnode;
0540 
0541     /*
0542      * Supported port type can be configured through device tree
0543      * else it is read from chip registers in stusb160x_get_caps.
0544      */
0545     ret = fwnode_property_read_string(fwnode, "power-role", &cap_str);
0546     if (!ret) {
0547         ret = typec_find_port_power_role(cap_str);
0548         if (ret < 0)
0549             return ret;
0550         chip->port_type = ret;
0551     }
0552     chip->capability.type = chip->port_type;
0553 
0554     /* Skip DRP/Source capabilities in case of Sink only */
0555     if (chip->port_type == TYPEC_PORT_SNK)
0556         return 0;
0557 
0558     if (chip->port_type == TYPEC_PORT_DRP)
0559         chip->capability.prefer_role = TYPEC_SINK;
0560 
0561     /*
0562      * Supported power operation mode can be configured through device tree
0563      * else it is read from chip registers in stusb160x_get_caps.
0564      */
0565     ret = fwnode_property_read_string(fwnode, "typec-power-opmode", &cap_str);
0566     if (!ret) {
0567         ret = typec_find_pwr_opmode(cap_str);
0568         /* Power delivery not yet supported */
0569         if (ret < 0 || ret == TYPEC_PWR_MODE_PD) {
0570             dev_err(chip->dev, "bad power operation mode: %d\n", ret);
0571             return -EINVAL;
0572         }
0573         chip->pwr_opmode = ret;
0574     }
0575 
0576     return 0;
0577 }
0578 
0579 static int stusb160x_get_caps(struct stusb160x *chip)
0580 {
0581     enum typec_port_type *type = &chip->capability.type;
0582     enum typec_port_data *data = &chip->capability.data;
0583     enum typec_accessory *accessory = chip->capability.accessory;
0584     u32 val;
0585     int ret;
0586 
0587     chip->capability.revision = USB_TYPEC_REV_1_2;
0588 
0589     ret = regmap_read(chip->regmap, STUSB160X_CC_POWER_MODE_CTRL, &val);
0590     if (ret)
0591         return ret;
0592 
0593     switch (FIELD_GET(STUSB160X_CC_POWER_MODE, val)) {
0594     case SOURCE_WITH_ACCESSORY:
0595         *type = TYPEC_PORT_SRC;
0596         *data = TYPEC_PORT_DFP;
0597         *accessory++ = TYPEC_ACCESSORY_AUDIO;
0598         *accessory++ = TYPEC_ACCESSORY_DEBUG;
0599         break;
0600     case SINK_WITH_ACCESSORY:
0601         *type = TYPEC_PORT_SNK;
0602         *data = TYPEC_PORT_UFP;
0603         *accessory++ = TYPEC_ACCESSORY_AUDIO;
0604         *accessory++ = TYPEC_ACCESSORY_DEBUG;
0605         break;
0606     case SINK_WITHOUT_ACCESSORY:
0607         *type = TYPEC_PORT_SNK;
0608         *data = TYPEC_PORT_UFP;
0609         break;
0610     case DUAL_WITH_ACCESSORY:
0611     case DUAL_WITH_ACCESSORY_AND_TRY_SRC:
0612     case DUAL_WITH_ACCESSORY_AND_TRY_SNK:
0613         *type = TYPEC_PORT_DRP;
0614         *data = TYPEC_PORT_DRD;
0615         *accessory++ = TYPEC_ACCESSORY_AUDIO;
0616         *accessory++ = TYPEC_ACCESSORY_DEBUG;
0617         break;
0618     default:
0619         return -EINVAL;
0620     }
0621 
0622     chip->port_type = *type;
0623     chip->pwr_opmode = stusb160x_get_pwr_opmode(chip);
0624 
0625     return 0;
0626 }
0627 
0628 static const struct of_device_id stusb160x_of_match[] = {
0629     { .compatible = "st,stusb1600", .data = &stusb1600_regmap_config},
0630     {},
0631 };
0632 MODULE_DEVICE_TABLE(of, stusb160x_of_match);
0633 
0634 static int stusb160x_probe(struct i2c_client *client)
0635 {
0636     struct stusb160x *chip;
0637     const struct of_device_id *match;
0638     struct regmap_config *regmap_config;
0639     struct fwnode_handle *fwnode;
0640     int ret;
0641 
0642     chip = devm_kzalloc(&client->dev, sizeof(struct stusb160x), GFP_KERNEL);
0643     if (!chip)
0644         return -ENOMEM;
0645 
0646     i2c_set_clientdata(client, chip);
0647 
0648     match = i2c_of_match_device(stusb160x_of_match, client);
0649     regmap_config = (struct regmap_config *)match->data;
0650     chip->regmap = devm_regmap_init_i2c(client, regmap_config);
0651     if (IS_ERR(chip->regmap)) {
0652         ret = PTR_ERR(chip->regmap);
0653         dev_err(&client->dev,
0654             "Failed to allocate register map:%d\n", ret);
0655         return ret;
0656     }
0657 
0658     chip->dev = &client->dev;
0659 
0660     chip->vsys_supply = devm_regulator_get_optional(chip->dev, "vsys");
0661     if (IS_ERR(chip->vsys_supply)) {
0662         ret = PTR_ERR(chip->vsys_supply);
0663         if (ret != -ENODEV)
0664             return ret;
0665         chip->vsys_supply = NULL;
0666     }
0667 
0668     chip->vdd_supply = devm_regulator_get_optional(chip->dev, "vdd");
0669     if (IS_ERR(chip->vdd_supply)) {
0670         ret = PTR_ERR(chip->vdd_supply);
0671         if (ret != -ENODEV)
0672             return ret;
0673         chip->vdd_supply = NULL;
0674     }
0675 
0676     chip->vconn_supply = devm_regulator_get_optional(chip->dev, "vconn");
0677     if (IS_ERR(chip->vconn_supply)) {
0678         ret = PTR_ERR(chip->vconn_supply);
0679         if (ret != -ENODEV)
0680             return ret;
0681         chip->vconn_supply = NULL;
0682     }
0683 
0684     fwnode = device_get_named_child_node(chip->dev, "connector");
0685     if (!fwnode)
0686         return -ENODEV;
0687 
0688     /*
0689      * This fwnode has a "compatible" property, but is never populated as a
0690      * struct device. Instead we simply parse it to read the properties.
0691      * This it breaks fw_devlink=on. To maintain backward compatibility
0692      * with existing DT files, we work around this by deleting any
0693      * fwnode_links to/from this fwnode.
0694      */
0695     fw_devlink_purge_absent_suppliers(fwnode);
0696 
0697     /*
0698      * When both VDD and VSYS power supplies are present, the low power
0699      * supply VSYS is selected when VSYS voltage is above 3.1 V.
0700      * Otherwise VDD is selected.
0701      */
0702     if (chip->vdd_supply &&
0703         (!chip->vsys_supply ||
0704          (regulator_get_voltage(chip->vsys_supply) <= 3100000)))
0705         chip->main_supply = chip->vdd_supply;
0706     else
0707         chip->main_supply = chip->vsys_supply;
0708 
0709     if (chip->main_supply) {
0710         ret = regulator_enable(chip->main_supply);
0711         if (ret) {
0712             dev_err(chip->dev,
0713                 "Failed to enable main supply: %d\n", ret);
0714             goto fwnode_put;
0715         }
0716     }
0717 
0718     /* Get configuration from chip */
0719     ret = stusb160x_get_caps(chip);
0720     if (ret) {
0721         dev_err(chip->dev, "Failed to get port caps: %d\n", ret);
0722         goto main_reg_disable;
0723     }
0724 
0725     /* Get optional re-configuration from device tree */
0726     ret = stusb160x_get_fw_caps(chip, fwnode);
0727     if (ret) {
0728         dev_err(chip->dev, "Failed to get connector caps: %d\n", ret);
0729         goto main_reg_disable;
0730     }
0731 
0732     ret = stusb160x_chip_init(chip);
0733     if (ret) {
0734         dev_err(chip->dev, "Failed to init port: %d\n", ret);
0735         goto main_reg_disable;
0736     }
0737 
0738     chip->port = typec_register_port(chip->dev, &chip->capability);
0739     if (IS_ERR(chip->port)) {
0740         ret = PTR_ERR(chip->port);
0741         goto all_reg_disable;
0742     }
0743 
0744     /*
0745      * Default power operation mode initialization: will be updated upon
0746      * attach/detach interrupt
0747      */
0748     typec_set_pwr_opmode(chip->port, chip->pwr_opmode);
0749 
0750     if (client->irq) {
0751         chip->role_sw = fwnode_usb_role_switch_get(fwnode);
0752         if (IS_ERR(chip->role_sw)) {
0753             ret = PTR_ERR(chip->role_sw);
0754             if (ret != -EPROBE_DEFER)
0755                 dev_err(chip->dev,
0756                     "Failed to get usb role switch: %d\n",
0757                     ret);
0758             goto port_unregister;
0759         }
0760 
0761         ret = stusb160x_irq_init(chip, client->irq);
0762         if (ret)
0763             goto role_sw_put;
0764     } else {
0765         /*
0766          * If Source or Dual power role, need to enable VDD supply
0767          * providing Vbus if present. In case of interrupt support,
0768          * VDD supply will be dynamically managed upon attach/detach
0769          * interrupt.
0770          */
0771         if (chip->port_type != TYPEC_PORT_SNK && chip->vdd_supply) {
0772             ret = regulator_enable(chip->vdd_supply);
0773             if (ret) {
0774                 dev_err(chip->dev,
0775                     "Failed to enable VDD supply: %d\n",
0776                     ret);
0777                 goto port_unregister;
0778             }
0779             chip->vbus_on = true;
0780         }
0781     }
0782 
0783     fwnode_handle_put(fwnode);
0784 
0785     return 0;
0786 
0787 role_sw_put:
0788     if (chip->role_sw)
0789         usb_role_switch_put(chip->role_sw);
0790 port_unregister:
0791     typec_unregister_port(chip->port);
0792 all_reg_disable:
0793     if (stusb160x_get_vconn(chip))
0794         stusb160x_set_vconn(chip, false);
0795 main_reg_disable:
0796     if (chip->main_supply)
0797         regulator_disable(chip->main_supply);
0798 fwnode_put:
0799     fwnode_handle_put(fwnode);
0800 
0801     return ret;
0802 }
0803 
0804 static int stusb160x_remove(struct i2c_client *client)
0805 {
0806     struct stusb160x *chip = i2c_get_clientdata(client);
0807 
0808     if (chip->partner) {
0809         typec_unregister_partner(chip->partner);
0810         chip->partner = NULL;
0811     }
0812 
0813     if (chip->vbus_on)
0814         regulator_disable(chip->vdd_supply);
0815 
0816     if (chip->role_sw)
0817         usb_role_switch_put(chip->role_sw);
0818 
0819     typec_unregister_port(chip->port);
0820 
0821     if (stusb160x_get_vconn(chip))
0822         stusb160x_set_vconn(chip, false);
0823 
0824     if (chip->main_supply)
0825         regulator_disable(chip->main_supply);
0826 
0827     return 0;
0828 }
0829 
0830 static int __maybe_unused stusb160x_suspend(struct device *dev)
0831 {
0832     struct stusb160x *chip = dev_get_drvdata(dev);
0833 
0834     /* Mask interrupts */
0835     return regmap_update_bits(chip->regmap,
0836                   STUSB160X_ALERT_STATUS_MASK_CTRL,
0837                   STUSB160X_ALL_ALERTS, STUSB160X_ALL_ALERTS);
0838 }
0839 
0840 static int __maybe_unused stusb160x_resume(struct device *dev)
0841 {
0842     struct stusb160x *chip = dev_get_drvdata(dev);
0843     u32 status;
0844     int ret;
0845 
0846     ret = regcache_sync(chip->regmap);
0847     if (ret)
0848         return ret;
0849 
0850     /* Check if attach/detach occurred during low power */
0851     ret = regmap_read(chip->regmap,
0852               STUSB160X_CC_CONNECTION_STATUS, &status);
0853     if (ret)
0854         return ret;
0855 
0856     if (chip->partner && !(status & STUSB160X_CC_ATTACH))
0857         stusb160x_detach(chip, status);
0858 
0859     if (!chip->partner && (status & STUSB160X_CC_ATTACH)) {
0860         ret = stusb160x_attach(chip, status);
0861         if (ret)
0862             dev_err(chip->dev, "attach failed: %d\n", ret);
0863     }
0864 
0865     /* Unmask interrupts */
0866     return regmap_write_bits(chip->regmap, STUSB160X_ALERT_STATUS_MASK_CTRL,
0867                  STUSB160X_CC_CONNECTION, 0);
0868 }
0869 
0870 static SIMPLE_DEV_PM_OPS(stusb160x_pm_ops, stusb160x_suspend, stusb160x_resume);
0871 
0872 static struct i2c_driver stusb160x_driver = {
0873     .driver = {
0874         .name = "stusb160x",
0875         .pm = &stusb160x_pm_ops,
0876         .of_match_table = stusb160x_of_match,
0877     },
0878     .probe_new = stusb160x_probe,
0879     .remove = stusb160x_remove,
0880 };
0881 module_i2c_driver(stusb160x_driver);
0882 
0883 MODULE_AUTHOR("Amelie Delaunay <amelie.delaunay@st.com>");
0884 MODULE_DESCRIPTION("STMicroelectronics STUSB160x Type-C controller driver");
0885 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!