drivers/usb/pd/policy_engine.c

   1 /* Copyright (c) 2016-2017, Linux Foundation. All rights reserved.
   2  *
   3  * This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License version 2 and
   5  * only version 2 as published by the Free Software Foundation.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  */
  12
  13 #include <linux/completion.h>
  14 #include <linux/delay.h>
  15 #include <linux/hrtimer.h>
  16 #include <linux/ipc_logging.h>
  17 #include <linux/kernel.h>
  18 #include <linux/list.h>
  19 #include <linux/module.h>
  20 #include <linux/of.h>
  21 #include <linux/of_platform.h>
  22 #include <linux/power_supply.h>
  23 #include <linux/regulator/consumer.h>
  24 #include <linux/slab.h>
  25 #include <linux/spinlock.h>
  26 #include <linux/workqueue.h>
  27 #include <linux/extcon.h>
  28 #include <linux/usb/class-dual-role.h>
  29 #include <linux/usb/usbpd.h>
  30 #include "usbpd.h"
  31
  32 /* To start USB stack for USB3.1 complaince testing */
  33 static bool usb_compliance_mode;
  34 module_param(usb_compliance_mode, bool, S_IRUGO|S_IWUSR);
  35 MODULE_PARM_DESC(usb_compliance_mode, "Start USB stack for USB3.1 compliance testing");
  36
  37 static bool disable_usb_pd;
  38 module_param(disable_usb_pd, bool, S_IRUGO|S_IWUSR);
  39 MODULE_PARM_DESC(disable_usb_pd, "Disable USB PD for USB3.1 compliance testing");
  40
  41 static bool rev3_sink_only;
  42 module_param(rev3_sink_only, bool, 0644);
  43 MODULE_PARM_DESC(rev3_sink_only, "Enable power delivery rev3.0 sink only mode");
  44
  45 enum usbpd_state {
  46         PE_UNKNOWN,
  47         PE_ERROR_RECOVERY,
  48         PE_SRC_DISABLED,
  49         PE_SRC_STARTUP,
  50         PE_SRC_SEND_CAPABILITIES,
  51         PE_SRC_SEND_CAPABILITIES_WAIT, /* substate to wait for Request */
  52         PE_SRC_NEGOTIATE_CAPABILITY,
  53         PE_SRC_TRANSITION_SUPPLY,
  54         PE_SRC_READY,
  55         PE_SRC_HARD_RESET,
  56         PE_SRC_SOFT_RESET,
  57         PE_SRC_SEND_SOFT_RESET,
  58         PE_SRC_DISCOVERY,
  59         PE_SRC_TRANSITION_TO_DEFAULT,
  60         PE_SNK_STARTUP,
  61         PE_SNK_DISCOVERY,
  62         PE_SNK_WAIT_FOR_CAPABILITIES,
  63         PE_SNK_EVALUATE_CAPABILITY,
  64         PE_SNK_SELECT_CAPABILITY,
  65         PE_SNK_TRANSITION_SINK,
  66         PE_SNK_READY,
  67         PE_SNK_HARD_RESET,
  68         PE_SNK_SOFT_RESET,
  69         PE_SNK_SEND_SOFT_RESET,
  70         PE_SNK_TRANSITION_TO_DEFAULT,
  71         PE_DRS_SEND_DR_SWAP,
  72         PE_PRS_SNK_SRC_SEND_SWAP,
  73         PE_PRS_SNK_SRC_TRANSITION_TO_OFF,
  74         PE_PRS_SNK_SRC_SOURCE_ON,
  75         PE_PRS_SRC_SNK_SEND_SWAP,
  76         PE_PRS_SRC_SNK_TRANSITION_TO_OFF,
  77         PE_PRS_SRC_SNK_WAIT_SOURCE_ON,
  78         PE_VCS_WAIT_FOR_VCONN,
  79 };
  80
  81 static const char * const usbpd_state_strings[] = {
  82         "UNKNOWN",
  83         "ERROR_RECOVERY",
  84         "SRC_Disabled",
  85         "SRC_Startup",
  86         "SRC_Send_Capabilities",
  87         "SRC_Send_Capabilities (Wait for Request)",
  88         "SRC_Negotiate_Capability",
  89         "SRC_Transition_Supply",
  90         "SRC_Ready",
  91         "SRC_Hard_Reset",
  92         "SRC_Soft_Reset",
  93         "SRC_Send_Soft_Reset",
  94         "SRC_Discovery",
  95         "SRC_Transition_to_default",
  96         "SNK_Startup",
  97         "SNK_Discovery",
  98         "SNK_Wait_for_Capabilities",
  99         "SNK_Evaluate_Capability",
 100         "SNK_Select_Capability",
 101         "SNK_Transition_Sink",
 102         "SNK_Ready",
 103         "SNK_Hard_Reset",
 104         "SNK_Soft_Reset",
 105         "SNK_Send_Soft_Reset",
 106         "SNK_Transition_to_default",
 107         "DRS_Send_DR_Swap",
 108         "PRS_SNK_SRC_Send_Swap",
 109         "PRS_SNK_SRC_Transition_to_off",
 110         "PRS_SNK_SRC_Source_on",
 111         "PRS_SRC_SNK_Send_Swap",
 112         "PRS_SRC_SNK_Transition_to_off",
 113         "PRS_SRC_SNK_Wait_Source_on",
 114         "VCS_Wait_for_VCONN",
 115 };
 116
 117 enum usbpd_control_msg_type {
 118         MSG_RESERVED = 0,
 119         MSG_GOODCRC,
 120         MSG_GOTOMIN,
 121         MSG_ACCEPT,
 122         MSG_REJECT,
 123         MSG_PING,
 124         MSG_PS_RDY,
 125         MSG_GET_SOURCE_CAP,
 126         MSG_GET_SINK_CAP,
 127         MSG_DR_SWAP,
 128         MSG_PR_SWAP,
 129         MSG_VCONN_SWAP,
 130         MSG_WAIT,
 131         MSG_SOFT_RESET,
 132         MSG_NOT_SUPPORTED = 0x10,
 133         MSG_GET_SOURCE_CAP_EXTENDED,
 134         MSG_GET_STATUS,
 135         MSG_FR_SWAP,
 136         MSG_GET_PPS_STATUS,
 137         MSG_GET_COUNTRY_CODES,
 138 };
 139
 140 enum usbpd_data_msg_type {
 141         MSG_SOURCE_CAPABILITIES = 1,
 142         MSG_REQUEST,
 143         MSG_BIST,
 144         MSG_SINK_CAPABILITIES,
 145         MSG_BATTERY_STATUS,
 146         MSG_ALERT,
 147         MSG_GET_COUNTRY_INFO,
 148         MSG_VDM = 0xF,
 149 };
 150
 151 enum usbpd_ext_msg_type {
 152         MSG_SOURCE_CAPABILITIES_EXTENDED = 1,
 153         MSG_STATUS,
 154         MSG_GET_BATTERY_CAP,
 155         MSG_GET_BATTERY_STATUS,
 156         MSG_BATTERY_CAPABILITIES,
 157         MSG_GET_MANUFACTURER_INFO,
 158         MSG_MANUFACTURER_INFO,
 159         MSG_SECURITY_REQUEST,
 160         MSG_SECURITY_RESPONSE,
 161         MSG_FIRMWARE_UPDATE_REQUEST,
 162         MSG_FIRMWARE_UPDATE_RESPONSE,
 163         MSG_PPS_STATUS,
 164         MSG_COUNTRY_INFO,
 165         MSG_COUNTRY_CODES,
 166 };
 167
 168 enum vdm_state {
 169         VDM_NONE,
 170         DISCOVERED_ID,
 171         DISCOVERED_SVIDS,
 172         DISCOVERED_MODES,
 173         MODE_ENTERED,
 174         MODE_EXITED,
 175 };
 176
 177 static void *usbpd_ipc_log;
 178 #define usbpd_dbg(dev, fmt, ...) do { \
 179         ipc_log_string(usbpd_ipc_log, "%s: %s: " fmt, dev_name(dev), __func__, \
 180                         ##__VA_ARGS__); \
 181         dev_dbg(dev, fmt, ##__VA_ARGS__); \
 182         } while (0)
 183
 184 #define usbpd_info(dev, fmt, ...) do { \
 185         ipc_log_string(usbpd_ipc_log, "%s: %s: " fmt, dev_name(dev), __func__, \
 186                         ##__VA_ARGS__); \
 187         dev_info(dev, fmt, ##__VA_ARGS__); \
 188         } while (0)
 189
 190 #define usbpd_warn(dev, fmt, ...) do { \
 191         ipc_log_string(usbpd_ipc_log, "%s: %s: " fmt, dev_name(dev), __func__, \
 192                         ##__VA_ARGS__); \
 193         dev_warn(dev, fmt, ##__VA_ARGS__); \
 194         } while (0)
 195
 196 #define usbpd_err(dev, fmt, ...) do { \
 197         ipc_log_string(usbpd_ipc_log, "%s: %s: " fmt, dev_name(dev), __func__, \
 198                         ##__VA_ARGS__); \
 199         dev_err(dev, fmt, ##__VA_ARGS__); \
 200         } while (0)
 201
 202 #define NUM_LOG_PAGES           10
 203
 204 /* Timeouts (in ms) */
 205 #define ERROR_RECOVERY_TIME     25
 206 #define SENDER_RESPONSE_TIME    26
 207 #define SINK_WAIT_CAP_TIME      500
 208 #define PS_TRANSITION_TIME      450
 209 #define SRC_CAP_TIME            120
 210 #define SRC_TRANSITION_TIME     25
 211 #define SRC_RECOVER_TIME        750
 212 #define PS_HARD_RESET_TIME      25
 213 #define PS_SOURCE_ON            400
 214 #define PS_SOURCE_OFF           750
 215 #define FIRST_SOURCE_CAP_TIME   200
 216 #define VDM_BUSY_TIME           50
 217 #define VCONN_ON_TIME           100
 218
 219 /* tPSHardReset + tSafe0V */
 220 #define SNK_HARD_RESET_VBUS_OFF_TIME    (35 + 650)
 221
 222 /* tSrcRecover + tSrcTurnOn */
 223 #define SNK_HARD_RESET_VBUS_ON_TIME     (1000 + 275)
 224
 225 #define PD_CAPS_COUNT           50
 226
 227 #define PD_MAX_MSG_ID           7
 228
 229 #define PD_MAX_DATA_OBJ         7
 230
 231 #define PD_SRC_CAP_EXT_DB_LEN   24
 232 #define PD_STATUS_DB_LEN        5
 233 #define PD_BATTERY_CAP_DB_LEN   9
 234
 235 #define PD_MAX_EXT_MSG_LEN              260
 236 #define PD_MAX_EXT_MSG_LEGACY_LEN       26
 237
 238 #define PD_MSG_HDR(type, dr, pr, id, cnt, rev) \
 239         (((type) & 0x1F) | ((dr) << 5) | (rev << 6) | \
 240          ((pr) << 8) | ((id) << 9) | ((cnt) << 12))
 241 #define PD_MSG_HDR_COUNT(hdr)           (((hdr) >> 12) & 7)
 242 #define PD_MSG_HDR_TYPE(hdr)            ((hdr) & 0x1F)
 243 #define PD_MSG_HDR_ID(hdr)              (((hdr) >> 9) & 7)
 244 #define PD_MSG_HDR_REV(hdr)             (((hdr) >> 6) & 3)
 245 #define PD_MSG_HDR_EXTENDED             BIT(15)
 246 #define PD_MSG_HDR_IS_EXTENDED(hdr)     ((hdr) & PD_MSG_HDR_EXTENDED)
 247
 248 #define PD_MSG_EXT_HDR(chunked, num, req, size) \
 249         (((chunked) << 15) | (((num) & 0xF) << 11) | \
 250          ((req) << 10) | ((size) & 0x1FF))
 251 #define PD_MSG_EXT_HDR_IS_CHUNKED(ehdr) ((ehdr) & 0x8000)
 252 #define PD_MSG_EXT_HDR_CHUNK_NUM(ehdr)  (((ehdr) >> 11) & 0xF)
 253 #define PD_MSG_EXT_HDR_REQ_CHUNK(ehdr)  ((ehdr) & 0x400)
 254 #define PD_MSG_EXT_HDR_DATA_SIZE(ehdr)  ((ehdr) & 0x1FF)
 255
 256 #define PD_RDO_FIXED(obj, gb, mismatch, usb_comm, no_usb_susp, curr1, curr2) \
 257                 (((obj) << 28) | ((gb) << 27) | ((mismatch) << 26) | \
 258                  ((usb_comm) << 25) | ((no_usb_susp) << 24) | \
 259                  ((curr1) << 10) | (curr2))
 260
 261 #define PD_RDO_AUGMENTED(obj, mismatch, usb_comm, no_usb_susp, volt, curr) \
 262                 (((obj) << 28) | ((mismatch) << 26) | ((usb_comm) << 25) | \
 263                  ((no_usb_susp) << 24) | ((volt) << 9) | (curr))
 264
 265 #define PD_RDO_OBJ_POS(rdo)             ((rdo) >> 28 & 7)
 266 #define PD_RDO_GIVEBACK(rdo)            ((rdo) >> 27 & 1)
 267 #define PD_RDO_MISMATCH(rdo)            ((rdo) >> 26 & 1)
 268 #define PD_RDO_USB_COMM(rdo)            ((rdo) >> 25 & 1)
 269 #define PD_RDO_NO_USB_SUSP(rdo)         ((rdo) >> 24 & 1)
 270 #define PD_RDO_FIXED_CURR(rdo)          ((rdo) >> 10 & 0x3FF)
 271 #define PD_RDO_FIXED_CURR_MINMAX(rdo)   ((rdo) & 0x3FF)
 272 #define PD_RDO_PROG_VOLTAGE(rdo)        ((rdo) >> 9 & 0x7FF)
 273 #define PD_RDO_PROG_CURR(rdo)           ((rdo) & 0x7F)
 274
 275 #define PD_SRC_PDO_TYPE(pdo)            (((pdo) >> 30) & 3)
 276 #define PD_SRC_PDO_TYPE_FIXED           0
 277 #define PD_SRC_PDO_TYPE_BATTERY         1
 278 #define PD_SRC_PDO_TYPE_VARIABLE        2
 279 #define PD_SRC_PDO_TYPE_AUGMENTED       3
 280
 281 #define PD_SRC_PDO_FIXED_PR_SWAP(pdo)           (((pdo) >> 29) & 1)
 282 #define PD_SRC_PDO_FIXED_USB_SUSP(pdo)          (((pdo) >> 28) & 1)
 283 #define PD_SRC_PDO_FIXED_EXT_POWERED(pdo)       (((pdo) >> 27) & 1)
 284 #define PD_SRC_PDO_FIXED_USB_COMM(pdo)          (((pdo) >> 26) & 1)
 285 #define PD_SRC_PDO_FIXED_DR_SWAP(pdo)           (((pdo) >> 25) & 1)
 286 #define PD_SRC_PDO_FIXED_PEAK_CURR(pdo)         (((pdo) >> 20) & 3)
 287 #define PD_SRC_PDO_FIXED_VOLTAGE(pdo)           (((pdo) >> 10) & 0x3FF)
 288 #define PD_SRC_PDO_FIXED_MAX_CURR(pdo)          ((pdo) & 0x3FF)
 289
 290 #define PD_SRC_PDO_VAR_BATT_MAX_VOLT(pdo)       (((pdo) >> 20) & 0x3FF)
 291 #define PD_SRC_PDO_VAR_BATT_MIN_VOLT(pdo)       (((pdo) >> 10) & 0x3FF)
 292 #define PD_SRC_PDO_VAR_BATT_MAX(pdo)            ((pdo) & 0x3FF)
 293
 294 #define PD_APDO_PPS(pdo)                        (((pdo) >> 28) & 3)
 295 #define PD_APDO_MAX_VOLT(pdo)                   (((pdo) >> 17) & 0xFF)
 296 #define PD_APDO_MIN_VOLT(pdo)                   (((pdo) >> 8) & 0xFF)
 297 #define PD_APDO_MAX_CURR(pdo)                   ((pdo) & 0x7F)
 298
 299 /* Vendor Defined Messages */
 300 #define MAX_CRC_RECEIVE_TIME    9 /* ~(2 * tReceive_max(1.1ms) * # retry 4) */
 301 #define MAX_VDM_RESPONSE_TIME   60 /* 2 * tVDMSenderResponse_max(30ms) */
 302 #define MAX_VDM_BUSY_TIME       100 /* 2 * tVDMBusy (50ms) */
 303
 304 #define PD_SNK_PDO_FIXED(prs, hc, uc, usb_comm, drs, volt, curr) \
 305         (((prs) << 29) | ((hc) << 28) | ((uc) << 27) | ((usb_comm) << 26) | \
 306          ((drs) << 25) | ((volt) << 10) | (curr))
 307
 308 /* VDM header is the first 32-bit object following the 16-bit PD header */
 309 #define VDM_HDR_SVID(hdr)       ((hdr) >> 16)
 310 #define VDM_IS_SVDM(hdr)        ((hdr) & 0x8000)
 311 #define SVDM_HDR_OBJ_POS(hdr)   (((hdr) >> 8) & 0x7)
 312 #define SVDM_HDR_CMD_TYPE(hdr)  (((hdr) >> 6) & 0x3)
 313 #define SVDM_HDR_CMD(hdr)       ((hdr) & 0x1f)
 314
 315 #define SVDM_HDR(svid, ver, obj, cmd_type, cmd) \
 316         (((svid) << 16) | (1 << 15) | ((ver) << 13) \
 317         | ((obj) << 8) | ((cmd_type) << 6) | (cmd))
 318
 319 /* discover id response vdo bit fields */
 320 #define ID_HDR_USB_HOST         BIT(31)
 321 #define ID_HDR_USB_DEVICE       BIT(30)
 322 #define ID_HDR_MODAL_OPR        BIT(26)
 323 #define ID_HDR_PRODUCT_TYPE(n)  ((n) >> 27)
 324 #define ID_HDR_PRODUCT_PER_MASK (2 << 27)
 325 #define ID_HDR_PRODUCT_HUB      1
 326 #define ID_HDR_PRODUCT_PER      2
 327 #define ID_HDR_PRODUCT_AMA      5
 328 #define ID_HDR_VID              0x05c6 /* qcom */
 329 #define PROD_VDO_PID            0x0a00 /* TBD */
 330
 331 static bool check_vsafe0v = true;
 332 module_param(check_vsafe0v, bool, S_IRUSR | S_IWUSR);
 333
 334 static int min_sink_current = 900;
 335 module_param(min_sink_current, int, S_IRUSR | S_IWUSR);
 336
 337 static const u32 default_src_caps[] = { 0x36019096 };   /* VSafe5V @ 1.5A */
 338 static const u32 default_snk_caps[] = { 0x2601912C };   /* VSafe5V @ 3A */
 339
 340 struct vdm_tx {
 341         u32                     data[PD_MAX_DATA_OBJ];
 342         int                     size;
 343 };
 344
 345 struct rx_msg {
 346         u16                     hdr;
 347         u16                     data_len;       /* size of payload in bytes */
 348         struct list_head        entry;
 349         u8                      payload[];
 350 };
 351
 352 #define IS_DATA(m, t) ((m) && !PD_MSG_HDR_IS_EXTENDED((m)->hdr) && \
 353                 PD_MSG_HDR_COUNT((m)->hdr) && \
 354                 (PD_MSG_HDR_TYPE((m)->hdr) == (t)))
 355 #define IS_CTRL(m, t) ((m) && !PD_MSG_HDR_COUNT((m)->hdr) && \
 356                 (PD_MSG_HDR_TYPE((m)->hdr) == (t)))
 357 #define IS_EXT(m, t) ((m) && PD_MSG_HDR_IS_EXTENDED((m)->hdr) && \
 358                 (PD_MSG_HDR_TYPE((m)->hdr) == (t)))
 359
 360 struct usbpd {
 361         struct device           dev;
 362         struct workqueue_struct *wq;
 363         struct work_struct      sm_work;
 364         struct hrtimer          timer;
 365         bool                    sm_queued;
 366
 367         struct extcon_dev       *extcon;
 368
 369         enum usbpd_state        current_state;
 370         bool                    hard_reset_recvd;
 371         ktime_t                 hard_reset_recvd_time;
 372         struct list_head        rx_q;
 373         spinlock_t              rx_lock;
 374         struct rx_msg           *rx_ext_msg;
 375
 376         u32                     received_pdos[PD_MAX_DATA_OBJ];
 377         u32                     received_ado;
 378         u16                     src_cap_id;
 379         u8                      selected_pdo;
 380         u8                      requested_pdo;
 381         u32                     rdo;    /* can be either source or sink */
 382         int                     current_voltage;        /* uV */
 383         int                     requested_voltage;      /* uV */
 384         int                     requested_current;      /* mA */
 385         bool                    pd_connected;
 386         bool                    in_explicit_contract;
 387         bool                    peer_usb_comm;
 388         bool                    peer_pr_swap;
 389         bool                    peer_dr_swap;
 390
 391         u32                     sink_caps[7];
 392         int                     num_sink_caps;
 393
 394         struct power_supply     *usb_psy;
 395         struct notifier_block   psy_nb;
 396
 397         enum power_supply_typec_mode typec_mode;
 398         enum power_supply_type  psy_type;
 399         enum power_supply_typec_power_role forced_pr;
 400         bool                    vbus_present;
 401
 402         enum pd_spec_rev        spec_rev;
 403         enum data_role          current_dr;
 404         enum power_role         current_pr;
 405         bool                    in_pr_swap;
 406         bool                    pd_phy_opened;
 407         bool                    send_request;
 408         struct completion       is_ready;
 409         struct completion       tx_chunk_request;
 410         u8                      next_tx_chunk;
 411
 412         struct mutex            swap_lock;
 413         struct dual_role_phy_instance   *dual_role;
 414         struct dual_role_phy_desc       dr_desc;
 415         bool                    send_pr_swap;
 416         bool                    send_dr_swap;
 417
 418         struct regulator        *vbus;
 419         struct regulator        *vconn;
 420         bool                    vbus_enabled;
 421         bool                    vconn_enabled;
 422         bool                    vconn_is_external;
 423
 424         u8                      tx_msgid;
 425         u8                      rx_msgid;
 426         int                     caps_count;
 427         int                     hard_reset_count;
 428
 429         enum vdm_state          vdm_state;
 430         u16                     *discovered_svids;
 431         int                     num_svids;
 432         struct vdm_tx           *vdm_tx;
 433         struct vdm_tx           *vdm_tx_retry;
 434         struct list_head        svid_handlers;
 435
 436         struct list_head        instance;
 437
 438         /* ext msg support */
 439         bool                    send_get_src_cap_ext;
 440         u8                      src_cap_ext_db[PD_SRC_CAP_EXT_DB_LEN];
 441         bool                    send_get_pps_status;
 442         u32                     pps_status_db;
 443         u8                      status_db[PD_STATUS_DB_LEN];
 444         bool                    send_get_battery_cap;
 445         u8                      get_battery_cap_db;
 446         u8                      battery_cap_db[PD_BATTERY_CAP_DB_LEN];
 447         u8                      get_battery_status_db;
 448         bool                    send_get_battery_status;
 449         u32                     battery_sts_dobj;
 450 };
 451
 452 static LIST_HEAD(_usbpd);       /* useful for debugging */
 453
 454 static const unsigned int usbpd_extcon_cable[] = {
 455         EXTCON_USB,
 456         EXTCON_USB_HOST,
 457         EXTCON_USB_CC,
 458         EXTCON_USB_SPEED,
 459         EXTCON_USB_TYPEC_MED_HIGH_CURRENT,
 460         EXTCON_NONE,
 461 };
 462
 463 /* EXTCON_USB and EXTCON_USB_HOST are mutually exclusive */
 464 static const u32 usbpd_extcon_exclusive[] = {0x3, 0};
 465
 466 enum plug_orientation usbpd_get_plug_orientation(struct usbpd *pd)
 467 {
 468         int ret;
 469         union power_supply_propval val;
 470
 471         ret = power_supply_get_property(pd->usb_psy,
 472                 POWER_SUPPLY_PROP_TYPEC_CC_ORIENTATION, &val);
 473         if (ret)
 474                 return ORIENTATION_NONE;
 475
 476         return val.intval;
 477 }
 478 EXPORT_SYMBOL(usbpd_get_plug_orientation);
 479
 480 static inline void stop_usb_host(struct usbpd *pd)
 481 {
 482         extcon_set_cable_state_(pd->extcon, EXTCON_USB_HOST, 0);
 483 }
 484
 485 static inline void start_usb_host(struct usbpd *pd, bool ss)
 486 {
 487         enum plug_orientation cc = usbpd_get_plug_orientation(pd);
 488
 489         extcon_set_cable_state_(pd->extcon, EXTCON_USB_CC,
 490                         cc == ORIENTATION_CC2);
 491         extcon_set_cable_state_(pd->extcon, EXTCON_USB_SPEED, ss);
 492         extcon_set_cable_state_(pd->extcon, EXTCON_USB_HOST, 1);
 493 }
 494
 495 static inline void stop_usb_peripheral(struct usbpd *pd)
 496 {
 497         extcon_set_cable_state_(pd->extcon, EXTCON_USB, 0);
 498 }
 499
 500 static inline void start_usb_peripheral(struct usbpd *pd)
 501 {
 502         enum plug_orientation cc = usbpd_get_plug_orientation(pd);
 503
 504         extcon_set_cable_state_(pd->extcon, EXTCON_USB_CC,
 505                         cc == ORIENTATION_CC2);
 506         extcon_set_cable_state_(pd->extcon, EXTCON_USB_SPEED, 1);
 507         extcon_set_cable_state_(pd->extcon, EXTCON_USB_TYPEC_MED_HIGH_CURRENT,
 508                 pd->typec_mode > POWER_SUPPLY_TYPEC_SOURCE_DEFAULT ? 1 : 0);
 509         extcon_set_cable_state_(pd->extcon, EXTCON_USB, 1);
 510 }
 511
 512 static int set_power_role(struct usbpd *pd, enum power_role pr)
 513 {
 514         union power_supply_propval val = {0};
 515
 516         switch (pr) {
 517         case PR_NONE:
 518                 val.intval = POWER_SUPPLY_TYPEC_PR_NONE;
 519                 break;
 520         case PR_SINK:
 521                 val.intval = POWER_SUPPLY_TYPEC_PR_SINK;
 522                 break;
 523         case PR_SRC:
 524                 val.intval = POWER_SUPPLY_TYPEC_PR_SOURCE;
 525                 break;
 526         }
 527
 528         return power_supply_set_property(pd->usb_psy,
 529                         POWER_SUPPLY_PROP_TYPEC_POWER_ROLE, &val);
 530 }
 531
 532 static struct usbpd_svid_handler *find_svid_handler(struct usbpd *pd, u16 svid)
 533 {
 534         struct usbpd_svid_handler *handler;
 535
 536         list_for_each_entry(handler, &pd->svid_handlers, entry)
 537                 if (svid == handler->svid)
 538                         return handler;
 539
 540         return NULL;
 541 }
 542
 543 /* Reset protocol layer */
 544 static inline void pd_reset_protocol(struct usbpd *pd)
 545 {
 546         /*
 547          * first Rx ID should be 0; set this to a sentinel of -1 so that in
 548          * phy_msg_received() we can check if we had seen it before.
 549          */
 550         pd->rx_msgid = -1;
 551         pd->tx_msgid = 0;
 552         pd->send_request = false;
 553         pd->send_pr_swap = false;
 554         pd->send_dr_swap = false;
 555 }
 556
 557 static int pd_send_msg(struct usbpd *pd, u8 msg_type, const u32 *data,
 558                 size_t num_data, enum pd_sop_type sop)
 559 {
 560         int ret;
 561         u16 hdr;
 562
 563         if (pd->hard_reset_recvd)
 564                 return -EBUSY;
 565
 566         hdr = PD_MSG_HDR(msg_type, pd->current_dr, pd->current_pr,
 567                         pd->tx_msgid, num_data, pd->spec_rev);
 568
 569         ret = pd_phy_write(hdr, (u8 *)data, num_data * sizeof(u32), sop);
 570         if (ret)
 571                 return ret;
 572
 573         pd->tx_msgid = (pd->tx_msgid + 1) & PD_MAX_MSG_ID;
 574         return 0;
 575 }
 576
 577 static int pd_send_ext_msg(struct usbpd *pd, u8 msg_type,
 578                 const u8 *data, size_t data_len, enum pd_sop_type sop)
 579 {
 580         int ret;
 581         size_t len_remain, chunk_len;
 582         u8 chunked_payload[PD_MAX_DATA_OBJ * sizeof(u32)] = {0};
 583         u16 hdr;
 584         u16 ext_hdr;
 585         u8 num_objs;
 586
 587         if (data_len > PD_MAX_EXT_MSG_LEN) {
 588                 usbpd_warn(&pd->dev, "Extended message length exceeds max, truncating...\n");
 589                 data_len = PD_MAX_EXT_MSG_LEN;
 590         }
 591
 592         pd->next_tx_chunk = 0;
 593         len_remain = data_len;
 594         do {
 595                 ext_hdr = PD_MSG_EXT_HDR(1, pd->next_tx_chunk++, 0, data_len);
 596                 memcpy(chunked_payload, &ext_hdr, sizeof(ext_hdr));
 597
 598                 chunk_len = min_t(size_t, len_remain,
 599                                 PD_MAX_EXT_MSG_LEGACY_LEN);
 600                 memcpy(chunked_payload + sizeof(ext_hdr), data, chunk_len);
 601
 602                 num_objs = DIV_ROUND_UP(chunk_len + sizeof(u16), sizeof(u32));
 603                 len_remain -= chunk_len;
 604
 605                 reinit_completion(&pd->tx_chunk_request);
 606                 hdr = PD_MSG_HDR(msg_type, pd->current_dr, pd->current_pr,
 607                                 pd->tx_msgid, num_objs, pd->spec_rev) |
 608                         PD_MSG_HDR_EXTENDED;
 609                 ret = pd_phy_write(hdr, chunked_payload,
 610                                 num_objs * sizeof(u32), sop);
 611                 if (ret)
 612                         return ret;
 613
 614                 pd->tx_msgid = (pd->tx_msgid + 1) & PD_MAX_MSG_ID;
 615
 616                 /* Wait for request chunk */
 617                 if (len_remain &&
 618                         !wait_for_completion_timeout(&pd->tx_chunk_request,
 619                                 msecs_to_jiffies(SENDER_RESPONSE_TIME))) {
 620                         usbpd_err(&pd->dev, "Timed out waiting for chunk request\n");
 621                         return -EPROTO;
 622                 }
 623         } while (len_remain);
 624
 625         return 0;
 626 }
 627
 628 static int pd_select_pdo(struct usbpd *pd, int pdo_pos, int uv, int ua)
 629 {
 630         int curr;
 631         int max_current;
 632         bool mismatch = false;
 633         u8 type;
 634         u32 pdo = pd->received_pdos[pdo_pos - 1];
 635
 636         type = PD_SRC_PDO_TYPE(pdo);
 637         if (type == PD_SRC_PDO_TYPE_FIXED) {
 638                 curr = max_current = PD_SRC_PDO_FIXED_MAX_CURR(pdo) * 10;
 639
 640                 /*
 641                  * Check if the PDO has enough current, otherwise set the
 642                  * Capability Mismatch flag
 643                  */
 644                 if (curr < min_sink_current) {
 645                         mismatch = true;
 646                         max_current = min_sink_current;
 647                 }
 648
 649                 pd->requested_voltage =
 650                         PD_SRC_PDO_FIXED_VOLTAGE(pdo) * 50 * 1000;
 651                 pd->rdo = PD_RDO_FIXED(pdo_pos, 0, mismatch, 1, 1, curr / 10,
 652                                 max_current / 10);
 653         } else if (type == PD_SRC_PDO_TYPE_AUGMENTED) {
 654                 if ((uv / 100000) > PD_APDO_MAX_VOLT(pdo) ||
 655                         (uv / 100000) < PD_APDO_MIN_VOLT(pdo) ||
 656                         (ua / 50000) > PD_APDO_MAX_CURR(pdo) || (ua < 0)) {
 657                         usbpd_err(&pd->dev, "uv (%d) and ua (%d) out of range of APDO\n",
 658                                         uv, ua);
 659                         return -EINVAL;
 660                 }
 661
 662                 curr = ua / 1000;
 663                 pd->requested_voltage = uv;
 664                 pd->rdo = PD_RDO_AUGMENTED(pdo_pos, mismatch, 1, 1,
 665                                 uv / 20000, ua / 50000);
 666         } else {
 667                 usbpd_err(&pd->dev, "Only Fixed or Programmable PDOs supported\n");
 668                 return -ENOTSUPP;
 669         }
 670
 671         /* Can't sink more than 5V if VCONN is sourced from the VBUS input */
 672         if (pd->vconn_enabled && !pd->vconn_is_external &&
 673                         pd->requested_voltage > 5000000)
 674                 return -ENOTSUPP;
 675
 676         pd->requested_current = curr;
 677         pd->requested_pdo = pdo_pos;
 678
 679         return 0;
 680 }
 681
 682 static int pd_eval_src_caps(struct usbpd *pd)
 683 {
 684         int i;
 685         union power_supply_propval val;
 686         u32 first_pdo = pd->received_pdos[0];
 687
 688         if (PD_SRC_PDO_TYPE(first_pdo) != PD_SRC_PDO_TYPE_FIXED) {
 689                 usbpd_err(&pd->dev, "First src_cap invalid! %08x\n", first_pdo);
 690                 return -EINVAL;
 691         }
 692
 693         pd->peer_usb_comm = PD_SRC_PDO_FIXED_USB_COMM(first_pdo);
 694         pd->peer_pr_swap = PD_SRC_PDO_FIXED_PR_SWAP(first_pdo);
 695         pd->peer_dr_swap = PD_SRC_PDO_FIXED_DR_SWAP(first_pdo);
 696
 697         val.intval = PD_SRC_PDO_FIXED_USB_SUSP(first_pdo);
 698         power_supply_set_property(pd->usb_psy,
 699                         POWER_SUPPLY_PROP_PD_USB_SUSPEND_SUPPORTED, &val);
 700
 701         if (pd->spec_rev == USBPD_REV_30 && !rev3_sink_only) {
 702                 bool pps_found = false;
 703
 704                 /* downgrade to 2.0 if no PPS */
 705                 for (i = 1; i < PD_MAX_DATA_OBJ; i++) {
 706                         if ((PD_SRC_PDO_TYPE(pd->received_pdos[i]) ==
 707                                         PD_SRC_PDO_TYPE_AUGMENTED) &&
 708                                 !PD_APDO_PPS(pd->received_pdos[i])) {
 709                                 pps_found = true;
 710                                 break;
 711                         }
 712                 }
 713                 if (!pps_found)
 714                         pd->spec_rev = USBPD_REV_20;
 715         }
 716
 717         /* Select the first PDO (vSafe5V) immediately. */
 718         pd_select_pdo(pd, 1, 0, 0);
 719
 720         return 0;
 721 }
 722
 723 static void pd_send_hard_reset(struct usbpd *pd)
 724 {
 725         union power_supply_propval val = {0};
 726
 727         usbpd_dbg(&pd->dev, "send hard reset");
 728
 729         /* Force CC logic to source/sink to keep Rp/Rd unchanged */
 730         set_power_role(pd, pd->current_pr);
 731         pd->hard_reset_count++;
 732         pd_phy_signal(HARD_RESET_SIG);
 733         pd->in_pr_swap = false;
 734         power_supply_set_property(pd->usb_psy, POWER_SUPPLY_PROP_PR_SWAP, &val);
 735 }
 736
 737 static void kick_sm(struct usbpd *pd, int ms)
 738 {
 739         pm_stay_awake(&pd->dev);
 740         pd->sm_queued = true;
 741
 742         if (ms)
 743                 hrtimer_start(&pd->timer, ms_to_ktime(ms), HRTIMER_MODE_REL);
 744         else
 745                 queue_work(pd->wq, &pd->sm_work);
 746 }
 747
 748 static void phy_sig_received(struct usbpd *pd, enum pd_sig_type sig)
 749 {
 750         union power_supply_propval val = {1};
 751
 752         if (sig != HARD_RESET_SIG) {
 753                 usbpd_err(&pd->dev, "invalid signal (%d) received\n", sig);
 754                 return;
 755         }
 756
 757         pd->hard_reset_recvd = true;
 758         pd->hard_reset_recvd_time = ktime_get();
 759
 760         usbpd_err(&pd->dev, "hard reset received\n");
 761
 762         /* Force CC logic to source/sink to keep Rp/Rd unchanged */
 763         set_power_role(pd, pd->current_pr);
 764         power_supply_set_property(pd->usb_psy,
 765                         POWER_SUPPLY_PROP_PD_IN_HARD_RESET, &val);
 766
 767         kick_sm(pd, 0);
 768 }
 769
 770 struct pd_request_chunk {
 771         struct work_struct      w;
 772         struct usbpd            *pd;
 773         u8                      msg_type;
 774         u8                      chunk_num;
 775         enum pd_sop_type        sop;
 776 };
 777
 778 static void pd_request_chunk_work(struct work_struct *w)
 779 {
 780         struct pd_request_chunk *req =
 781                 container_of(w, struct pd_request_chunk, w);
 782         struct usbpd *pd = req->pd;
 783         unsigned long flags;
 784         int ret;
 785         u8 payload[4] = {0}; /* ext_hdr + padding */
 786         u16 hdr = PD_MSG_HDR(req->msg_type, pd->current_dr, pd->current_pr,
 787                         pd->tx_msgid, 1, pd->spec_rev) | PD_MSG_HDR_EXTENDED;
 788
 789         *(u16 *)payload = PD_MSG_EXT_HDR(1, req->chunk_num, 1, 0);
 790
 791         ret = pd_phy_write(hdr, payload, sizeof(payload), req->sop);
 792         if (!ret) {
 793                 pd->tx_msgid = (pd->tx_msgid + 1) & PD_MAX_MSG_ID;
 794         } else {
 795                 usbpd_err(&pd->dev, "could not send chunk request\n");
 796
 797                 /* queue what we have anyway */
 798                 spin_lock_irqsave(&pd->rx_lock, flags);
 799                 list_add_tail(&pd->rx_ext_msg->entry, &pd->rx_q);
 800                 spin_unlock_irqrestore(&pd->rx_lock, flags);
 801
 802                 pd->rx_ext_msg = NULL;
 803         }
 804
 805         kfree(req);
 806 }
 807
 808 static struct rx_msg *pd_ext_msg_received(struct usbpd *pd, u16 header, u8 *buf,
 809                 size_t len, enum pd_sop_type sop)
 810 {
 811         struct rx_msg *rx_msg;
 812         u16 bytes_to_copy;
 813         u16 ext_hdr = *(u16 *)buf;
 814         u8 chunk_num;
 815
 816         if (!PD_MSG_EXT_HDR_IS_CHUNKED(ext_hdr)) {
 817                 usbpd_err(&pd->dev, "unchunked extended messages unsupported\n");
 818                 return NULL;
 819         }
 820
 821         /* request for next Tx chunk */
 822         if (PD_MSG_EXT_HDR_REQ_CHUNK(ext_hdr)) {
 823                 if (PD_MSG_EXT_HDR_DATA_SIZE(ext_hdr) ||
 824                         PD_MSG_EXT_HDR_CHUNK_NUM(ext_hdr) !=
 825                                 pd->next_tx_chunk) {
 826                         usbpd_err(&pd->dev, "invalid request chunk ext header 0x%02x\n",
 827                                         ext_hdr);
 828                         return NULL;
 829                 }
 830
 831                 if (!completion_done(&pd->tx_chunk_request))
 832                         complete(&pd->tx_chunk_request);
 833
 834                 return NULL;
 835         }
 836
 837         chunk_num = PD_MSG_EXT_HDR_CHUNK_NUM(ext_hdr);
 838         if (!chunk_num) {
 839                 /* allocate new message if first chunk */
 840                 rx_msg = kzalloc(sizeof(*rx_msg) +
 841                                 PD_MSG_EXT_HDR_DATA_SIZE(ext_hdr),
 842                                 GFP_ATOMIC);
 843                 if (!rx_msg)
 844                         return NULL;
 845
 846                 rx_msg->hdr = header;
 847                 rx_msg->data_len = PD_MSG_EXT_HDR_DATA_SIZE(ext_hdr);
 848
 849                 if (rx_msg->data_len > PD_MAX_EXT_MSG_LEN) {
 850                         usbpd_warn(&pd->dev, "Extended message length exceeds max, truncating...\n");
 851                         rx_msg->data_len = PD_MAX_EXT_MSG_LEN;
 852                 }
 853         } else {
 854                 if (!pd->rx_ext_msg) {
 855                         usbpd_err(&pd->dev, "missing first rx_ext_msg chunk\n");
 856                         return NULL;
 857                 }
 858
 859                 rx_msg = pd->rx_ext_msg;
 860         }
 861
 862         /*
 863          * The amount to copy is derived as follows:
 864          *
 865          * - if extended data_len < 26, then copy data_len bytes
 866          * - for chunks 0..N-2, copy 26 bytes
 867          * - for the last chunk (N-1), copy the remainder
 868          */
 869         bytes_to_copy =
 870                 min((rx_msg->data_len - chunk_num * PD_MAX_EXT_MSG_LEGACY_LEN),
 871                         PD_MAX_EXT_MSG_LEGACY_LEN);
 872
 873         /* check against received length to avoid overrun */
 874         if (bytes_to_copy > len - sizeof(ext_hdr)) {
 875                 usbpd_warn(&pd->dev, "not enough bytes in chunk, expected:%u received:%zu\n",
 876                         bytes_to_copy, len - sizeof(ext_hdr));
 877                 bytes_to_copy = len - sizeof(ext_hdr);
 878         }
 879
 880         memcpy(rx_msg->payload + chunk_num * PD_MAX_EXT_MSG_LEGACY_LEN, buf + 2,
 881                         bytes_to_copy);
 882
 883         /* request next chunk? */
 884         if ((rx_msg->data_len - chunk_num * PD_MAX_EXT_MSG_LEGACY_LEN) >
 885                         PD_MAX_EXT_MSG_LEGACY_LEN) {
 886                 struct pd_request_chunk *req;
 887
 888                 if (pd->rx_ext_msg && pd->rx_ext_msg != rx_msg) {
 889                         usbpd_dbg(&pd->dev, "stale previous rx_ext_msg?\n");
 890                         kfree(pd->rx_ext_msg);
 891                 }
 892
 893                 pd->rx_ext_msg = rx_msg;
 894
 895                 req = kzalloc(sizeof(*req), GFP_ATOMIC);
 896                 if (!req)
 897                         goto queue_rx; /* return what we have anyway */
 898
 899                 INIT_WORK(&req->w, pd_request_chunk_work);
 900                 req->pd = pd;
 901                 req->msg_type = PD_MSG_HDR_TYPE(header);
 902                 req->chunk_num = chunk_num + 1;
 903                 req->sop = sop;
 904                 queue_work(pd->wq, &req->w);
 905
 906                 return NULL;
 907         }
 908
 909 queue_rx:
 910         pd->rx_ext_msg = NULL;
 911         return rx_msg;  /* queue it for usbpd_sm */
 912 }
 913
 914 static void phy_msg_received(struct usbpd *pd, enum pd_sop_type sop,
 915                 u8 *buf, size_t len)
 916 {
 917         struct rx_msg *rx_msg;
 918         unsigned long flags;
 919         u16 header;
 920
 921         if (sop != SOP_MSG) {
 922                 usbpd_err(&pd->dev, "invalid msg type (%d) received; only SOP supported\n",
 923                                 sop);
 924                 return;
 925         }
 926
 927         if (len < 2) {
 928                 usbpd_err(&pd->dev, "invalid message received, len=%zd\n", len);
 929                 return;
 930         }
 931
 932         header = *((u16 *)buf);
 933         buf += sizeof(u16);
 934         len -= sizeof(u16);
 935
 936         if (len % 4 != 0) {
 937                 usbpd_err(&pd->dev, "len=%zd not multiple of 4\n", len);
 938                 return;
 939         }
 940
 941         /* if MSGID already seen, discard */
 942         if (PD_MSG_HDR_ID(header) == pd->rx_msgid &&
 943                         PD_MSG_HDR_TYPE(header) != MSG_SOFT_RESET) {
 944                 usbpd_dbg(&pd->dev, "MessageID already seen, discarding\n");
 945                 return;
 946         }
 947
 948         pd->rx_msgid = PD_MSG_HDR_ID(header);
 949
 950         /* discard Pings */
 951         if (PD_MSG_HDR_TYPE(header) == MSG_PING && !len)
 952                 return;
 953
 954         /* check header's count field to see if it matches len */
 955         if (PD_MSG_HDR_COUNT(header) != (len / 4)) {
 956                 usbpd_err(&pd->dev, "header count (%d) mismatch, len=%zd\n",
 957                                 PD_MSG_HDR_COUNT(header), len);
 958                 return;
 959         }
 960
 961         /* if spec rev differs (i.e. is older), update PHY */
 962         if (PD_MSG_HDR_REV(header) < pd->spec_rev)
 963                 pd->spec_rev = PD_MSG_HDR_REV(header);
 964
 965         usbpd_dbg(&pd->dev, "received message: type(%d) num_objs(%d)\n",
 966                         PD_MSG_HDR_TYPE(header), PD_MSG_HDR_COUNT(header));
 967
 968         if (!PD_MSG_HDR_IS_EXTENDED(header)) {
 969                 rx_msg = kzalloc(sizeof(*rx_msg) + len, GFP_ATOMIC);
 970                 if (!rx_msg)
 971                         return;
 972
 973                 rx_msg->hdr = header;
 974                 rx_msg->data_len = len;
 975                 memcpy(rx_msg->payload, buf, len);
 976         } else {
 977                 rx_msg = pd_ext_msg_received(pd, header, buf, len, sop);
 978                 if (!rx_msg)
 979                         return;
 980         }
 981
 982         spin_lock_irqsave(&pd->rx_lock, flags);
 983         list_add_tail(&rx_msg->entry, &pd->rx_q);
 984         spin_unlock_irqrestore(&pd->rx_lock, flags);
 985
 986         kick_sm(pd, 0);
 987 }
 988
 989 static void phy_shutdown(struct usbpd *pd)
 990 {
 991         usbpd_dbg(&pd->dev, "shutdown");
 992 }
 993
 994 static enum hrtimer_restart pd_timeout(struct hrtimer *timer)
 995 {
 996         struct usbpd *pd = container_of(timer, struct usbpd, timer);
 997
 998         usbpd_dbg(&pd->dev, "timeout");
 999         queue_work(pd->wq, &pd->sm_work);
1000
1001         return HRTIMER_NORESTART;
1002 }
1003
1004 /* Enters new state and executes actions on entry */
1005 static void usbpd_set_state(struct usbpd *pd, enum usbpd_state next_state)
1006 {
1007         struct pd_phy_params phy_params = {
1008                 .signal_cb              = phy_sig_received,
1009                 .msg_rx_cb              = phy_msg_received,
1010                 .shutdown_cb            = phy_shutdown,
1011                 .frame_filter_val       = FRAME_FILTER_EN_SOP |
1012                                           FRAME_FILTER_EN_HARD_RESET,
1013         };
1014         union power_supply_propval val = {0};
1015         unsigned long flags;
1016         int ret;
1017
1018         if (pd->hard_reset_recvd) /* let usbpd_sm handle it */
1019                 return;
1020
1021         usbpd_dbg(&pd->dev, "%s -> %s\n",
1022                         usbpd_state_strings[pd->current_state],
1023                         usbpd_state_strings[next_state]);
1024
1025         pd->current_state = next_state;
1026
1027         switch (next_state) {
1028         case PE_ERROR_RECOVERY: /* perform hard disconnect/reconnect */
1029                 pd->in_pr_swap = false;
1030                 pd->current_pr = PR_NONE;
1031                 set_power_role(pd, PR_NONE);
1032                 pd->typec_mode = POWER_SUPPLY_TYPEC_NONE;
1033                 kick_sm(pd, 0);
1034                 break;
1035
1036         /* Source states */
1037         case PE_SRC_DISABLED:
1038                 /* are we still connected? */
1039                 if (pd->typec_mode == POWER_SUPPLY_TYPEC_NONE) {
1040                         pd->current_pr = PR_NONE;
1041                         kick_sm(pd, 0);
1042                 }
1043
1044                 break;
1045
1046         case PE_SRC_STARTUP:
1047                 if (pd->current_dr == DR_NONE) {
1048                         pd->current_dr = DR_DFP;
1049                         /*
1050                          * Defer starting USB host mode until PE_SRC_READY or
1051                          * when PE_SRC_SEND_CAPABILITIES fails
1052                          */
1053                 }
1054
1055                 dual_role_instance_changed(pd->dual_role);
1056
1057                 /* Set CC back to DRP toggle for the next disconnect */
1058                 val.intval = POWER_SUPPLY_TYPEC_PR_DUAL;
1059                 power_supply_set_property(pd->usb_psy,
1060                                 POWER_SUPPLY_PROP_TYPEC_POWER_ROLE, &val);
1061
1062                 /* support only PD 2.0 as a source */
1063                 pd->spec_rev = USBPD_REV_20;
1064                 pd_reset_protocol(pd);
1065
1066                 if (!pd->in_pr_swap) {
1067                         if (pd->pd_phy_opened) {
1068                                 pd_phy_close();
1069                                 pd->pd_phy_opened = false;
1070                         }
1071
1072                         phy_params.data_role = pd->current_dr;
1073                         phy_params.power_role = pd->current_pr;
1074
1075                         ret = pd_phy_open(&phy_params);
1076                         if (ret) {
1077                                 WARN_ON_ONCE(1);
1078                                 usbpd_err(&pd->dev, "error opening PD PHY %d\n",
1079                                                 ret);
1080                                 pd->current_state = PE_UNKNOWN;
1081                                 return;
1082                         }
1083
1084                         pd->pd_phy_opened = true;
1085                 }
1086
1087                 if (pd->in_pr_swap) {
1088                         pd->in_pr_swap = false;
1089                         val.intval = 0;
1090                         power_supply_set_property(pd->usb_psy,
1091                                         POWER_SUPPLY_PROP_PR_SWAP, &val);
1092                 }
1093
1094                 /*
1095                  * A sink might remove its terminations (during some Type-C
1096                  * compliance tests or a sink attempting to do Try.SRC)
1097                  * at this point just after we enabled VBUS. Sending PD
1098                  * messages now would delay detecting the detach beyond the
1099                  * required timing. Instead, delay sending out the first
1100                  * source capabilities to allow for the other side to
1101                  * completely settle CC debounce and allow HW to detect detach
1102                  * sooner in the meantime. PD spec allows up to
1103                  * tFirstSourceCap (250ms).
1104                  */
1105                 pd->current_state = PE_SRC_SEND_CAPABILITIES;
1106                 kick_sm(pd, FIRST_SOURCE_CAP_TIME);
1107                 break;
1108
1109         case PE_SRC_SEND_CAPABILITIES:
1110                 kick_sm(pd, 0);
1111                 break;
1112
1113         case PE_SRC_NEGOTIATE_CAPABILITY:
1114                 if (PD_RDO_OBJ_POS(pd->rdo) != 1 ||
1115                         PD_RDO_FIXED_CURR(pd->rdo) >
1116                                 PD_SRC_PDO_FIXED_MAX_CURR(*default_src_caps) ||
1117                         PD_RDO_FIXED_CURR_MINMAX(pd->rdo) >
1118                                 PD_SRC_PDO_FIXED_MAX_CURR(*default_src_caps)) {
1119                         /* send Reject */
1120                         ret = pd_send_msg(pd, MSG_REJECT, NULL, 0, SOP_MSG);
1121                         if (ret) {
1122                                 usbpd_err(&pd->dev, "Error sending Reject\n");
1123                                 usbpd_set_state(pd, PE_SRC_SEND_SOFT_RESET);
1124                                 break;
1125                         }
1126
1127                         usbpd_err(&pd->dev, "Invalid request: %08x\n", pd->rdo);
1128
1129                         if (pd->in_explicit_contract)
1130                                 usbpd_set_state(pd, PE_SRC_READY);
1131                         else
1132                                 /*
1133                                  * bypass PE_SRC_Capability_Response and
1134                                  * PE_SRC_Wait_New_Capabilities in this
1135                                  * implementation for simplicity.
1136                                  */
1137                                 usbpd_set_state(pd, PE_SRC_SEND_CAPABILITIES);
1138                         break;
1139                 }
1140
1141                 /* PE_SRC_TRANSITION_SUPPLY pseudo-state */
1142                 ret = pd_send_msg(pd, MSG_ACCEPT, NULL, 0, SOP_MSG);
1143                 if (ret) {
1144                         usbpd_err(&pd->dev, "Error sending Accept\n");
1145                         usbpd_set_state(pd, PE_SRC_SEND_SOFT_RESET);
1146                         break;
1147                 }
1148
1149                 /* tSrcTransition required after ACCEPT */
1150                 usleep_range(SRC_TRANSITION_TIME * USEC_PER_MSEC,
1151                                 (SRC_TRANSITION_TIME + 5) * USEC_PER_MSEC);
1152
1153                 /*
1154                  * Normally a voltage change should occur within tSrcReady
1155                  * but since we only support VSafe5V there is nothing more to
1156                  * prepare from the power supply so send PS_RDY right away.
1157                  */
1158                 ret = pd_send_msg(pd, MSG_PS_RDY, NULL, 0, SOP_MSG);
1159                 if (ret) {
1160                         usbpd_err(&pd->dev, "Error sending PS_RDY\n");
1161                         usbpd_set_state(pd, PE_SRC_SEND_SOFT_RESET);
1162                         break;
1163                 }
1164
1165                 usbpd_set_state(pd, PE_SRC_READY);
1166                 break;
1167
1168         case PE_SRC_READY:
1169                 pd->in_explicit_contract = true;
1170
1171                 if (pd->vdm_tx)
1172                         kick_sm(pd, 0);
1173                 else if (pd->current_dr == DR_DFP && pd->vdm_state == VDM_NONE)
1174                         usbpd_send_svdm(pd, USBPD_SID,
1175                                         USBPD_SVDM_DISCOVER_IDENTITY,
1176                                         SVDM_CMD_TYPE_INITIATOR, 0, NULL, 0);
1177
1178                 kobject_uevent(&pd->dev.kobj, KOBJ_CHANGE);
1179                 complete(&pd->is_ready);
1180                 dual_role_instance_changed(pd->dual_role);
1181                 break;
1182
1183         case PE_SRC_HARD_RESET:
1184         case PE_SNK_HARD_RESET:
1185                 /* are we still connected? */
1186                 if (pd->typec_mode == POWER_SUPPLY_TYPEC_NONE)
1187                         pd->current_pr = PR_NONE;
1188
1189                 /* hard reset may sleep; handle it in the workqueue */
1190                 kick_sm(pd, 0);
1191                 break;
1192
1193         case PE_SRC_SEND_SOFT_RESET:
1194         case PE_SNK_SEND_SOFT_RESET:
1195                 pd_reset_protocol(pd);
1196
1197                 ret = pd_send_msg(pd, MSG_SOFT_RESET, NULL, 0, SOP_MSG);
1198                 if (ret) {
1199                         usbpd_err(&pd->dev, "Error sending Soft Reset, do Hard Reset\n");
1200                         usbpd_set_state(pd, pd->current_pr == PR_SRC ?
1201                                         PE_SRC_HARD_RESET : PE_SNK_HARD_RESET);
1202                         break;
1203                 }
1204
1205                 /* wait for ACCEPT */
1206                 kick_sm(pd, SENDER_RESPONSE_TIME);
1207                 break;
1208
1209         /* Sink states */
1210         case PE_SNK_STARTUP:
1211                 if (pd->current_dr == DR_NONE || pd->current_dr == DR_UFP) {
1212                         pd->current_dr = DR_UFP;
1213
1214                         if (pd->psy_type == POWER_SUPPLY_TYPE_USB ||
1215                                 pd->psy_type == POWER_SUPPLY_TYPE_USB_CDP ||
1216                                 pd->psy_type == POWER_SUPPLY_TYPE_USB_FLOAT ||
1217                                 usb_compliance_mode)
1218                                 start_usb_peripheral(pd);
1219                 }
1220
1221                 dual_role_instance_changed(pd->dual_role);
1222
1223                 ret = power_supply_get_property(pd->usb_psy,
1224                                 POWER_SUPPLY_PROP_PD_ALLOWED, &val);
1225                 if (ret) {
1226                         usbpd_err(&pd->dev, "Unable to read USB PROP_PD_ALLOWED: %d\n",
1227                                         ret);
1228                         break;
1229                 }
1230
1231                 if (!val.intval || disable_usb_pd)
1232                         break;
1233
1234                 /*
1235                  * support up to PD 3.0 as a sink; if source is 2.0
1236                  * phy_msg_received() will handle the downgrade.
1237                  */
1238                 pd->spec_rev = USBPD_REV_30;
1239                 pd_reset_protocol(pd);
1240
1241                 if (!pd->in_pr_swap) {
1242                         if (pd->pd_phy_opened) {
1243                                 pd_phy_close();
1244                                 pd->pd_phy_opened = false;
1245                         }
1246
1247                         phy_params.data_role = pd->current_dr;
1248                         phy_params.power_role = pd->current_pr;
1249
1250                         ret = pd_phy_open(&phy_params);
1251                         if (ret) {
1252                                 WARN_ON_ONCE(1);
1253                                 usbpd_err(&pd->dev, "error opening PD PHY %d\n",
1254                                                 ret);
1255                                 pd->current_state = PE_UNKNOWN;
1256                                 return;
1257                         }
1258
1259                         pd->pd_phy_opened = true;
1260                 }
1261
1262                 pd->current_voltage = pd->requested_voltage = 5000000;
1263                 val.intval = pd->requested_voltage; /* set max range to 5V */
1264                 power_supply_set_property(pd->usb_psy,
1265                                 POWER_SUPPLY_PROP_PD_VOLTAGE_MAX, &val);
1266
1267                 if (!pd->vbus_present) {
1268                         pd->current_state = PE_SNK_DISCOVERY;
1269                         /* max time for hard reset to turn vbus back on */
1270                         kick_sm(pd, SNK_HARD_RESET_VBUS_ON_TIME);
1271                         break;
1272                 }
1273
1274                 pd->current_state = PE_SNK_WAIT_FOR_CAPABILITIES;
1275                 /* fall-through */
1276
1277         case PE_SNK_WAIT_FOR_CAPABILITIES:
1278                 spin_lock_irqsave(&pd->rx_lock, flags);
1279                 if (list_empty(&pd->rx_q))
1280                         kick_sm(pd, SINK_WAIT_CAP_TIME);
1281                 spin_unlock_irqrestore(&pd->rx_lock, flags);
1282                 break;
1283
1284         case PE_SNK_EVALUATE_CAPABILITY:
1285                 pd->pd_connected = true; /* we know peer is PD capable */
1286                 pd->hard_reset_count = 0;
1287
1288                 /* evaluate PDOs and select one */
1289                 ret = pd_eval_src_caps(pd);
1290                 if (ret < 0) {
1291                         usbpd_err(&pd->dev, "Invalid src_caps received. Skipping request\n");
1292                         break;
1293                 }
1294                 pd->current_state = PE_SNK_SELECT_CAPABILITY;
1295                 /* fall-through */
1296
1297         case PE_SNK_SELECT_CAPABILITY:
1298                 ret = pd_send_msg(pd, MSG_REQUEST, &pd->rdo, 1, SOP_MSG);
1299                 if (ret) {
1300                         usbpd_err(&pd->dev, "Error sending Request\n");
1301                         usbpd_set_state(pd, PE_SNK_SEND_SOFT_RESET);
1302                         break;
1303                 }
1304
1305                 /* wait for ACCEPT */
1306                 kick_sm(pd, SENDER_RESPONSE_TIME);
1307                 break;
1308
1309         case PE_SNK_TRANSITION_SINK:
1310                 /* wait for PS_RDY */
1311                 kick_sm(pd, PS_TRANSITION_TIME);
1312                 break;
1313
1314         case PE_SNK_READY:
1315                 pd->in_explicit_contract = true;
1316
1317                 if (pd->vdm_tx)
1318                         kick_sm(pd, 0);
1319                 else if (pd->current_dr == DR_DFP && pd->vdm_state == VDM_NONE)
1320                         usbpd_send_svdm(pd, USBPD_SID,
1321                                         USBPD_SVDM_DISCOVER_IDENTITY,
1322                                         SVDM_CMD_TYPE_INITIATOR, 0, NULL, 0);
1323
1324                 kobject_uevent(&pd->dev.kobj, KOBJ_CHANGE);
1325                 complete(&pd->is_ready);
1326                 dual_role_instance_changed(pd->dual_role);
1327                 break;
1328
1329         case PE_SNK_TRANSITION_TO_DEFAULT:
1330                 if (pd->current_dr != DR_UFP) {
1331                         stop_usb_host(pd);
1332                         start_usb_peripheral(pd);
1333                         pd->current_dr = DR_UFP;
1334                         pd_phy_update_roles(pd->current_dr, pd->current_pr);
1335                 }
1336                 if (pd->vconn_enabled) {
1337                         regulator_disable(pd->vconn);
1338                         pd->vconn_enabled = false;
1339                 }
1340
1341                 /* max time for hard reset to turn vbus off */
1342                 kick_sm(pd, SNK_HARD_RESET_VBUS_OFF_TIME);
1343                 break;
1344
1345         case PE_PRS_SNK_SRC_TRANSITION_TO_OFF:
1346                 val.intval = pd->requested_current = 0; /* suspend charging */
1347                 power_supply_set_property(pd->usb_psy,
1348                                 POWER_SUPPLY_PROP_PD_CURRENT_MAX, &val);
1349
1350                 pd->in_explicit_contract = false;
1351
1352                 /*
1353                  * need to update PR bit in message header so that
1354                  * proper GoodCRC is sent when receiving next PS_RDY
1355                  */
1356                 pd_phy_update_roles(pd->current_dr, PR_SRC);
1357
1358                 /* wait for PS_RDY */
1359                 kick_sm(pd, PS_SOURCE_OFF);
1360                 break;
1361
1362         default:
1363                 usbpd_dbg(&pd->dev, "No action for state %s\n",
1364                                 usbpd_state_strings[pd->current_state]);
1365                 break;
1366         }
1367 }
1368
1369 int usbpd_register_svid(struct usbpd *pd, struct usbpd_svid_handler *hdlr)
1370 {
1371         if (find_svid_handler(pd, hdlr->svid)) {
1372                 usbpd_err(&pd->dev, "SVID 0x%04x already registered\n",
1373                                 hdlr->svid);
1374                 return -EINVAL;
1375         }
1376
1377         /* require connect/disconnect callbacks be implemented */
1378         if (!hdlr->connect || !hdlr->disconnect) {
1379                 usbpd_err(&pd->dev, "SVID 0x%04x connect/disconnect must be non-NULL\n",
1380                                 hdlr->svid);
1381                 return -EINVAL;
1382         }
1383
1384         usbpd_dbg(&pd->dev, "registered handler for SVID 0x%04x\n", hdlr->svid);
1385
1386         list_add_tail(&hdlr->entry, &pd->svid_handlers);
1387
1388         /* already connected with this SVID discovered? */
1389         if (pd->vdm_state >= DISCOVERED_SVIDS) {
1390                 int i;
1391
1392                 for (i = 0; i < pd->num_svids; i++) {
1393                         if (pd->discovered_svids[i] == hdlr->svid) {
1394                                 hdlr->connect(hdlr);
1395                                 hdlr->discovered = true;
1396                                 break;
1397                         }
1398                 }
1399         }
1400
1401         return 0;
1402 }
1403 EXPORT_SYMBOL(usbpd_register_svid);
1404
1405 void usbpd_unregister_svid(struct usbpd *pd, struct usbpd_svid_handler *hdlr)
1406 {
1407         list_del_init(&hdlr->entry);
1408 }
1409 EXPORT_SYMBOL(usbpd_unregister_svid);
1410
1411 int usbpd_send_vdm(struct usbpd *pd, u32 vdm_hdr, const u32 *vdos, int num_vdos)
1412 {
1413         struct vdm_tx *vdm_tx;
1414
1415         if (!pd->in_explicit_contract || pd->vdm_tx)
1416                 return -EBUSY;
1417
1418         vdm_tx = kzalloc(sizeof(*vdm_tx), GFP_KERNEL);
1419         if (!vdm_tx)
1420                 return -ENOMEM;
1421
1422         vdm_tx->data[0] = vdm_hdr;
1423         if (vdos && num_vdos)
1424                 memcpy(&vdm_tx->data[1], vdos, num_vdos * sizeof(u32));
1425         vdm_tx->size = num_vdos + 1; /* include the header */
1426
1427         /* VDM will get sent in PE_SRC/SNK_READY state handling */
1428         pd->vdm_tx = vdm_tx;
1429
1430         /* slight delay before queuing to prioritize handling of incoming VDM */
1431         kick_sm(pd, 2);
1432
1433         return 0;
1434 }
1435 EXPORT_SYMBOL(usbpd_send_vdm);
1436
1437 int usbpd_send_svdm(struct usbpd *pd, u16 svid, u8 cmd,
1438                 enum usbpd_svdm_cmd_type cmd_type, int obj_pos,
1439                 const u32 *vdos, int num_vdos)
1440 {
1441         u32 svdm_hdr = SVDM_HDR(svid, 0, obj_pos, cmd_type, cmd);
1442
1443         usbpd_dbg(&pd->dev, "VDM tx: svid:%x cmd:%x cmd_type:%x svdm_hdr:%x\n",
1444                         svid, cmd, cmd_type, svdm_hdr);
1445
1446         return usbpd_send_vdm(pd, svdm_hdr, vdos, num_vdos);
1447 }
1448 EXPORT_SYMBOL(usbpd_send_svdm);
1449
1450 static void handle_vdm_rx(struct usbpd *pd, struct rx_msg *rx_msg)
1451 {
1452         u32 vdm_hdr =
1453         rx_msg->data_len >= sizeof(u32) ? ((u32 *)rx_msg->payload)[0] : 0;
1454
1455         u32 *vdos = (u32 *)&rx_msg->payload[sizeof(u32)];
1456         u16 svid = VDM_HDR_SVID(vdm_hdr);
1457         u16 *psvid;
1458         u8 i, num_vdos = PD_MSG_HDR_COUNT(rx_msg->hdr) - 1;
1459         u8 cmd = SVDM_HDR_CMD(vdm_hdr);
1460         u8 cmd_type = SVDM_HDR_CMD_TYPE(vdm_hdr);
1461         bool has_dp = false;
1462         struct usbpd_svid_handler *handler;
1463
1464         usbpd_dbg(&pd->dev, "VDM rx: svid:%x cmd:%x cmd_type:%x vdm_hdr:%x\n",
1465                         svid, cmd, cmd_type, vdm_hdr);
1466
1467         /* if it's a supported SVID, pass the message to the handler */
1468         handler = find_svid_handler(pd, svid);
1469
1470         /* Unstructured VDM */
1471         if (!VDM_IS_SVDM(vdm_hdr)) {
1472                 if (handler && handler->vdm_received)
1473                         handler->vdm_received(handler, vdm_hdr, vdos, num_vdos);
1474                 return;
1475         }
1476
1477         /* if this interrupts a previous exchange, abort queued response */
1478         if (cmd_type == SVDM_CMD_TYPE_INITIATOR && pd->vdm_tx) {
1479                 usbpd_dbg(&pd->dev, "Discarding previously queued SVDM tx (SVID:0x%04x)\n",
1480                                 VDM_HDR_SVID(pd->vdm_tx->data[0]));
1481
1482                 kfree(pd->vdm_tx);
1483                 pd->vdm_tx = NULL;
1484         }
1485
1486         if (handler && handler->svdm_received) {
1487                 handler->svdm_received(handler, cmd, cmd_type, vdos, num_vdos);
1488                 return;
1489         }
1490
1491         /* Standard Discovery or unhandled messages go here */
1492         switch (cmd_type) {
1493         case SVDM_CMD_TYPE_INITIATOR:
1494                 if (svid == USBPD_SID && cmd == USBPD_SVDM_DISCOVER_IDENTITY) {
1495                         u32 tx_vdos[3] = {
1496                                 ID_HDR_USB_HOST | ID_HDR_USB_DEVICE |
1497                                         ID_HDR_PRODUCT_PER_MASK | ID_HDR_VID,
1498                                 0x0, /* TBD: Cert Stat VDO */
1499                                 (PROD_VDO_PID << 16),
1500                                 /* TBD: Get these from gadget */
1501                         };
1502
1503                         usbpd_send_svdm(pd, USBPD_SID, cmd,
1504                                         SVDM_CMD_TYPE_RESP_ACK, 0, tx_vdos, 3);
1505                 } else if (cmd != USBPD_SVDM_ATTENTION) {
1506                         usbpd_send_svdm(pd, svid, cmd, SVDM_CMD_TYPE_RESP_NAK,
1507                                         SVDM_HDR_OBJ_POS(vdm_hdr), NULL, 0);
1508                 }
1509                 break;
1510
1511         case SVDM_CMD_TYPE_RESP_ACK:
1512                 if (svid != USBPD_SID) {
1513                         usbpd_err(&pd->dev, "unhandled ACK for SVID:0x%x\n",
1514                                         svid);
1515                         break;
1516                 }
1517
1518                 switch (cmd) {
1519                 case USBPD_SVDM_DISCOVER_IDENTITY:
1520                         kfree(pd->vdm_tx_retry);
1521                         pd->vdm_tx_retry = NULL;
1522
1523                         pd->vdm_state = DISCOVERED_ID;
1524                         usbpd_send_svdm(pd, USBPD_SID,
1525                                         USBPD_SVDM_DISCOVER_SVIDS,
1526                                         SVDM_CMD_TYPE_INITIATOR, 0, NULL, 0);
1527                         break;
1528
1529                 case USBPD_SVDM_DISCOVER_SVIDS:
1530                         pd->vdm_state = DISCOVERED_SVIDS;
1531
1532                         kfree(pd->vdm_tx_retry);
1533                         pd->vdm_tx_retry = NULL;
1534
1535                         if (!pd->discovered_svids) {
1536                                 pd->num_svids = 2 * num_vdos;
1537                                 pd->discovered_svids = kcalloc(pd->num_svids,
1538                                                                 sizeof(u16),
1539                                                                 GFP_KERNEL);
1540                                 if (!pd->discovered_svids) {
1541                                         usbpd_err(&pd->dev, "unable to allocate SVIDs\n");
1542                                         break;
1543                                 }
1544
1545                                 psvid = pd->discovered_svids;
1546                         } else { /* handle > 12 SVIDs */
1547                                 void *ptr;
1548                                 size_t oldsize = pd->num_svids * sizeof(u16);
1549                                 size_t newsize = oldsize +
1550                                                 (2 * num_vdos * sizeof(u16));
1551
1552                                 ptr = krealloc(pd->discovered_svids, newsize,
1553                                                 GFP_KERNEL);
1554                                 if (!ptr) {
1555                                         usbpd_err(&pd->dev, "unable to realloc SVIDs\n");
1556                                         break;
1557                                 }
1558
1559                                 pd->discovered_svids = ptr;
1560                                 psvid = pd->discovered_svids + pd->num_svids;
1561                                 memset(psvid, 0, (2 * num_vdos));
1562                                 pd->num_svids += 2 * num_vdos;
1563                         }
1564
1565                         /* convert 32-bit VDOs to list of 16-bit SVIDs */
1566                         for (i = 0; i < num_vdos * 2; i++) {
1567                                 /*
1568                                  * Within each 32-bit VDO,
1569                                  *    SVID[i]: upper 16-bits
1570                                  *    SVID[i+1]: lower 16-bits
1571                                  * where i is even.
1572                                  */
1573                                 if (!(i & 1))
1574                                         svid = vdos[i >> 1] >> 16;
1575                                 else
1576                                         svid = vdos[i >> 1] & 0xFFFF;
1577
1578                                 /*
1579                                  * There are some devices that incorrectly
1580                                  * swap the order of SVIDs within a VDO. So in
1581                                  * case of an odd-number of SVIDs it could end
1582                                  * up with SVID[i] as 0 while SVID[i+1] is
1583                                  * non-zero. Just skip over the zero ones.
1584                                  */
1585                                 if (svid) {
1586                                         usbpd_dbg(&pd->dev, "Discovered SVID: 0x%04x\n",
1587                                                         svid);
1588                                         *psvid++ = svid;
1589                                 }
1590                         }
1591
1592                         /* if more than 12 SVIDs, resend the request */
1593                         if (num_vdos == 6 && vdos[5] != 0) {
1594                                 usbpd_send_svdm(pd, USBPD_SID,
1595                                                 USBPD_SVDM_DISCOVER_SVIDS,
1596                                                 SVDM_CMD_TYPE_INITIATOR, 0,
1597                                                 NULL, 0);
1598                                 break;
1599                         }
1600
1601                         /* now that all SVIDs are discovered, notify handlers */
1602                         for (i = 0; i < pd->num_svids; i++) {
1603                                 svid = pd->discovered_svids[i];
1604                                 if (svid) {
1605                                         handler = find_svid_handler(pd, svid);
1606                                         if (handler) {
1607                                                 handler->connect(handler);
1608                                                 handler->discovered = true;
1609                                         }
1610                                 }
1611
1612                                 if (svid == 0xFF01)
1613                                         has_dp = true;
1614                         }
1615
1616                         /*
1617                          * Finally start USB host now that we have determined
1618                          * if DisplayPort mode is present or not and limit USB
1619                          * to HS-only mode if so.
1620                          */
1621                         start_usb_host(pd, !has_dp);
1622
1623                         break;
1624
1625                 default:
1626                         usbpd_dbg(&pd->dev, "unhandled ACK for command:0x%x\n",
1627                                         cmd);
1628                         break;
1629                 }
1630                 break;
1631
1632         case SVDM_CMD_TYPE_RESP_NAK:
1633                 usbpd_info(&pd->dev, "VDM NAK received for SVID:0x%04x command:0x%x\n",
1634                                 svid, cmd);
1635
1636                 switch (cmd) {
1637                 case USBPD_SVDM_DISCOVER_IDENTITY:
1638                 case USBPD_SVDM_DISCOVER_SVIDS:
1639                         start_usb_host(pd, true);
1640                         break;
1641                 default:
1642                         break;
1643                 }
1644
1645                 break;
1646
1647         case SVDM_CMD_TYPE_RESP_BUSY:
1648                 switch (cmd) {
1649                 case USBPD_SVDM_DISCOVER_IDENTITY:
1650                 case USBPD_SVDM_DISCOVER_SVIDS:
1651                         if (!pd->vdm_tx_retry) {
1652                                 usbpd_err(&pd->dev, "Discover command %d VDM was unexpectedly freed\n",
1653                                                 cmd);
1654                                 break;
1655                         }
1656
1657                         /* wait tVDMBusy, then retry */
1658                         pd->vdm_tx = pd->vdm_tx_retry;
1659                         pd->vdm_tx_retry = NULL;
1660                         kick_sm(pd, VDM_BUSY_TIME);
1661                         break;
1662                 default:
1663                         break;
1664                 }
1665                 break;
1666         }
1667 }
1668
1669 static void handle_vdm_tx(struct usbpd *pd)
1670 {
1671         int ret;
1672         unsigned long flags;
1673
1674         /* only send one VDM at a time */
1675         if (pd->vdm_tx) {
1676                 u32 vdm_hdr = pd->vdm_tx->data[0];
1677
1678                 /* bail out and try again later if a message just arrived */
1679                 spin_lock_irqsave(&pd->rx_lock, flags);
1680                 if (!list_empty(&pd->rx_q)) {
1681                         spin_unlock_irqrestore(&pd->rx_lock, flags);
1682                         return;
1683                 }
1684                 spin_unlock_irqrestore(&pd->rx_lock, flags);
1685
1686                 ret = pd_send_msg(pd, MSG_VDM, pd->vdm_tx->data,
1687                                 pd->vdm_tx->size, SOP_MSG);
1688                 if (ret) {
1689                         usbpd_err(&pd->dev, "Error (%d) sending VDM command %d\n",
1690                                         ret, SVDM_HDR_CMD(pd->vdm_tx->data[0]));
1691
1692                         /* retry when hitting PE_SRC/SNK_Ready again */
1693                         if (ret != -EBUSY)
1694                                 usbpd_set_state(pd, pd->current_pr == PR_SRC ?
1695                                         PE_SRC_SEND_SOFT_RESET :
1696                                         PE_SNK_SEND_SOFT_RESET);
1697
1698                         return;
1699                 }
1700
1701                 /*
1702                  * special case: keep initiated Discover ID/SVIDs
1703                  * around in case we need to re-try when receiving BUSY
1704                  */
1705                 if (VDM_IS_SVDM(vdm_hdr) &&
1706                         SVDM_HDR_CMD_TYPE(vdm_hdr) == SVDM_CMD_TYPE_INITIATOR &&
1707                         SVDM_HDR_CMD(vdm_hdr) <= USBPD_SVDM_DISCOVER_SVIDS) {
1708                         if (pd->vdm_tx_retry) {
1709                                 usbpd_dbg(&pd->dev, "Previous Discover VDM command %d not ACKed/NAKed\n",
1710                                         SVDM_HDR_CMD(
1711                                                 pd->vdm_tx_retry->data[0]));
1712                                 kfree(pd->vdm_tx_retry);
1713                         }
1714                         pd->vdm_tx_retry = pd->vdm_tx;
1715                 } else {
1716                         kfree(pd->vdm_tx);
1717                 }
1718
1719                 pd->vdm_tx = NULL;
1720         }
1721 }
1722
1723 static void reset_vdm_state(struct usbpd *pd)
1724 {
1725         struct usbpd_svid_handler *handler;
1726
1727         list_for_each_entry(handler, &pd->svid_handlers, entry) {
1728                 if (handler->discovered) {
1729                         handler->disconnect(handler);
1730                         handler->discovered = false;
1731                 }
1732         }
1733
1734         pd->vdm_state = VDM_NONE;
1735         kfree(pd->vdm_tx_retry);
1736         pd->vdm_tx_retry = NULL;
1737         kfree(pd->discovered_svids);
1738         pd->discovered_svids = NULL;
1739         pd->num_svids = 0;
1740         kfree(pd->vdm_tx);
1741         pd->vdm_tx = NULL;
1742 }
1743
1744 static void dr_swap(struct usbpd *pd)
1745 {
1746         reset_vdm_state(pd);
1747
1748         if (pd->current_dr == DR_DFP) {
1749                 stop_usb_host(pd);
1750                 start_usb_peripheral(pd);
1751                 pd->current_dr = DR_UFP;
1752         } else if (pd->current_dr == DR_UFP) {
1753                 stop_usb_peripheral(pd);
1754                 pd->current_dr = DR_DFP;
1755
1756                 /* don't start USB host until after SVDM discovery */
1757                 usbpd_send_svdm(pd, USBPD_SID, USBPD_SVDM_DISCOVER_IDENTITY,
1758                                 SVDM_CMD_TYPE_INITIATOR, 0, NULL, 0);
1759         }
1760
1761         pd_phy_update_roles(pd->current_dr, pd->current_pr);
1762         dual_role_instance_changed(pd->dual_role);
1763 }
1764
1765
1766 static void vconn_swap(struct usbpd *pd)
1767 {
1768         int ret;
1769
1770         if (pd->vconn_enabled) {
1771                 pd->current_state = PE_VCS_WAIT_FOR_VCONN;
1772                 kick_sm(pd, VCONN_ON_TIME);
1773         } else {
1774                 ret = regulator_enable(pd->vconn);
1775                 if (ret) {
1776                         usbpd_err(&pd->dev, "Unable to enable vconn\n");
1777                         return;
1778                 }
1779
1780                 pd->vconn_enabled = true;
1781
1782                 /*
1783                  * Small delay to ensure Vconn has ramped up. This is well
1784                  * below tVCONNSourceOn (100ms) so we still send PS_RDY within
1785                  * the allowed time.
1786                  */
1787                 usleep_range(5000, 10000);
1788
1789                 ret = pd_send_msg(pd, MSG_PS_RDY, NULL, 0, SOP_MSG);
1790                 if (ret) {
1791                         usbpd_err(&pd->dev, "Error sending PS_RDY\n");
1792                         usbpd_set_state(pd, pd->current_pr == PR_SRC ?
1793                                         PE_SRC_SEND_SOFT_RESET :
1794                                         PE_SNK_SEND_SOFT_RESET);
1795                         return;
1796                 }
1797         }
1798 }
1799
1800 static int enable_vbus(struct usbpd *pd)
1801 {
1802         union power_supply_propval val = {0};
1803         int count = 100;
1804         int ret;
1805
1806         if (!check_vsafe0v)
1807                 goto enable_reg;
1808
1809         /*
1810          * Check to make sure there's no lingering charge on
1811          * VBUS before enabling it as a source. If so poll here
1812          * until it goes below VSafe0V (0.8V) before proceeding.
1813          */
1814         while (count--) {
1815                 ret = power_supply_get_property(pd->usb_psy,
1816                                 POWER_SUPPLY_PROP_VOLTAGE_NOW, &val);
1817                 if (ret || val.intval <= 800000)
1818                         break;
1819                 usleep_range(20000, 30000);
1820         }
1821
1822         if (count < 99)
1823                 msleep(100);    /* need to wait an additional tCCDebounce */
1824
1825 enable_reg:
1826         ret = regulator_enable(pd->vbus);
1827         if (ret)
1828                 usbpd_err(&pd->dev, "Unable to enable vbus (%d)\n", ret);
1829         else
1830                 pd->vbus_enabled = true;
1831
1832         count = 10;
1833         /*
1834          * Check to make sure VBUS voltage reaches above Vsafe5Vmin (4.75v)
1835          * before proceeding.
1836          */
1837         while (count--) {
1838                 ret = power_supply_get_property(pd->usb_psy,
1839                                 POWER_SUPPLY_PROP_VOLTAGE_NOW, &val);
1840                 if (ret || val.intval >= 4750000) /*vsafe5Vmin*/
1841                         break;
1842                 usleep_range(10000, 12000); /* Delay between two reads */
1843         }
1844
1845         if (ret)
1846                 msleep(100); /* Delay to wait for VBUS ramp up if read fails */
1847
1848         return ret;
1849 }
1850
1851 static inline void rx_msg_cleanup(struct usbpd *pd)
1852 {
1853         struct rx_msg *msg, *tmp;
1854         unsigned long flags;
1855
1856         spin_lock_irqsave(&pd->rx_lock, flags);
1857         list_for_each_entry_safe(msg, tmp, &pd->rx_q, entry) {
1858                 list_del(&msg->entry);
1859                 kfree(msg);
1860         }
1861         spin_unlock_irqrestore(&pd->rx_lock, flags);
1862 }
1863
1864 /* For PD 3.0, check SinkTxOk before allowing initiating AMS */
1865 static inline bool is_sink_tx_ok(struct usbpd *pd)
1866 {
1867         if (pd->spec_rev == USBPD_REV_30)
1868                 return pd->typec_mode == POWER_SUPPLY_TYPEC_SOURCE_HIGH;
1869
1870         return true;
1871 }
1872
1873 /* Handles current state and determines transitions */
1874 static void usbpd_sm(struct work_struct *w)
1875 {
1876         struct usbpd *pd = container_of(w, struct usbpd, sm_work);
1877         union power_supply_propval val = {0};
1878         int ret;
1879         struct rx_msg *rx_msg = NULL;
1880         unsigned long flags;
1881
1882         usbpd_dbg(&pd->dev, "handle state %s\n",
1883                         usbpd_state_strings[pd->current_state]);
1884
1885         hrtimer_cancel(&pd->timer);
1886         pd->sm_queued = false;
1887
1888         spin_lock_irqsave(&pd->rx_lock, flags);
1889         if (!list_empty(&pd->rx_q)) {
1890                 rx_msg = list_first_entry(&pd->rx_q, struct rx_msg, entry);
1891                 list_del(&rx_msg->entry);
1892         }
1893         spin_unlock_irqrestore(&pd->rx_lock, flags);
1894
1895         /* Disconnect? */
1896         if (pd->current_pr == PR_NONE) {
1897                 if (pd->current_state == PE_UNKNOWN)
1898                         goto sm_done;
1899
1900                 if (pd->vconn_enabled) {
1901                         regulator_disable(pd->vconn);
1902                         pd->vconn_enabled = false;
1903                 }
1904
1905                 usbpd_info(&pd->dev, "USB Type-C disconnect\n");
1906
1907                 if (pd->pd_phy_opened) {
1908                         pd_phy_close();
1909                         pd->pd_phy_opened = false;
1910                 }
1911
1912                 pd->in_pr_swap = false;
1913                 pd->pd_connected = false;
1914                 pd->in_explicit_contract = false;
1915                 pd->hard_reset_recvd = false;
1916                 pd->caps_count = 0;
1917                 pd->hard_reset_count = 0;
1918                 pd->requested_voltage = 0;
1919                 pd->requested_current = 0;
1920                 pd->selected_pdo = pd->requested_pdo = 0;
1921                 memset(&pd->received_pdos, 0, sizeof(pd->received_pdos));
1922                 rx_msg_cleanup(pd);
1923
1924                 power_supply_set_property(pd->usb_psy,
1925                                 POWER_SUPPLY_PROP_PD_IN_HARD_RESET, &val);
1926
1927                 power_supply_set_property(pd->usb_psy,
1928                                 POWER_SUPPLY_PROP_PD_USB_SUSPEND_SUPPORTED,
1929                                 &val);
1930
1931                 power_supply_set_property(pd->usb_psy,
1932                                 POWER_SUPPLY_PROP_PD_ACTIVE, &val);
1933
1934                 if (pd->vbus_enabled) {
1935                         regulator_disable(pd->vbus);
1936                         pd->vbus_enabled = false;
1937                 }
1938
1939                 if (pd->current_dr == DR_UFP)
1940                         stop_usb_peripheral(pd);
1941                 else if (pd->current_dr == DR_DFP)
1942                         stop_usb_host(pd);
1943
1944                 pd->current_dr = DR_NONE;
1945
1946                 reset_vdm_state(pd);
1947
1948                 if (pd->current_state == PE_ERROR_RECOVERY)
1949                         /* forced disconnect, wait before resetting to DRP */
1950                         usleep_range(ERROR_RECOVERY_TIME * USEC_PER_MSEC,
1951                                 (ERROR_RECOVERY_TIME + 5) * USEC_PER_MSEC);
1952
1953                 val.intval = 0;
1954                 power_supply_set_property(pd->usb_psy,
1955                                 POWER_SUPPLY_PROP_PR_SWAP, &val);
1956
1957                 /* set due to dual_role class "mode" change */
1958                 if (pd->forced_pr != POWER_SUPPLY_TYPEC_PR_NONE)
1959                         val.intval = pd->forced_pr;
1960                 else if (rev3_sink_only)
1961                         val.intval = POWER_SUPPLY_TYPEC_PR_SINK;
1962                 else
1963                         /* Set CC back to DRP toggle */
1964                         val.intval = POWER_SUPPLY_TYPEC_PR_DUAL;
1965
1966                 power_supply_set_property(pd->usb_psy,
1967                                 POWER_SUPPLY_PROP_TYPEC_POWER_ROLE, &val);
1968                 pd->forced_pr = POWER_SUPPLY_TYPEC_PR_NONE;
1969
1970                 pd->current_state = PE_UNKNOWN;
1971
1972                 kobject_uevent(&pd->dev.kobj, KOBJ_CHANGE);
1973                 dual_role_instance_changed(pd->dual_role);
1974
1975                 goto sm_done;
1976         }
1977
1978         /* Hard reset? */
1979         if (pd->hard_reset_recvd) {
1980                 pd->hard_reset_recvd = false;
1981
1982                 if (pd->requested_current) {
1983                         val.intval = pd->requested_current = 0;
1984                         power_supply_set_property(pd->usb_psy,
1985                                         POWER_SUPPLY_PROP_PD_CURRENT_MAX, &val);
1986                 }
1987
1988                 pd->requested_voltage = 5000000;
1989                 val.intval = pd->requested_voltage;
1990                 power_supply_set_property(pd->usb_psy,
1991                                 POWER_SUPPLY_PROP_PD_VOLTAGE_MIN, &val);
1992
1993                 pd->in_pr_swap = false;
1994                 val.intval = 0;
1995                 power_supply_set_property(pd->usb_psy,
1996                                 POWER_SUPPLY_PROP_PR_SWAP, &val);
1997
1998                 pd->in_explicit_contract = false;
1999                 pd->selected_pdo = pd->requested_pdo = 0;
2000                 pd->rdo = 0;
2001                 rx_msg_cleanup(pd);
2002                 reset_vdm_state(pd);
2003                 kobject_uevent(&pd->dev.kobj, KOBJ_CHANGE);
2004
2005                 if (pd->current_pr == PR_SINK) {
2006                         usbpd_set_state(pd, PE_SNK_TRANSITION_TO_DEFAULT);
2007                 } else {
2008                         s64 delta = ktime_ms_delta(ktime_get(),
2009                                         pd->hard_reset_recvd_time);
2010                         pd->current_state = PE_SRC_TRANSITION_TO_DEFAULT;
2011                         if (delta >= PS_HARD_RESET_TIME)
2012                                 kick_sm(pd, 0);
2013                         else
2014                                 kick_sm(pd, PS_HARD_RESET_TIME - (int)delta);
2015                 }
2016
2017                 goto sm_done;
2018         }
2019
2020         /* Soft reset? */
2021         if (IS_CTRL(rx_msg, MSG_SOFT_RESET)) {
2022                 usbpd_dbg(&pd->dev, "Handle soft reset\n");
2023
2024                 if (pd->current_pr == PR_SRC)
2025                         pd->current_state = PE_SRC_SOFT_RESET;
2026                 else if (pd->current_pr == PR_SINK)
2027                         pd->current_state = PE_SNK_SOFT_RESET;
2028         }
2029
2030         switch (pd->current_state) {
2031         case PE_UNKNOWN:
2032                 val.intval = 0;
2033                 power_supply_set_property(pd->usb_psy,
2034                                 POWER_SUPPLY_PROP_PD_IN_HARD_RESET, &val);
2035
2036                 if (pd->current_pr == PR_SINK) {
2037                         usbpd_set_state(pd, PE_SNK_STARTUP);
2038                 } else if (pd->current_pr == PR_SRC) {
2039                         if (!pd->vconn_enabled &&
2040                                         pd->typec_mode ==
2041                                         POWER_SUPPLY_TYPEC_SINK_POWERED_CABLE) {
2042                                 ret = regulator_enable(pd->vconn);
2043                                 if (ret)
2044                                         usbpd_err(&pd->dev, "Unable to enable vconn\n");
2045                                 else
2046                                         pd->vconn_enabled = true;
2047                         }
2048                         enable_vbus(pd);
2049
2050                         usbpd_set_state(pd, PE_SRC_STARTUP);
2051                 }
2052                 break;
2053
2054         case PE_SRC_STARTUP:
2055                 usbpd_set_state(pd, PE_SRC_STARTUP);
2056                 break;
2057
2058         case PE_SRC_SEND_CAPABILITIES:
2059                 ret = pd_send_msg(pd, MSG_SOURCE_CAPABILITIES, default_src_caps,
2060                                 ARRAY_SIZE(default_src_caps), SOP_MSG);
2061                 if (ret) {
2062                         pd->caps_count++;
2063
2064                         if (pd->caps_count == 10 && pd->current_dr == DR_DFP) {
2065                                 /* Likely not PD-capable, start host now */
2066                                 start_usb_host(pd, true);
2067                         } else if (pd->caps_count >= PD_CAPS_COUNT) {
2068                                 usbpd_dbg(&pd->dev, "Src CapsCounter exceeded, disabling PD\n");
2069                                 usbpd_set_state(pd, PE_SRC_DISABLED);
2070
2071                                 val.intval = 0;
2072                                 power_supply_set_property(pd->usb_psy,
2073                                                 POWER_SUPPLY_PROP_PD_ACTIVE,
2074                                                 &val);
2075                                 break;
2076                         }
2077
2078                         kick_sm(pd, SRC_CAP_TIME);
2079                         break;
2080                 }
2081
2082                 /* transmit was successful if GoodCRC was received */
2083                 pd->caps_count = 0;
2084                 pd->hard_reset_count = 0;
2085                 pd->pd_connected = true; /* we know peer is PD capable */
2086
2087                 /* wait for REQUEST */
2088                 pd->current_state = PE_SRC_SEND_CAPABILITIES_WAIT;
2089                 kick_sm(pd, SENDER_RESPONSE_TIME);
2090
2091                 val.intval = 1;
2092                 power_supply_set_property(pd->usb_psy,
2093                                 POWER_SUPPLY_PROP_PD_ACTIVE, &val);
2094                 break;
2095
2096         case PE_SRC_SEND_CAPABILITIES_WAIT:
2097                 if (IS_DATA(rx_msg, MSG_REQUEST)) {
2098                         pd->rdo = *(u32 *)rx_msg->payload;
2099                         usbpd_set_state(pd, PE_SRC_NEGOTIATE_CAPABILITY);
2100                 } else if (rx_msg) {
2101                         usbpd_err(&pd->dev, "Unexpected message received\n");
2102                         usbpd_set_state(pd, PE_SRC_SEND_SOFT_RESET);
2103                 } else {
2104                         usbpd_set_state(pd, PE_SRC_HARD_RESET);
2105                 }
2106                 break;
2107
2108         case PE_SRC_READY:
2109                 if (IS_CTRL(rx_msg, MSG_GET_SOURCE_CAP)) {
2110                         pd->current_state = PE_SRC_SEND_CAPABILITIES;
2111                         kick_sm(pd, 0);
2112                 } else if (IS_CTRL(rx_msg, MSG_GET_SINK_CAP)) {
2113                         ret = pd_send_msg(pd, MSG_SINK_CAPABILITIES,
2114                                         pd->sink_caps, pd->num_sink_caps,
2115                                         SOP_MSG);
2116                         if (ret) {
2117                                 usbpd_err(&pd->dev, "Error sending Sink Caps\n");
2118                                 usbpd_set_state(pd, PE_SRC_SEND_SOFT_RESET);
2119                         }
2120                 } else if (IS_DATA(rx_msg, MSG_REQUEST)) {
2121                         pd->rdo = *(u32 *)rx_msg->payload;
2122                         usbpd_set_state(pd, PE_SRC_NEGOTIATE_CAPABILITY);
2123                 } else if (IS_CTRL(rx_msg, MSG_DR_SWAP)) {
2124                         if (pd->vdm_state == MODE_ENTERED) {
2125                                 usbpd_set_state(pd, PE_SRC_HARD_RESET);
2126                                 break;
2127                         }
2128
2129                         ret = pd_send_msg(pd, MSG_ACCEPT, NULL, 0, SOP_MSG);
2130                         if (ret) {
2131                                 usbpd_err(&pd->dev, "Error sending Accept\n");
2132                                 usbpd_set_state(pd, PE_SRC_SEND_SOFT_RESET);
2133                                 break;
2134                         }
2135
2136                         dr_swap(pd);
2137                 } else if (IS_CTRL(rx_msg, MSG_PR_SWAP)) {
2138                         /* lock in current mode */
2139                         set_power_role(pd, pd->current_pr);
2140
2141                         /* we'll happily accept Src->Sink requests anytime */
2142                         ret = pd_send_msg(pd, MSG_ACCEPT, NULL, 0, SOP_MSG);
2143                         if (ret) {
2144                                 usbpd_err(&pd->dev, "Error sending Accept\n");
2145                                 usbpd_set_state(pd, PE_SRC_SEND_SOFT_RESET);
2146                                 break;
2147                         }
2148
2149                         pd->current_state = PE_PRS_SRC_SNK_TRANSITION_TO_OFF;
2150                         kick_sm(pd, SRC_TRANSITION_TIME);
2151                         break;
2152                 } else if (IS_CTRL(rx_msg, MSG_VCONN_SWAP)) {
2153                         ret = pd_send_msg(pd, MSG_ACCEPT, NULL, 0, SOP_MSG);
2154                         if (ret) {
2155                                 usbpd_err(&pd->dev, "Error sending Accept\n");
2156                                 usbpd_set_state(pd, PE_SRC_SEND_SOFT_RESET);
2157                                 break;
2158                         }
2159
2160                         vconn_swap(pd);
2161                 } else if (IS_DATA(rx_msg, MSG_VDM)) {
2162                         handle_vdm_rx(pd, rx_msg);
2163                 } else if (rx_msg && pd->spec_rev == USBPD_REV_30) {
2164                         /* unhandled messages */
2165                         ret = pd_send_msg(pd, MSG_NOT_SUPPORTED, NULL, 0,
2166                                         SOP_MSG);
2167                         if (ret) {
2168                                 usbpd_err(&pd->dev, "Error sending Not supported\n");
2169                                 usbpd_set_state(pd, PE_SRC_SEND_SOFT_RESET);
2170                         }
2171                         break;
2172                 } else if (pd->send_pr_swap) {
2173                         pd->send_pr_swap = false;
2174                         ret = pd_send_msg(pd, MSG_PR_SWAP, NULL, 0, SOP_MSG);
2175                         if (ret) {
2176                                 dev_err(&pd->dev, "Error sending PR Swap\n");
2177                                 usbpd_set_state(pd, PE_SRC_SEND_SOFT_RESET);
2178                                 break;
2179                         }
2180
2181                         pd->current_state = PE_PRS_SRC_SNK_SEND_SWAP;
2182                         kick_sm(pd, SENDER_RESPONSE_TIME);
2183                 } else if (pd->send_dr_swap) {
2184                         pd->send_dr_swap = false;
2185                         ret = pd_send_msg(pd, MSG_DR_SWAP, NULL, 0, SOP_MSG);
2186                         if (ret) {
2187                                 dev_err(&pd->dev, "Error sending DR Swap\n");
2188                                 usbpd_set_state(pd, PE_SRC_SEND_SOFT_RESET);
2189                                 break;
2190                         }
2191
2192                         pd->current_state = PE_DRS_SEND_DR_SWAP;
2193                         kick_sm(pd, SENDER_RESPONSE_TIME);
2194                 } else {
2195                         handle_vdm_tx(pd);
2196                 }
2197                 break;
2198
2199         case PE_SRC_TRANSITION_TO_DEFAULT:
2200                 if (pd->vconn_enabled)
2201                         regulator_disable(pd->vconn);
2202                 pd->vconn_enabled = false;
2203
2204                 if (pd->vbus_enabled)
2205                         regulator_disable(pd->vbus);
2206                 pd->vbus_enabled = false;
2207
2208                 if (pd->current_dr != DR_DFP) {
2209                         extcon_set_cable_state_(pd->extcon, EXTCON_USB, 0);
2210                         pd->current_dr = DR_DFP;
2211                         pd_phy_update_roles(pd->current_dr, pd->current_pr);
2212                 }
2213
2214                 /* PE_UNKNOWN will turn on VBUS and go back to PE_SRC_STARTUP */
2215                 pd->current_state = PE_UNKNOWN;
2216                 kick_sm(pd, SRC_RECOVER_TIME);
2217                 break;
2218
2219         case PE_SRC_HARD_RESET:
2220                 val.intval = 1;
2221                 power_supply_set_property(pd->usb_psy,
2222                                 POWER_SUPPLY_PROP_PD_IN_HARD_RESET, &val);
2223
2224                 pd_send_hard_reset(pd);
2225                 pd->in_explicit_contract = false;
2226                 pd->rdo = 0;
2227                 rx_msg_cleanup(pd);
2228                 reset_vdm_state(pd);
2229                 kobject_uevent(&pd->dev.kobj, KOBJ_CHANGE);
2230
2231                 pd->current_state = PE_SRC_TRANSITION_TO_DEFAULT;
2232                 kick_sm(pd, PS_HARD_RESET_TIME);
2233                 break;
2234
2235         case PE_SNK_STARTUP:
2236                 usbpd_set_state(pd, PE_SNK_STARTUP);
2237                 break;
2238
2239         case PE_SNK_DISCOVERY:
2240                 if (!rx_msg) {
2241                         if (pd->vbus_present)
2242                                 usbpd_set_state(pd,
2243                                                 PE_SNK_WAIT_FOR_CAPABILITIES);
2244
2245                         /*
2246                          * Handle disconnection in the middle of PR_Swap.
2247                          * Since in psy_changed() if pd->in_pr_swap is true
2248                          * we ignore the typec_mode==NONE change since that is
2249                          * expected to happen. However if the cable really did
2250                          * get disconnected we need to check for it here after
2251                          * waiting for VBUS presence times out.
2252                          */
2253                         if (!pd->typec_mode) {
2254                                 pd->current_pr = PR_NONE;
2255                                 kick_sm(pd, 0);
2256                         }
2257
2258                         break;
2259                 }
2260                 /* else fall-through */
2261
2262         case PE_SNK_WAIT_FOR_CAPABILITIES:
2263                 pd->in_pr_swap = false;
2264                 val.intval = 0;
2265                 power_supply_set_property(pd->usb_psy,
2266                                 POWER_SUPPLY_PROP_PR_SWAP, &val);
2267
2268                 if (IS_DATA(rx_msg, MSG_SOURCE_CAPABILITIES)) {
2269                         val.intval = 0;
2270                         power_supply_set_property(pd->usb_psy,
2271                                         POWER_SUPPLY_PROP_PD_IN_HARD_RESET,
2272                                         &val);
2273
2274                         /* save the PDOs so userspace can further evaluate */
2275                         memset(&pd->received_pdos, 0,
2276                                         sizeof(pd->received_pdos));
2277                         memcpy(&pd->received_pdos, rx_msg->payload,
2278                                         min_t(size_t, rx_msg->data_len,
2279                                                 sizeof(pd->received_pdos)));
2280                         pd->src_cap_id++;
2281
2282                         usbpd_set_state(pd, PE_SNK_EVALUATE_CAPABILITY);
2283
2284                         val.intval = 1;
2285                         power_supply_set_property(pd->usb_psy,
2286                                         POWER_SUPPLY_PROP_PD_ACTIVE, &val);
2287                 } else if (pd->hard_reset_count < 3) {
2288                         usbpd_set_state(pd, PE_SNK_HARD_RESET);
2289                 } else {
2290                         usbpd_dbg(&pd->dev, "Sink hard reset count exceeded, disabling PD\n");
2291
2292                         val.intval = 0;
2293                         power_supply_set_property(pd->usb_psy,
2294                                         POWER_SUPPLY_PROP_PD_IN_HARD_RESET,
2295                                         &val);
2296
2297                         val.intval = 0;
2298                         power_supply_set_property(pd->usb_psy,
2299                                         POWER_SUPPLY_PROP_PD_ACTIVE, &val);
2300
2301                         pd_phy_close();
2302                         pd->pd_phy_opened = false;
2303                 }
2304                 break;
2305
2306         case PE_SNK_SELECT_CAPABILITY:
2307                 if (IS_CTRL(rx_msg, MSG_ACCEPT)) {
2308                         u32 pdo = pd->received_pdos[pd->requested_pdo - 1];
2309                         bool same_pps = (pd->selected_pdo == pd->requested_pdo)
2310                                 && (PD_SRC_PDO_TYPE(pdo) ==
2311                                                 PD_SRC_PDO_TYPE_AUGMENTED);
2312
2313                         usbpd_set_state(pd, PE_SNK_TRANSITION_SINK);
2314
2315                         /* prepare for voltage increase/decrease */
2316                         val.intval = pd->requested_voltage;
2317                         power_supply_set_property(pd->usb_psy,
2318                                 pd->requested_voltage >= pd->current_voltage ?
2319                                         POWER_SUPPLY_PROP_PD_VOLTAGE_MAX :
2320                                         POWER_SUPPLY_PROP_PD_VOLTAGE_MIN,
2321                                         &val);
2322
2323                         /*
2324                          * if changing voltages (not within the same PPS PDO),
2325                          * we must lower input current to pSnkStdby (2.5W).
2326                          * Calculate it and set PD_CURRENT_MAX accordingly.
2327                          */
2328                         if (!same_pps &&
2329                                 pd->requested_voltage != pd->current_voltage) {
2330                                 int mv = max(pd->requested_voltage,
2331                                                 pd->current_voltage) / 1000;
2332                                 val.intval = (2500000 / mv) * 1000;
2333                                 power_supply_set_property(pd->usb_psy,
2334                                         POWER_SUPPLY_PROP_PD_CURRENT_MAX, &val);
2335                         } else {
2336                                 /* decreasing current? */
2337                                 ret = power_supply_get_property(pd->usb_psy,
2338                                         POWER_SUPPLY_PROP_PD_CURRENT_MAX, &val);
2339                                 if (!ret &&
2340                                         pd->requested_current < val.intval) {
2341                                         val.intval =
2342                                                 pd->requested_current * 1000;
2343                                         power_supply_set_property(pd->usb_psy,
2344                                              POWER_SUPPLY_PROP_PD_CURRENT_MAX,
2345                                              &val);
2346                                 }
2347                         }
2348
2349                         pd->selected_pdo = pd->requested_pdo;
2350                 } else if (IS_CTRL(rx_msg, MSG_REJECT) ||
2351                                 IS_CTRL(rx_msg, MSG_WAIT)) {
2352                         if (pd->in_explicit_contract)
2353                                 usbpd_set_state(pd, PE_SNK_READY);
2354                         else
2355                                 usbpd_set_state(pd,
2356                                                 PE_SNK_WAIT_FOR_CAPABILITIES);
2357                 } else if (rx_msg) {
2358                         usbpd_err(&pd->dev, "Invalid response to sink request\n");
2359                         usbpd_set_state(pd, PE_SNK_SEND_SOFT_RESET);
2360                 } else {
2361                         /* timed out; go to hard reset */
2362                         usbpd_set_state(pd, PE_SNK_HARD_RESET);
2363                 }
2364                 break;
2365
2366         case PE_SNK_TRANSITION_SINK:
2367                 if (IS_CTRL(rx_msg, MSG_PS_RDY)) {
2368                         val.intval = pd->requested_voltage;
2369                         power_supply_set_property(pd->usb_psy,
2370                                 pd->requested_voltage >= pd->current_voltage ?
2371                                         POWER_SUPPLY_PROP_PD_VOLTAGE_MIN :
2372                                         POWER_SUPPLY_PROP_PD_VOLTAGE_MAX, &val);
2373                         pd->current_voltage = pd->requested_voltage;
2374
2375                         /* resume charging */
2376                         val.intval = pd->requested_current * 1000; /* mA->uA */
2377                         power_supply_set_property(pd->usb_psy,
2378                                         POWER_SUPPLY_PROP_PD_CURRENT_MAX, &val);
2379
2380                         usbpd_set_state(pd, PE_SNK_READY);
2381                 } else {
2382                         /* timed out; go to hard reset */
2383                         usbpd_set_state(pd, PE_SNK_HARD_RESET);
2384                 }
2385                 break;
2386
2387         case PE_SNK_READY:
2388                 if (IS_DATA(rx_msg, MSG_SOURCE_CAPABILITIES)) {
2389                         /* save the PDOs so userspace can further evaluate */
2390                         memset(&pd->received_pdos, 0,
2391                                         sizeof(pd->received_pdos));
2392                         memcpy(&pd->received_pdos, rx_msg->payload,
2393                                         min_t(size_t, rx_msg->data_len,
2394                                                 sizeof(pd->received_pdos)));
2395                         pd->src_cap_id++;
2396
2397                         usbpd_set_state(pd, PE_SNK_EVALUATE_CAPABILITY);
2398                 } else if (IS_CTRL(rx_msg, MSG_GET_SINK_CAP)) {
2399                         ret = pd_send_msg(pd, MSG_SINK_CAPABILITIES,
2400                                         pd->sink_caps, pd->num_sink_caps,
2401                                         SOP_MSG);
2402                         if (ret) {
2403                                 usbpd_err(&pd->dev, "Error sending Sink Caps\n");
2404                                 usbpd_set_state(pd, PE_SNK_SEND_SOFT_RESET);
2405                         }
2406                 } else if (IS_CTRL(rx_msg, MSG_GET_SOURCE_CAP) &&
2407                                 pd->spec_rev == USBPD_REV_20) {
2408                         ret = pd_send_msg(pd, MSG_SOURCE_CAPABILITIES,
2409                                         default_src_caps,
2410                                         ARRAY_SIZE(default_src_caps), SOP_MSG);
2411                         if (ret) {
2412                                 usbpd_err(&pd->dev, "Error sending SRC CAPs\n");
2413                                 usbpd_set_state(pd, PE_SNK_SEND_SOFT_RESET);
2414                                 break;
2415                         }
2416                 } else if (IS_CTRL(rx_msg, MSG_DR_SWAP)) {
2417                         if (pd->vdm_state == MODE_ENTERED) {
2418                                 usbpd_set_state(pd, PE_SNK_HARD_RESET);
2419                                 break;
2420                         }
2421
2422                         ret = pd_send_msg(pd, MSG_ACCEPT, NULL, 0, SOP_MSG);
2423                         if (ret) {
2424                                 usbpd_err(&pd->dev, "Error sending Accept\n");
2425                                 usbpd_set_state(pd, PE_SRC_SEND_SOFT_RESET);
2426                                 break;
2427                         }
2428
2429                         dr_swap(pd);
2430                 } else if (IS_CTRL(rx_msg, MSG_PR_SWAP) &&
2431                                 pd->spec_rev == USBPD_REV_20) {
2432                         /* lock in current mode */
2433                         set_power_role(pd, pd->current_pr);
2434
2435                         /* TODO: should we Reject in certain circumstances? */
2436                         ret = pd_send_msg(pd, MSG_ACCEPT, NULL, 0, SOP_MSG);
2437                         if (ret) {
2438                                 usbpd_err(&pd->dev, "Error sending Accept\n");
2439                                 usbpd_set_state(pd, PE_SNK_SEND_SOFT_RESET);
2440                                 break;
2441                         }
2442
2443                         pd->in_pr_swap = true;
2444                         val.intval = 1;
2445                         power_supply_set_property(pd->usb_psy,
2446                                         POWER_SUPPLY_PROP_PR_SWAP, &val);
2447                         usbpd_set_state(pd, PE_PRS_SNK_SRC_TRANSITION_TO_OFF);
2448                         break;
2449                 } else if (IS_CTRL(rx_msg, MSG_VCONN_SWAP) &&
2450                                 pd->spec_rev == USBPD_REV_20) {
2451                         /*
2452                          * if VCONN is connected to VBUS, make sure we are
2453                          * not in high voltage contract, otherwise reject.
2454                          */
2455                         if (!pd->vconn_is_external &&
2456                                         (pd->requested_voltage > 5000000)) {
2457                                 ret = pd_send_msg(pd, MSG_REJECT, NULL, 0,
2458                                                 SOP_MSG);
2459                                 if (ret) {
2460                                         usbpd_err(&pd->dev, "Error sending Reject\n");
2461                                         usbpd_set_state(pd,
2462                                                         PE_SNK_SEND_SOFT_RESET);
2463                                 }
2464
2465                                 break;
2466                         }
2467
2468                         ret = pd_send_msg(pd, MSG_ACCEPT, NULL, 0, SOP_MSG);
2469                         if (ret) {
2470                                 usbpd_err(&pd->dev, "Error sending Accept\n");
2471                                 usbpd_set_state(pd, PE_SNK_SEND_SOFT_RESET);
2472                                 break;
2473                         }
2474
2475                         vconn_swap(pd);
2476                 } else if (IS_DATA(rx_msg, MSG_VDM)) {
2477                         handle_vdm_rx(pd, rx_msg);
2478                 } else if (pd->send_get_src_cap_ext && is_sink_tx_ok(pd)) {
2479                         pd->send_get_src_cap_ext = false;
2480                         ret = pd_send_msg(pd, MSG_GET_SOURCE_CAP_EXTENDED, NULL,
2481                                 0, SOP_MSG);
2482                         if (ret) {
2483                                 dev_err(&pd->dev,
2484                                         "Error sending get_src_cap_ext\n");
2485                                 usbpd_set_state(pd, PE_SNK_SEND_SOFT_RESET);
2486                                 break;
2487                         }
2488                         kick_sm(pd, SENDER_RESPONSE_TIME);
2489                 } else if (rx_msg &&
2490                         IS_EXT(rx_msg, MSG_SOURCE_CAPABILITIES_EXTENDED)) {
2491                         if (rx_msg->data_len != PD_SRC_CAP_EXT_DB_LEN) {
2492                                 usbpd_err(&pd->dev, "Invalid src cap ext db\n");
2493                                 break;
2494                         }
2495                         memcpy(&pd->src_cap_ext_db, rx_msg->payload,
2496                                 sizeof(pd->src_cap_ext_db));
2497                         complete(&pd->is_ready);
2498                 } else if (pd->send_get_pps_status && is_sink_tx_ok(pd)) {
2499                         pd->send_get_pps_status = false;
2500                         ret = pd_send_msg(pd, MSG_GET_PPS_STATUS, NULL,
2501                                 0, SOP_MSG);
2502                         if (ret) {
2503                                 dev_err(&pd->dev,
2504                                         "Error sending get_pps_status\n");
2505                                 usbpd_set_state(pd, PE_SNK_SEND_SOFT_RESET);
2506                                 break;
2507                         }
2508                         kick_sm(pd, SENDER_RESPONSE_TIME);
2509                 } else if (rx_msg &&
2510                         IS_EXT(rx_msg, MSG_PPS_STATUS)) {
2511                         if (rx_msg->data_len != sizeof(pd->pps_status_db)) {
2512                                 usbpd_err(&pd->dev, "Invalid pps status db\n");
2513                                 break;
2514                         }
2515                         memcpy(&pd->pps_status_db, rx_msg->payload,
2516                                 sizeof(pd->pps_status_db));
2517                         complete(&pd->is_ready);
2518                 } else if (IS_DATA(rx_msg, MSG_ALERT)) {
2519                         if (rx_msg->data_len != sizeof(pd->received_ado)) {
2520                                 usbpd_err(&pd->dev, "Invalid ado\n");
2521                                 break;
2522                         }
2523                         memcpy(&pd->received_ado, rx_msg->payload,
2524                                 sizeof(pd->received_ado));
2525                         ret = pd_send_msg(pd, MSG_GET_STATUS, NULL,
2526                                 0, SOP_MSG);
2527                         if (ret) {
2528                                 dev_err(&pd->dev,
2529                                         "Error sending get_status\n");
2530                                 usbpd_set_state(pd, PE_SNK_SEND_SOFT_RESET);
2531                                 break;
2532                         }
2533                         kick_sm(pd, SENDER_RESPONSE_TIME);
2534                 } else if (rx_msg &&
2535                         IS_EXT(rx_msg, MSG_STATUS)) {
2536                         if (rx_msg->data_len != PD_STATUS_DB_LEN) {
2537                                 usbpd_err(&pd->dev, "Invalid status db\n");
2538                                 break;
2539                         }
2540                         memcpy(&pd->status_db, rx_msg->payload,
2541                                 sizeof(pd->status_db));
2542                         kobject_uevent(&pd->dev.kobj, KOBJ_CHANGE);
2543                 } else if (pd->send_get_battery_cap && is_sink_tx_ok(pd)) {
2544                         pd->send_get_battery_cap = false;
2545                         ret = pd_send_ext_msg(pd, MSG_GET_BATTERY_CAP,
2546                                 &pd->get_battery_cap_db, 1, SOP_MSG);
2547                         if (ret) {
2548                                 dev_err(&pd->dev,
2549                                         "Error sending get_battery_cap\n");
2550                                 usbpd_set_state(pd, PE_SNK_SEND_SOFT_RESET);
2551                                 break;
2552                         }
2553                         kick_sm(pd, SENDER_RESPONSE_TIME);
2554                 } else if (rx_msg &&
2555                         IS_EXT(rx_msg, MSG_BATTERY_CAPABILITIES)) {
2556                         if (rx_msg->data_len != PD_BATTERY_CAP_DB_LEN) {
2557                                 usbpd_err(&pd->dev, "Invalid battery cap db\n");
2558                                 break;
2559                         }
2560                         memcpy(&pd->battery_cap_db, rx_msg->payload,
2561                                 sizeof(pd->battery_cap_db));
2562                         complete(&pd->is_ready);
2563                 } else if (pd->send_get_battery_status && is_sink_tx_ok(pd)) {
2564                         pd->send_get_battery_status = false;
2565                         ret = pd_send_ext_msg(pd, MSG_GET_BATTERY_STATUS,
2566                                 &pd->get_battery_status_db, 1, SOP_MSG);
2567                         if (ret) {
2568                                 dev_err(&pd->dev,
2569                                         "Error sending get_battery_status\n");
2570                                 usbpd_set_state(pd, PE_SNK_SEND_SOFT_RESET);
2571                                 break;
2572                         }
2573                         kick_sm(pd, SENDER_RESPONSE_TIME);
2574                 } else if (rx_msg &&
2575                         IS_EXT(rx_msg, MSG_BATTERY_STATUS)) {
2576                         if (rx_msg->data_len != sizeof(pd->battery_sts_dobj)) {
2577                                 usbpd_err(&pd->dev, "Invalid bat sts dobj\n");
2578                                 break;
2579                         }
2580                         memcpy(&pd->battery_sts_dobj, rx_msg->payload,
2581                                 sizeof(pd->battery_sts_dobj));
2582                         complete(&pd->is_ready);
2583                 } else if (rx_msg && pd->spec_rev == USBPD_REV_30) {
2584                         /* unhandled messages */
2585                         ret = pd_send_msg(pd, MSG_NOT_SUPPORTED, NULL, 0,
2586                                         SOP_MSG);
2587                         if (ret) {
2588                                 usbpd_err(&pd->dev, "Error sending Not supported\n");
2589                                 usbpd_set_state(pd, PE_SNK_SEND_SOFT_RESET);
2590                         }
2591                         break;
2592                 } else if (pd->send_request) {
2593                         pd->send_request = false;
2594                         usbpd_set_state(pd, PE_SNK_SELECT_CAPABILITY);
2595                 } else if (pd->send_pr_swap && is_sink_tx_ok(pd)) {
2596                         pd->send_pr_swap = false;
2597                         ret = pd_send_msg(pd, MSG_PR_SWAP, NULL, 0, SOP_MSG);
2598                         if (ret) {
2599                                 dev_err(&pd->dev, "Error sending PR Swap\n");
2600                                 usbpd_set_state(pd, PE_SNK_SEND_SOFT_RESET);
2601                                 break;
2602                         }
2603
2604                         pd->current_state = PE_PRS_SNK_SRC_SEND_SWAP;
2605                         kick_sm(pd, SENDER_RESPONSE_TIME);
2606                 } else if (pd->send_dr_swap && is_sink_tx_ok(pd)) {
2607                         pd->send_dr_swap = false;
2608                         ret = pd_send_msg(pd, MSG_DR_SWAP, NULL, 0, SOP_MSG);
2609                         if (ret) {
2610                                 dev_err(&pd->dev, "Error sending DR Swap\n");
2611                                 usbpd_set_state(pd, PE_SNK_SEND_SOFT_RESET);
2612                                 break;
2613                         }
2614
2615                         pd->current_state = PE_DRS_SEND_DR_SWAP;
2616                         kick_sm(pd, SENDER_RESPONSE_TIME);
2617                 } else if (is_sink_tx_ok(pd)) {
2618                         handle_vdm_tx(pd);
2619                 }
2620                 break;
2621
2622         case PE_SNK_TRANSITION_TO_DEFAULT:
2623                 usbpd_set_state(pd, PE_SNK_STARTUP);
2624                 break;
2625
2626         case PE_SRC_SOFT_RESET:
2627         case PE_SNK_SOFT_RESET:
2628                 pd_reset_protocol(pd);
2629
2630                 ret = pd_send_msg(pd, MSG_ACCEPT, NULL, 0, SOP_MSG);
2631                 if (ret) {
2632                         usbpd_err(&pd->dev, "%s: Error sending Accept, do Hard Reset\n",
2633                                         usbpd_state_strings[pd->current_state]);
2634                         usbpd_set_state(pd, pd->current_pr == PR_SRC ?
2635                                         PE_SRC_HARD_RESET : PE_SNK_HARD_RESET);
2636                         break;
2637                 }
2638
2639                 usbpd_set_state(pd, pd->current_pr == PR_SRC ?
2640                                 PE_SRC_SEND_CAPABILITIES :
2641                                 PE_SNK_WAIT_FOR_CAPABILITIES);
2642                 break;
2643
2644         case PE_SRC_SEND_SOFT_RESET:
2645         case PE_SNK_SEND_SOFT_RESET:
2646                 if (IS_CTRL(rx_msg, MSG_ACCEPT)) {
2647                         usbpd_set_state(pd, pd->current_pr == PR_SRC ?
2648                                         PE_SRC_SEND_CAPABILITIES :
2649                                         PE_SNK_WAIT_FOR_CAPABILITIES);
2650                 } else {
2651                         usbpd_err(&pd->dev, "%s: Did not see Accept, do Hard Reset\n",
2652                                         usbpd_state_strings[pd->current_state]);
2653                         usbpd_set_state(pd, pd->current_pr == PR_SRC ?
2654                                         PE_SRC_HARD_RESET : PE_SNK_HARD_RESET);
2655                 }
2656                 break;
2657
2658         case PE_SNK_HARD_RESET:
2659                 /* prepare charger for VBUS change */
2660                 val.intval = 1;
2661                 power_supply_set_property(pd->usb_psy,
2662                                 POWER_SUPPLY_PROP_PD_IN_HARD_RESET, &val);
2663
2664                 pd->requested_voltage = 5000000;
2665
2666                 if (pd->requested_current) {
2667                         val.intval = pd->requested_current = 0;
2668                         power_supply_set_property(pd->usb_psy,
2669                                         POWER_SUPPLY_PROP_PD_CURRENT_MAX, &val);
2670                 }
2671
2672                 val.intval = pd->requested_voltage;
2673                 power_supply_set_property(pd->usb_psy,
2674                                 POWER_SUPPLY_PROP_PD_VOLTAGE_MIN, &val);
2675
2676                 pd_send_hard_reset(pd);
2677                 pd->in_explicit_contract = false;
2678                 pd->selected_pdo = pd->requested_pdo = 0;
2679                 pd->rdo = 0;
2680                 reset_vdm_state(pd);
2681                 kobject_uevent(&pd->dev.kobj, KOBJ_CHANGE);
2682                 usbpd_set_state(pd, PE_SNK_TRANSITION_TO_DEFAULT);
2683                 break;
2684
2685         case PE_DRS_SEND_DR_SWAP:
2686                 if (IS_CTRL(rx_msg, MSG_ACCEPT))
2687                         dr_swap(pd);
2688
2689                 usbpd_set_state(pd, pd->current_pr == PR_SRC ?
2690                                 PE_SRC_READY : PE_SNK_READY);
2691                 break;
2692
2693         case PE_PRS_SRC_SNK_SEND_SWAP:
2694                 if (!IS_CTRL(rx_msg, MSG_ACCEPT)) {
2695                         pd->current_state = PE_SRC_READY;
2696                         break;
2697                 }
2698
2699                 pd->current_state = PE_PRS_SRC_SNK_TRANSITION_TO_OFF;
2700                 kick_sm(pd, SRC_TRANSITION_TIME);
2701                 break;
2702
2703         case PE_PRS_SRC_SNK_TRANSITION_TO_OFF:
2704                 pd->in_pr_swap = true;
2705                 val.intval = 1;
2706                 power_supply_set_property(pd->usb_psy,
2707                                 POWER_SUPPLY_PROP_PR_SWAP, &val);
2708                 pd->in_explicit_contract = false;
2709
2710                 if (pd->vbus_enabled) {
2711                         regulator_disable(pd->vbus);
2712                         pd->vbus_enabled = false;
2713                 }
2714
2715                 /* PE_PRS_SRC_SNK_Assert_Rd */
2716                 pd->current_pr = PR_SINK;
2717                 set_power_role(pd, pd->current_pr);
2718                 pd_phy_update_roles(pd->current_dr, pd->current_pr);
2719
2720                 /* allow time for Vbus discharge, must be < tSrcSwapStdby */
2721                 msleep(500);
2722
2723                 ret = pd_send_msg(pd, MSG_PS_RDY, NULL, 0, SOP_MSG);
2724                 if (ret) {
2725                         usbpd_err(&pd->dev, "Error sending PS_RDY\n");
2726                         usbpd_set_state(pd, PE_ERROR_RECOVERY);
2727                         break;
2728                 }
2729
2730                 pd->current_state = PE_PRS_SRC_SNK_WAIT_SOURCE_ON;
2731                 kick_sm(pd, PS_SOURCE_ON);
2732                 break;
2733
2734         case PE_PRS_SRC_SNK_WAIT_SOURCE_ON:
2735                 if (IS_CTRL(rx_msg, MSG_PS_RDY))
2736                         usbpd_set_state(pd, PE_SNK_STARTUP);
2737                 else
2738                         usbpd_set_state(pd, PE_ERROR_RECOVERY);
2739                 break;
2740
2741         case PE_PRS_SNK_SRC_SEND_SWAP:
2742                 if (!IS_CTRL(rx_msg, MSG_ACCEPT)) {
2743                         pd->current_state = PE_SNK_READY;
2744                         break;
2745                 }
2746
2747                 pd->in_pr_swap = true;
2748                 val.intval = 1;
2749                 power_supply_set_property(pd->usb_psy,
2750                                 POWER_SUPPLY_PROP_PR_SWAP, &val);
2751                 usbpd_set_state(pd, PE_PRS_SNK_SRC_TRANSITION_TO_OFF);
2752                 break;
2753
2754         case PE_PRS_SNK_SRC_TRANSITION_TO_OFF:
2755                 if (!IS_CTRL(rx_msg, MSG_PS_RDY)) {
2756                         usbpd_set_state(pd, PE_ERROR_RECOVERY);
2757                         break;
2758                 }
2759
2760                 /* PE_PRS_SNK_SRC_Assert_Rp */
2761                 pd->current_pr = PR_SRC;
2762                 set_power_role(pd, pd->current_pr);
2763                 pd->current_state = PE_PRS_SNK_SRC_SOURCE_ON;
2764
2765                 /* fall-through */
2766
2767         case PE_PRS_SNK_SRC_SOURCE_ON:
2768                 enable_vbus(pd);
2769
2770                 ret = pd_send_msg(pd, MSG_PS_RDY, NULL, 0, SOP_MSG);
2771                 if (ret) {
2772                         usbpd_err(&pd->dev, "Error sending PS_RDY\n");
2773                         usbpd_set_state(pd, PE_ERROR_RECOVERY);
2774                         break;
2775                 }
2776
2777                 usbpd_set_state(pd, PE_SRC_STARTUP);
2778                 break;
2779
2780         case PE_VCS_WAIT_FOR_VCONN:
2781                 if (IS_CTRL(rx_msg, MSG_PS_RDY)) {
2782                         /*
2783                          * hopefully redundant check but in case not enabled
2784                          * avoids unbalanced regulator disable count
2785                          */
2786                         if (pd->vconn_enabled)
2787                                 regulator_disable(pd->vconn);
2788                         pd->vconn_enabled = false;
2789
2790                         pd->current_state = pd->current_pr == PR_SRC ?
2791                                 PE_SRC_READY : PE_SNK_READY;
2792                 } else {
2793                         /* timed out; go to hard reset */
2794                         usbpd_set_state(pd, pd->current_pr == PR_SRC ?
2795                                         PE_SRC_HARD_RESET : PE_SNK_HARD_RESET);
2796                 }
2797
2798                 break;
2799
2800         default:
2801                 usbpd_err(&pd->dev, "Unhandled state %s\n",
2802                                 usbpd_state_strings[pd->current_state]);
2803                 break;
2804         }
2805
2806 sm_done:
2807         kfree(rx_msg);
2808
2809         spin_lock_irqsave(&pd->rx_lock, flags);
2810         ret = list_empty(&pd->rx_q);
2811         spin_unlock_irqrestore(&pd->rx_lock, flags);
2812
2813         /* requeue if there are any new/pending RX messages */
2814         if (!ret)
2815                 kick_sm(pd, 0);
2816
2817         if (!pd->sm_queued)
2818                 pm_relax(&pd->dev);
2819 }
2820
2821 static inline const char *src_current(enum power_supply_typec_mode typec_mode)
2822 {
2823         switch (typec_mode) {
2824         case POWER_SUPPLY_TYPEC_SOURCE_DEFAULT:
2825                 return "default";
2826         case POWER_SUPPLY_TYPEC_SOURCE_MEDIUM:
2827                 return "medium - 1.5A";
2828         case POWER_SUPPLY_TYPEC_SOURCE_HIGH:
2829                 return "high - 3.0A";
2830         default:
2831                 return "";
2832         }
2833 }
2834
2835 static int psy_changed(struct notifier_block *nb, unsigned long evt, void *ptr)
2836 {
2837         struct usbpd *pd = container_of(nb, struct usbpd, psy_nb);
2838         union power_supply_propval val;
2839         enum power_supply_typec_mode typec_mode;
2840         int ret;
2841
2842         if (ptr != pd->usb_psy || evt != PSY_EVENT_PROP_CHANGED)
2843                 return 0;
2844
2845         ret = power_supply_get_property(pd->usb_psy,
2846                         POWER_SUPPLY_PROP_TYPEC_MODE, &val);
2847         if (ret) {
2848                 usbpd_err(&pd->dev, "Unable to read USB TYPEC_MODE: %d\n", ret);
2849                 return ret;
2850         }
2851
2852         typec_mode = val.intval;
2853
2854         ret = power_supply_get_property(pd->usb_psy,
2855                         POWER_SUPPLY_PROP_PE_START, &val);
2856         if (ret) {
2857                 usbpd_err(&pd->dev, "Unable to read USB PROP_PE_START: %d\n",
2858                                 ret);
2859                 return ret;
2860         }
2861
2862         /* Don't proceed if PE_START=0 as other props may still change */
2863         if (!val.intval && !pd->pd_connected &&
2864                         typec_mode != POWER_SUPPLY_TYPEC_NONE)
2865                 return 0;
2866
2867         ret = power_supply_get_property(pd->usb_psy,
2868                         POWER_SUPPLY_PROP_PRESENT, &val);
2869         if (ret) {
2870                 usbpd_err(&pd->dev, "Unable to read USB PRESENT: %d\n", ret);
2871                 return ret;
2872         }
2873
2874         pd->vbus_present = val.intval;
2875
2876         ret = power_supply_get_property(pd->usb_psy,
2877                         POWER_SUPPLY_PROP_REAL_TYPE, &val);
2878         if (ret) {
2879                 usbpd_err(&pd->dev, "Unable to read USB TYPE: %d\n", ret);
2880                 return ret;
2881         }
2882
2883         pd->psy_type = val.intval;
2884
2885         /*
2886          * For sink hard reset, state machine needs to know when VBUS changes
2887          *   - when in PE_SNK_TRANSITION_TO_DEFAULT, notify when VBUS falls
2888          *   - when in PE_SNK_DISCOVERY, notify when VBUS rises
2889          */
2890         if (typec_mode && ((!pd->vbus_present &&
2891                         pd->current_state == PE_SNK_TRANSITION_TO_DEFAULT) ||
2892                 (pd->vbus_present && pd->current_state == PE_SNK_DISCOVERY))) {
2893                 usbpd_dbg(&pd->dev, "hard reset: typec mode:%d present:%d\n",
2894                         typec_mode, pd->vbus_present);
2895                 pd->typec_mode = typec_mode;
2896                 kick_sm(pd, 0);
2897                 return 0;
2898         }
2899
2900         if (pd->typec_mode == typec_mode)
2901                 return 0;
2902
2903         pd->typec_mode = typec_mode;
2904
2905         usbpd_dbg(&pd->dev, "typec mode:%d present:%d type:%d orientation:%d\n",
2906                         typec_mode, pd->vbus_present, pd->psy_type,
2907                         usbpd_get_plug_orientation(pd));
2908
2909         switch (typec_mode) {
2910         /* Disconnect */
2911         case POWER_SUPPLY_TYPEC_NONE:
2912                 if (pd->in_pr_swap) {
2913                         usbpd_dbg(&pd->dev, "Ignoring disconnect due to PR swap\n");
2914                         return 0;
2915                 }
2916
2917                 pd->current_pr = PR_NONE;
2918                 break;
2919
2920         /* Sink states */
2921         case POWER_SUPPLY_TYPEC_SOURCE_DEFAULT:
2922         case POWER_SUPPLY_TYPEC_SOURCE_MEDIUM:
2923         case POWER_SUPPLY_TYPEC_SOURCE_HIGH:
2924                 usbpd_info(&pd->dev, "Type-C Source (%s) connected\n",
2925                                 src_current(typec_mode));
2926
2927                 /* if waiting for SinkTxOk to start an AMS */
2928                 if (pd->spec_rev == USBPD_REV_30 &&
2929                         typec_mode == POWER_SUPPLY_TYPEC_SOURCE_HIGH &&
2930                         (pd->send_pr_swap || pd->send_dr_swap || pd->vdm_tx))
2931                         break;
2932
2933                 if (pd->current_pr == PR_SINK)
2934                         return 0;
2935
2936                 /*
2937                  * Unexpected if not in PR swap; need to force disconnect from
2938                  * source so we can turn off VBUS, Vconn, PD PHY etc.
2939                  */
2940                 if (pd->current_pr == PR_SRC) {
2941                         usbpd_info(&pd->dev, "Forcing disconnect from source mode\n");
2942                         pd->current_pr = PR_NONE;
2943                         break;
2944                 }
2945
2946                 pd->current_pr = PR_SINK;
2947                 break;
2948
2949         /* Source states */
2950         case POWER_SUPPLY_TYPEC_SINK_POWERED_CABLE:
2951         case POWER_SUPPLY_TYPEC_SINK:
2952                 usbpd_info(&pd->dev, "Type-C Sink%s connected\n",
2953                                 typec_mode == POWER_SUPPLY_TYPEC_SINK ?
2954                                         "" : " (powered)");
2955
2956                 if (pd->current_pr == PR_SRC)
2957                         return 0;
2958
2959                 pd->current_pr = PR_SRC;
2960                 break;
2961
2962         case POWER_SUPPLY_TYPEC_SINK_DEBUG_ACCESSORY:
2963                 usbpd_info(&pd->dev, "Type-C Debug Accessory connected\n");
2964                 break;
2965         case POWER_SUPPLY_TYPEC_SINK_AUDIO_ADAPTER:
2966                 usbpd_info(&pd->dev, "Type-C Analog Audio Adapter connected\n");
2967                 break;
2968         default:
2969                 usbpd_warn(&pd->dev, "Unsupported typec mode:%d\n",
2970                                 typec_mode);
2971                 break;
2972         }
2973
2974         /* queue state machine due to CC state change */
2975         kick_sm(pd, 0);
2976         return 0;
2977 }
2978
2979 static enum dual_role_property usbpd_dr_properties[] = {
2980         DUAL_ROLE_PROP_SUPPORTED_MODES,
2981         DUAL_ROLE_PROP_MODE,
2982         DUAL_ROLE_PROP_PR,
2983         DUAL_ROLE_PROP_DR,
2984 };
2985
2986 static int usbpd_dr_get_property(struct dual_role_phy_instance *dual_role,
2987                 enum dual_role_property prop, unsigned int *val)
2988 {
2989         struct usbpd *pd = dual_role_get_drvdata(dual_role);
2990
2991         if (!pd)
2992                 return -ENODEV;
2993
2994         switch (prop) {
2995         case DUAL_ROLE_PROP_MODE:
2996                 /* For now associate UFP/DFP with data role only */
2997                 if (pd->current_dr == DR_UFP)
2998                         *val = DUAL_ROLE_PROP_MODE_UFP;
2999                 else if (pd->current_dr == DR_DFP)
3000                         *val = DUAL_ROLE_PROP_MODE_DFP;
3001                 else
3002                         *val = DUAL_ROLE_PROP_MODE_NONE;
3003                 break;
3004         case DUAL_ROLE_PROP_PR:
3005                 if (pd->current_pr == PR_SRC)
3006                         *val = DUAL_ROLE_PROP_PR_SRC;
3007                 else if (pd->current_pr == PR_SINK)
3008                         *val = DUAL_ROLE_PROP_PR_SNK;
3009                 else
3010                         *val = DUAL_ROLE_PROP_PR_NONE;
3011                 break;
3012         case DUAL_ROLE_PROP_DR:
3013                 if (pd->current_dr == DR_UFP)
3014                         *val = DUAL_ROLE_PROP_DR_DEVICE;
3015                 else if (pd->current_dr == DR_DFP)
3016                         *val = DUAL_ROLE_PROP_DR_HOST;
3017                 else
3018                         *val = DUAL_ROLE_PROP_DR_NONE;
3019                 break;
3020         default:
3021                 usbpd_warn(&pd->dev, "unsupported property %d\n", prop);
3022                 return -ENODATA;
3023         }
3024
3025         return 0;
3026 }
3027
3028 static int usbpd_dr_set_property(struct dual_role_phy_instance *dual_role,
3029                 enum dual_role_property prop, const unsigned int *val)
3030 {
3031         struct usbpd *pd = dual_role_get_drvdata(dual_role);
3032         bool do_swap = false;
3033         int wait_count = 5;
3034
3035         if (!pd)
3036                 return -ENODEV;
3037
3038         switch (prop) {
3039         case DUAL_ROLE_PROP_MODE:
3040                 usbpd_dbg(&pd->dev, "Setting mode to %d\n", *val);
3041
3042                 if (pd->current_state == PE_UNKNOWN) {
3043                         usbpd_warn(&pd->dev, "No active connection. Don't allow MODE change\n");
3044                         return -EAGAIN;
3045                 }
3046
3047                 /*
3048                  * Forces disconnect on CC and re-establishes connection.
3049                  * This does not use PD-based PR/DR swap
3050                  */
3051                 if (*val == DUAL_ROLE_PROP_MODE_UFP)
3052                         pd->forced_pr = POWER_SUPPLY_TYPEC_PR_SINK;
3053                 else if (*val == DUAL_ROLE_PROP_MODE_DFP)
3054                         pd->forced_pr = POWER_SUPPLY_TYPEC_PR_SOURCE;
3055
3056                 /* new mode will be applied in disconnect handler */
3057                 set_power_role(pd, PR_NONE);
3058
3059                 /* wait until it takes effect */
3060                 while (pd->forced_pr != POWER_SUPPLY_TYPEC_PR_NONE &&
3061                                                         --wait_count)
3062                         msleep(20);
3063
3064                 if (!wait_count) {
3065                         usbpd_err(&pd->dev, "setting mode timed out\n");
3066                         return -ETIMEDOUT;
3067                 }
3068
3069                 break;
3070
3071         case DUAL_ROLE_PROP_DR:
3072                 usbpd_dbg(&pd->dev, "Setting data_role to %d\n", *val);
3073
3074                 if (*val == DUAL_ROLE_PROP_DR_HOST) {
3075                         if (pd->current_dr == DR_UFP)
3076                                 do_swap = true;
3077                 } else if (*val == DUAL_ROLE_PROP_DR_DEVICE) {
3078                         if (pd->current_dr == DR_DFP)
3079                                 do_swap = true;
3080                 } else {
3081                         usbpd_warn(&pd->dev, "setting data_role to 'none' unsupported\n");
3082                         return -ENOTSUPP;
3083                 }
3084
3085                 if (do_swap) {
3086                         if (pd->current_state != PE_SRC_READY &&
3087                                         pd->current_state != PE_SNK_READY) {
3088                                 usbpd_err(&pd->dev, "data_role swap not allowed: PD not in Ready state\n");
3089                                 return -EAGAIN;
3090                         }
3091
3092                         if (pd->current_state == PE_SNK_READY &&
3093                                         !is_sink_tx_ok(pd)) {
3094                                 usbpd_err(&pd->dev, "Rp indicates SinkTxNG\n");
3095                                 return -EAGAIN;
3096                         }
3097
3098                         mutex_lock(&pd->swap_lock);
3099                         reinit_completion(&pd->is_ready);
3100                         pd->send_dr_swap = true;
3101                         kick_sm(pd, 0);
3102
3103                         /* wait for operation to complete */
3104                         if (!wait_for_completion_timeout(&pd->is_ready,
3105                                         msecs_to_jiffies(100))) {
3106                                 usbpd_err(&pd->dev, "data_role swap timed out\n");
3107                                 mutex_unlock(&pd->swap_lock);
3108                                 return -ETIMEDOUT;
3109                         }
3110
3111                         mutex_unlock(&pd->swap_lock);
3112
3113                         if ((*val == DUAL_ROLE_PROP_DR_HOST &&
3114                                         pd->current_dr != DR_DFP) ||
3115                                 (*val == DUAL_ROLE_PROP_DR_DEVICE &&
3116                                          pd->current_dr != DR_UFP)) {
3117                                 usbpd_err(&pd->dev, "incorrect state (%s) after data_role swap\n",
3118                                                 pd->current_dr == DR_DFP ?
3119                                                 "dfp" : "ufp");
3120                                 return -EPROTO;
3121                         }
3122                 }
3123
3124                 break;
3125
3126         case DUAL_ROLE_PROP_PR:
3127                 usbpd_dbg(&pd->dev, "Setting power_role to %d\n", *val);
3128
3129                 if (*val == DUAL_ROLE_PROP_PR_SRC) {
3130                         if (pd->current_pr == PR_SINK)
3131                                 do_swap = true;
3132                 } else if (*val == DUAL_ROLE_PROP_PR_SNK) {
3133                         if (pd->current_pr == PR_SRC)
3134                                 do_swap = true;
3135                 } else {
3136                         usbpd_warn(&pd->dev, "setting power_role to 'none' unsupported\n");
3137                         return -ENOTSUPP;
3138                 }
3139
3140                 if (do_swap) {
3141                         if (pd->current_state != PE_SRC_READY &&
3142                                         pd->current_state != PE_SNK_READY) {
3143                                 usbpd_err(&pd->dev, "power_role swap not allowed: PD not in Ready state\n");
3144                                 return -EAGAIN;
3145                         }
3146
3147                         if (pd->current_state == PE_SNK_READY &&
3148                                         !is_sink_tx_ok(pd)) {
3149                                 usbpd_err(&pd->dev, "Rp indicates SinkTxNG\n");
3150                                 return -EAGAIN;
3151                         }
3152
3153                         mutex_lock(&pd->swap_lock);
3154                         reinit_completion(&pd->is_ready);
3155                         pd->send_pr_swap = true;
3156                         kick_sm(pd, 0);
3157
3158                         /* wait for operation to complete */
3159                         if (!wait_for_completion_timeout(&pd->is_ready,
3160                                         msecs_to_jiffies(2000))) {
3161                                 usbpd_err(&pd->dev, "power_role swap timed out\n");
3162                                 mutex_unlock(&pd->swap_lock);
3163                                 return -ETIMEDOUT;
3164                         }
3165
3166                         mutex_unlock(&pd->swap_lock);
3167
3168                         if ((*val == DUAL_ROLE_PROP_PR_SRC &&
3169                                         pd->current_pr != PR_SRC) ||
3170                                 (*val == DUAL_ROLE_PROP_PR_SNK &&
3171                                          pd->current_pr != PR_SINK)) {
3172                                 usbpd_err(&pd->dev, "incorrect state (%s) after power_role swap\n",
3173                                                 pd->current_pr == PR_SRC ?
3174                                                 "source" : "sink");
3175                                 return -EPROTO;
3176                         }
3177                 }
3178                 break;
3179
3180         default:
3181                 usbpd_warn(&pd->dev, "unsupported property %d\n", prop);
3182                 return -ENOTSUPP;
3183         }
3184
3185         return 0;
3186 }
3187
3188 static int usbpd_dr_prop_writeable(struct dual_role_phy_instance *dual_role,
3189                 enum dual_role_property prop)
3190 {
3191         struct usbpd *pd = dual_role_get_drvdata(dual_role);
3192
3193         switch (prop) {
3194         case DUAL_ROLE_PROP_MODE:
3195                 return 1;
3196         case DUAL_ROLE_PROP_DR:
3197         case DUAL_ROLE_PROP_PR:
3198                 if (pd)
3199                         return pd->current_state == PE_SNK_READY ||
3200                                 pd->current_state == PE_SRC_READY;
3201                 break;
3202         default:
3203                 break;
3204         }
3205
3206         return 0;
3207 }
3208
3209 static int usbpd_uevent(struct device *dev, struct kobj_uevent_env *env)
3210 {
3211         struct usbpd *pd = dev_get_drvdata(dev);
3212         int i;
3213
3214         add_uevent_var(env, "DATA_ROLE=%s", pd->current_dr == DR_DFP ?
3215                         "dfp" : "ufp");
3216
3217         if (pd->current_pr == PR_SINK) {
3218                 add_uevent_var(env, "POWER_ROLE=sink");
3219                 add_uevent_var(env, "SRC_CAP_ID=%d", pd->src_cap_id);
3220
3221                 for (i = 0; i < ARRAY_SIZE(pd->received_pdos); i++)
3222                         add_uevent_var(env, "PDO%d=%08x", i,
3223                                         pd->received_pdos[i]);
3224
3225                 add_uevent_var(env, "REQUESTED_PDO=%d", pd->requested_pdo);
3226                 add_uevent_var(env, "SELECTED_PDO=%d", pd->selected_pdo);
3227         } else {
3228                 add_uevent_var(env, "POWER_ROLE=source");
3229                 for (i = 0; i < ARRAY_SIZE(default_src_caps); i++)
3230                         add_uevent_var(env, "PDO%d=%08x", i,
3231                                         default_src_caps[i]);
3232         }
3233
3234         add_uevent_var(env, "RDO=%08x", pd->rdo);
3235         add_uevent_var(env, "CONTRACT=%s", pd->in_explicit_contract ?
3236                                 "explicit" : "implicit");
3237         add_uevent_var(env, "ALT_MODE=%d", pd->vdm_state == MODE_ENTERED);
3238
3239         add_uevent_var(env, "ADO=%08x", pd->received_ado);
3240         for (i = 0; i < PD_STATUS_DB_LEN; i++)
3241                 add_uevent_var(env, "SDB%d=%08x", i, pd->status_db[i]);
3242
3243         return 0;
3244 }
3245
3246 static ssize_t contract_show(struct device *dev, struct device_attribute *attr,
3247                 char *buf)
3248 {
3249         struct usbpd *pd = dev_get_drvdata(dev);
3250
3251         return snprintf(buf, PAGE_SIZE, "%s\n",
3252                         pd->in_explicit_contract ?  "explicit" : "implicit");
3253 }
3254 static DEVICE_ATTR_RO(contract);
3255
3256 static ssize_t current_pr_show(struct device *dev,
3257                 struct device_attribute *attr, char *buf)
3258 {
3259         struct usbpd *pd = dev_get_drvdata(dev);
3260         const char *pr = "none";
3261
3262         if (pd->current_pr == PR_SINK)
3263                 pr = "sink";
3264         else if (pd->current_pr == PR_SRC)
3265                 pr = "source";
3266
3267         return snprintf(buf, PAGE_SIZE, "%s\n", pr);
3268 }
3269 static DEVICE_ATTR_RO(current_pr);
3270
3271 static ssize_t initial_pr_show(struct device *dev,
3272                 struct device_attribute *attr, char *buf)
3273 {
3274         struct usbpd *pd = dev_get_drvdata(dev);
3275         const char *pr = "none";
3276
3277         if (pd->typec_mode >= POWER_SUPPLY_TYPEC_SOURCE_DEFAULT)
3278                 pr = "sink";
3279         else if (pd->typec_mode >= POWER_SUPPLY_TYPEC_SINK)
3280                 pr = "source";
3281
3282         return snprintf(buf, PAGE_SIZE, "%s\n", pr);
3283 }
3284 static DEVICE_ATTR_RO(initial_pr);
3285
3286 static ssize_t current_dr_show(struct device *dev,
3287                 struct device_attribute *attr, char *buf)
3288 {
3289         struct usbpd *pd = dev_get_drvdata(dev);
3290         const char *dr = "none";
3291
3292         if (pd->current_dr == DR_UFP)
3293                 dr = "ufp";
3294         else if (pd->current_dr == DR_DFP)
3295                 dr = "dfp";
3296
3297         return snprintf(buf, PAGE_SIZE, "%s\n", dr);
3298 }
3299 static DEVICE_ATTR_RO(current_dr);
3300
3301 static ssize_t initial_dr_show(struct device *dev,
3302                 struct device_attribute *attr, char *buf)
3303 {
3304         struct usbpd *pd = dev_get_drvdata(dev);
3305         const char *dr = "none";
3306
3307         if (pd->typec_mode >= POWER_SUPPLY_TYPEC_SOURCE_DEFAULT)
3308                 dr = "ufp";
3309         else if (pd->typec_mode >= POWER_SUPPLY_TYPEC_SINK)
3310                 dr = "dfp";
3311
3312         return snprintf(buf, PAGE_SIZE, "%s\n", dr);
3313 }
3314 static DEVICE_ATTR_RO(initial_dr);
3315
3316 static ssize_t src_cap_id_show(struct device *dev,
3317                 struct device_attribute *attr, char *buf)
3318 {
3319         struct usbpd *pd = dev_get_drvdata(dev);
3320
3321         return snprintf(buf, PAGE_SIZE, "%d\n", pd->src_cap_id);
3322 }
3323 static DEVICE_ATTR_RO(src_cap_id);
3324
3325 /* Dump received source PDOs in human-readable format */
3326 static ssize_t pdo_h_show(struct device *dev, struct device_attribute *attr,
3327                 char *buf)
3328 {
3329         struct usbpd *pd = dev_get_drvdata(dev);
3330         int i;
3331         ssize_t cnt = 0;
3332
3333         for (i = 0; i < ARRAY_SIZE(pd->received_pdos); i++) {
3334                 u32 pdo = pd->received_pdos[i];
3335
3336                 if (pdo == 0)
3337                         break;
3338
3339                 cnt += scnprintf(&buf[cnt], PAGE_SIZE - cnt, "PDO %d\n", i + 1);
3340
3341                 if (PD_SRC_PDO_TYPE(pdo) == PD_SRC_PDO_TYPE_FIXED) {
3342                         cnt += scnprintf(&buf[cnt], PAGE_SIZE - cnt,
3343                                         "\tFixed supply\n"
3344                                         "\tDual-Role Power:%d\n"
3345                                         "\tUSB Suspend Supported:%d\n"
3346                                         "\tExternally Powered:%d\n"
3347                                         "\tUSB Communications Capable:%d\n"
3348                                         "\tData Role Swap:%d\n"
3349                                         "\tPeak Current:%d\n"
3350                                         "\tVoltage:%d (mV)\n"
3351                                         "\tMax Current:%d (mA)\n",
3352                                         PD_SRC_PDO_FIXED_PR_SWAP(pdo),
3353                                         PD_SRC_PDO_FIXED_USB_SUSP(pdo),
3354                                         PD_SRC_PDO_FIXED_EXT_POWERED(pdo),
3355                                         PD_SRC_PDO_FIXED_USB_COMM(pdo),
3356                                         PD_SRC_PDO_FIXED_DR_SWAP(pdo),
3357                                         PD_SRC_PDO_FIXED_PEAK_CURR(pdo),
3358                                         PD_SRC_PDO_FIXED_VOLTAGE(pdo) * 50,
3359                                         PD_SRC_PDO_FIXED_MAX_CURR(pdo) * 10);
3360                 } else if (PD_SRC_PDO_TYPE(pdo) == PD_SRC_PDO_TYPE_BATTERY) {
3361                         cnt += scnprintf(&buf[cnt], PAGE_SIZE - cnt,
3362                                         "\tBattery supply\n"
3363                                         "\tMax Voltage:%d (mV)\n"
3364                                         "\tMin Voltage:%d (mV)\n"
3365                                         "\tMax Power:%d (mW)\n",
3366                                         PD_SRC_PDO_VAR_BATT_MAX_VOLT(pdo) * 50,
3367                                         PD_SRC_PDO_VAR_BATT_MIN_VOLT(pdo) * 50,
3368                                         PD_SRC_PDO_VAR_BATT_MAX(pdo) * 250);
3369                 } else if (PD_SRC_PDO_TYPE(pdo) == PD_SRC_PDO_TYPE_VARIABLE) {
3370                         cnt += scnprintf(&buf[cnt], PAGE_SIZE - cnt,
3371                                         "\tVariable supply\n"
3372                                         "\tMax Voltage:%d (mV)\n"
3373                                         "\tMin Voltage:%d (mV)\n"
3374                                         "\tMax Current:%d (mA)\n",
3375                                         PD_SRC_PDO_VAR_BATT_MAX_VOLT(pdo) * 50,
3376                                         PD_SRC_PDO_VAR_BATT_MIN_VOLT(pdo) * 50,
3377                                         PD_SRC_PDO_VAR_BATT_MAX(pdo) * 10);
3378                 } else if (PD_SRC_PDO_TYPE(pdo) == PD_SRC_PDO_TYPE_AUGMENTED) {
3379                         cnt += scnprintf(&buf[cnt], PAGE_SIZE - cnt,
3380                                         "\tProgrammable Power supply\n"
3381                                         "\tMax Voltage:%d (mV)\n"
3382                                         "\tMin Voltage:%d (mV)\n"
3383                                         "\tMax Current:%d (mA)\n",
3384                                         PD_APDO_MAX_VOLT(pdo) * 100,
3385                                         PD_APDO_MIN_VOLT(pdo) * 100,
3386                                         PD_APDO_MAX_CURR(pdo) * 50);
3387                 } else {
3388                         cnt += scnprintf(&buf[cnt], PAGE_SIZE - cnt,
3389                                         "Invalid PDO\n");
3390                 }
3391
3392                 buf[cnt++] = '\n';
3393         }
3394
3395         return cnt;
3396 }
3397 static DEVICE_ATTR_RO(pdo_h);
3398
3399 static ssize_t pdo_n_show(struct device *dev, struct device_attribute *attr,
3400                 char *buf);
3401
3402 #define PDO_ATTR(n) {                                   \
3403         .attr   = { .name = __stringify(pdo##n), .mode = S_IRUGO },     \
3404         .show   = pdo_n_show,                           \
3405 }
3406 static struct device_attribute dev_attr_pdos[] = {
3407         PDO_ATTR(1),
3408         PDO_ATTR(2),
3409         PDO_ATTR(3),
3410         PDO_ATTR(4),
3411         PDO_ATTR(5),
3412         PDO_ATTR(6),
3413         PDO_ATTR(7),
3414 };
3415
3416 static ssize_t pdo_n_show(struct device *dev, struct device_attribute *attr,
3417                 char *buf)
3418 {
3419         struct usbpd *pd = dev_get_drvdata(dev);
3420         int i;
3421
3422         for (i = 0; i < ARRAY_SIZE(dev_attr_pdos); i++)
3423                 if (attr == &dev_attr_pdos[i])
3424                         /* dump the PDO as a hex string */
3425                         return snprintf(buf, PAGE_SIZE, "%08x\n",
3426                                         pd->received_pdos[i]);
3427
3428         usbpd_err(&pd->dev, "Invalid PDO index\n");
3429         return -EINVAL;
3430 }
3431
3432 static ssize_t select_pdo_store(struct device *dev,
3433                 struct device_attribute *attr, const char *buf, size_t size)
3434 {
3435         struct usbpd *pd = dev_get_drvdata(dev);
3436         int src_cap_id;
3437         int pdo, uv = 0, ua = 0;
3438         int ret;
3439
3440         mutex_lock(&pd->swap_lock);
3441
3442         /* Only allowed if we are already in explicit sink contract */
3443         if (pd->current_state != PE_SNK_READY || !is_sink_tx_ok(pd)) {
3444                 usbpd_err(&pd->dev, "select_pdo: Cannot select new PDO yet\n");
3445                 ret = -EBUSY;
3446                 goto out;
3447         }
3448
3449         ret = sscanf(buf, "%d %d %d %d", &src_cap_id, &pdo, &uv, &ua);
3450         if (ret != 2 && ret != 4) {
3451                 usbpd_err(&pd->dev, "select_pdo: Must specify <src cap id> <PDO> [<uV> <uA>]\n");
3452                 ret = -EINVAL;
3453                 goto out;
3454         }
3455
3456         if (src_cap_id != pd->src_cap_id) {
3457                 usbpd_err(&pd->dev, "select_pdo: src_cap_id mismatch.  Requested:%d, current:%d\n",
3458                                 src_cap_id, pd->src_cap_id);
3459                 ret = -EINVAL;
3460                 goto out;
3461         }
3462
3463         if (pdo < 1 || pdo > 7) {
3464                 usbpd_err(&pd->dev, "select_pdo: invalid PDO:%d\n", pdo);
3465                 ret = -EINVAL;
3466                 goto out;
3467         }
3468
3469         ret = pd_select_pdo(pd, pdo, uv, ua);
3470         if (ret)
3471                 goto out;
3472
3473         reinit_completion(&pd->is_ready);
3474         pd->send_request = true;
3475         kick_sm(pd, 0);
3476
3477         /* wait for operation to complete */
3478         if (!wait_for_completion_timeout(&pd->is_ready,
3479                         msecs_to_jiffies(1000))) {
3480                 usbpd_err(&pd->dev, "select_pdo: request timed out\n");
3481                 ret = -ETIMEDOUT;
3482                 goto out;
3483         }
3484
3485         /* determine if request was accepted/rejected */
3486         if (pd->selected_pdo != pd->requested_pdo ||
3487                         pd->current_voltage != pd->requested_voltage) {
3488                 usbpd_err(&pd->dev, "select_pdo: request rejected\n");
3489                 ret = -EINVAL;
3490         }
3491
3492 out:
3493         pd->send_request = false;
3494         mutex_unlock(&pd->swap_lock);
3495         return ret ? ret : size;
3496 }
3497
3498 static ssize_t select_pdo_show(struct device *dev,
3499                 struct device_attribute *attr, char *buf)
3500 {
3501         struct usbpd *pd = dev_get_drvdata(dev);
3502
3503         return snprintf(buf, PAGE_SIZE, "%d\n", pd->selected_pdo);
3504 }
3505 static DEVICE_ATTR_RW(select_pdo);
3506
3507 static ssize_t rdo_show(struct device *dev, struct device_attribute *attr,
3508                 char *buf)
3509 {
3510         struct usbpd *pd = dev_get_drvdata(dev);
3511
3512         /* dump the RDO as a hex string */
3513         return snprintf(buf, PAGE_SIZE, "%08x\n", pd->rdo);
3514 }
3515 static DEVICE_ATTR_RO(rdo);
3516
3517 static ssize_t rdo_h_show(struct device *dev, struct device_attribute *attr,
3518                 char *buf)
3519 {
3520         struct usbpd *pd = dev_get_drvdata(dev);
3521         int pos = PD_RDO_OBJ_POS(pd->rdo);
3522         int type = PD_SRC_PDO_TYPE(pd->received_pdos[pos]);
3523         int len;
3524
3525         len = scnprintf(buf, PAGE_SIZE, "Request Data Object\n"
3526                         "\tObj Pos:%d\n"
3527                         "\tGiveback:%d\n"
3528                         "\tCapability Mismatch:%d\n"
3529                         "\tUSB Communications Capable:%d\n"
3530                         "\tNo USB Suspend:%d\n",
3531                         PD_RDO_OBJ_POS(pd->rdo),
3532                         PD_RDO_GIVEBACK(pd->rdo),
3533                         PD_RDO_MISMATCH(pd->rdo),
3534                         PD_RDO_USB_COMM(pd->rdo),
3535                         PD_RDO_NO_USB_SUSP(pd->rdo));
3536
3537         switch (type) {
3538         case PD_SRC_PDO_TYPE_FIXED:
3539         case PD_SRC_PDO_TYPE_VARIABLE:
3540                 len += scnprintf(buf + len, PAGE_SIZE - len,
3541                                 "(Fixed/Variable)\n"
3542                                 "\tOperating Current:%d (mA)\n"
3543                                 "\t%s Current:%d (mA)\n",
3544                                 PD_RDO_FIXED_CURR(pd->rdo) * 10,
3545                                 PD_RDO_GIVEBACK(pd->rdo) ? "Min" : "Max",
3546                                 PD_RDO_FIXED_CURR_MINMAX(pd->rdo) * 10);
3547                 break;
3548
3549         case PD_SRC_PDO_TYPE_BATTERY:
3550                 len += scnprintf(buf + len, PAGE_SIZE - len,
3551                                 "(Battery)\n"
3552                                 "\tOperating Power:%d (mW)\n"
3553                                 "\t%s Power:%d (mW)\n",
3554                                 PD_RDO_FIXED_CURR(pd->rdo) * 250,
3555                                 PD_RDO_GIVEBACK(pd->rdo) ? "Min" : "Max",
3556                                 PD_RDO_FIXED_CURR_MINMAX(pd->rdo) * 250);
3557                 break;
3558
3559         case PD_SRC_PDO_TYPE_AUGMENTED:
3560                 len += scnprintf(buf + len, PAGE_SIZE - len,
3561                                 "(Programmable)\n"
3562                                 "\tOutput Voltage:%d (mV)\n"
3563                                 "\tOperating Current:%d (mA)\n",
3564                                 PD_RDO_PROG_VOLTAGE(pd->rdo) * 20,
3565                                 PD_RDO_PROG_CURR(pd->rdo) * 50);
3566                 break;
3567         }
3568
3569         return len;
3570 }
3571 static DEVICE_ATTR_RO(rdo_h);
3572
3573 static ssize_t hard_reset_store(struct device *dev,
3574                 struct device_attribute *attr, const char *buf, size_t size)
3575 {
3576         struct usbpd *pd = dev_get_drvdata(dev);
3577         int val = 0;
3578
3579         if (sscanf(buf, "%d\n", &val) != 1)
3580                 return -EINVAL;
3581
3582         if (val)
3583                 usbpd_set_state(pd, pd->current_pr == PR_SRC ?
3584                                 PE_SRC_HARD_RESET : PE_SNK_HARD_RESET);
3585
3586         return size;
3587 }
3588 static DEVICE_ATTR_WO(hard_reset);
3589
3590 static int trigger_tx_msg(struct usbpd *pd, bool *msg_tx_flag)
3591 {
3592         int ret = 0;
3593
3594         /* Only allowed if we are already in explicit sink contract */
3595         if (pd->current_state != PE_SNK_READY || !is_sink_tx_ok(pd)) {
3596                 usbpd_err(&pd->dev, "%s: Cannot send msg\n", __func__);
3597                 ret = -EBUSY;
3598                 goto out;
3599         }
3600
3601         reinit_completion(&pd->is_ready);
3602         *msg_tx_flag = true;
3603         kick_sm(pd, 0);
3604
3605         /* wait for operation to complete */
3606         if (!wait_for_completion_timeout(&pd->is_ready,
3607                         msecs_to_jiffies(1000))) {
3608                 usbpd_err(&pd->dev, "%s: request timed out\n", __func__);
3609                 ret = -ETIMEDOUT;
3610         }
3611
3612 out:
3613         *msg_tx_flag = false;
3614         return ret;
3615
3616 }
3617
3618 static ssize_t get_src_cap_ext_show(struct device *dev,
3619                 struct device_attribute *attr, char *buf)
3620 {
3621         int i, ret, len = 0;
3622         struct usbpd *pd = dev_get_drvdata(dev);
3623
3624         if (pd->spec_rev == USBPD_REV_20)
3625                 return -EINVAL;
3626
3627         ret = trigger_tx_msg(pd, &pd->send_get_src_cap_ext);
3628         if (ret)
3629                 return ret;
3630
3631         for (i = 0; i < PD_SRC_CAP_EXT_DB_LEN; i++)
3632                 len += snprintf(buf + len, PAGE_SIZE - len, "%d\n",
3633                         pd->src_cap_ext_db[i]);
3634         return len;
3635 }
3636 static DEVICE_ATTR_RO(get_src_cap_ext);
3637
3638 static ssize_t get_pps_status_show(struct device *dev,
3639                 struct device_attribute *attr, char *buf)
3640 {
3641         int ret;
3642         struct usbpd *pd = dev_get_drvdata(dev);
3643
3644         if (pd->spec_rev == USBPD_REV_20)
3645                 return -EINVAL;
3646
3647         ret = trigger_tx_msg(pd, &pd->send_get_pps_status);
3648         if (ret)
3649                 return ret;
3650
3651         return snprintf(buf, PAGE_SIZE, "%d\n", pd->pps_status_db);
3652 }
3653 static DEVICE_ATTR_RO(get_pps_status);
3654
3655 static ssize_t rx_ado_show(struct device *dev, struct device_attribute *attr,
3656                 char *buf)
3657 {
3658         struct usbpd *pd = dev_get_drvdata(dev);
3659
3660         /* dump the ADO as a hex string */
3661         return snprintf(buf, PAGE_SIZE, "%08x\n", pd->received_ado);
3662 }
3663 static DEVICE_ATTR_RO(rx_ado);
3664
3665 static ssize_t get_battery_cap_store(struct device *dev,
3666                 struct device_attribute *attr, const char *buf, size_t size)
3667 {
3668         struct usbpd *pd = dev_get_drvdata(dev);
3669         int val, ret;
3670
3671         if (pd->spec_rev == USBPD_REV_20 || sscanf(buf, "%d\n", &val) != 1) {
3672                 pd->get_battery_cap_db = -EINVAL;
3673                 return -EINVAL;
3674         }
3675
3676         pd->get_battery_cap_db = val;
3677
3678         ret = trigger_tx_msg(pd, &pd->send_get_battery_cap);
3679
3680         return ret ? ret : size;
3681 }
3682
3683 static ssize_t get_battery_cap_show(struct device *dev,
3684                 struct device_attribute *attr, char *buf)
3685 {
3686         int i, len = 0;
3687         struct usbpd *pd = dev_get_drvdata(dev);
3688
3689         if (pd->get_battery_cap_db == -EINVAL)
3690                 return -EINVAL;
3691
3692         for (i = 0; i < PD_BATTERY_CAP_DB_LEN; i++)
3693                 len += snprintf(buf + len, PAGE_SIZE - len, "%d\n",
3694                         pd->battery_cap_db[i]);
3695         return len;
3696 }
3697 static DEVICE_ATTR_RW(get_battery_cap);
3698
3699 static ssize_t get_battery_status_store(struct device *dev,
3700                 struct device_attribute *attr, const char *buf, size_t size)
3701 {
3702         struct usbpd *pd = dev_get_drvdata(dev);
3703         int val, ret;
3704
3705         if (pd->spec_rev == USBPD_REV_20 || sscanf(buf, "%d\n", &val) != 1) {
3706                 pd->get_battery_status_db = -EINVAL;
3707                 return -EINVAL;
3708         }
3709
3710         pd->get_battery_status_db = val;
3711
3712         ret = trigger_tx_msg(pd, &pd->send_get_battery_status);
3713
3714         return ret ? ret : size;
3715 }
3716
3717 static ssize_t get_battery_status_show(struct device *dev,
3718                 struct device_attribute *attr, char *buf)
3719 {
3720         struct usbpd *pd = dev_get_drvdata(dev);
3721
3722         if (pd->get_battery_status_db == -EINVAL)
3723                 return -EINVAL;
3724
3725         return snprintf(buf, PAGE_SIZE, "%d\n", pd->battery_sts_dobj);
3726 }
3727 static DEVICE_ATTR_RW(get_battery_status);
3728
3729 static struct attribute *usbpd_attrs[] = {
3730         &dev_attr_contract.attr,
3731         &dev_attr_initial_pr.attr,
3732         &dev_attr_current_pr.attr,
3733         &dev_attr_initial_dr.attr,
3734         &dev_attr_current_dr.attr,
3735         &dev_attr_src_cap_id.attr,
3736         &dev_attr_pdo_h.attr,
3737         &dev_attr_pdos[0].attr,
3738         &dev_attr_pdos[1].attr,
3739         &dev_attr_pdos[2].attr,
3740         &dev_attr_pdos[3].attr,
3741         &dev_attr_pdos[4].attr,
3742         &dev_attr_pdos[5].attr,
3743         &dev_attr_pdos[6].attr,
3744         &dev_attr_select_pdo.attr,
3745         &dev_attr_rdo.attr,
3746         &dev_attr_rdo_h.attr,
3747         &dev_attr_hard_reset.attr,
3748         &dev_attr_get_src_cap_ext.attr,
3749         &dev_attr_get_pps_status.attr,
3750         &dev_attr_rx_ado.attr,
3751         &dev_attr_get_battery_cap.attr,
3752         &dev_attr_get_battery_status.attr,
3753         NULL,
3754 };
3755 ATTRIBUTE_GROUPS(usbpd);
3756
3757 static struct class usbpd_class = {
3758         .name = "usbpd",
3759         .owner = THIS_MODULE,
3760         .dev_uevent = usbpd_uevent,
3761         .dev_groups = usbpd_groups,
3762 };
3763
3764 static int match_usbpd_device(struct device *dev, const void *data)
3765 {
3766         return dev->parent == data;
3767 }
3768
3769 static void devm_usbpd_put(struct device *dev, void *res)
3770 {
3771         struct usbpd **ppd = res;
3772
3773         put_device(&(*ppd)->dev);
3774 }
3775
3776 struct usbpd *devm_usbpd_get_by_phandle(struct device *dev, const char *phandle)
3777 {
3778         struct usbpd **ptr, *pd = NULL;
3779         struct device_node *pd_np;
3780         struct platform_device *pdev;
3781         struct device *pd_dev;
3782
3783         if (!usbpd_class.p) /* usbpd_init() not yet called */
3784                 return ERR_PTR(-EAGAIN);
3785
3786         if (!dev->of_node)
3787                 return ERR_PTR(-EINVAL);
3788
3789         pd_np = of_parse_phandle(dev->of_node, phandle, 0);
3790         if (!pd_np)
3791                 return ERR_PTR(-ENXIO);
3792
3793         pdev = of_find_device_by_node(pd_np);
3794         if (!pdev)
3795                 return ERR_PTR(-ENODEV);
3796
3797         pd_dev = class_find_device(&usbpd_class, NULL, &pdev->dev,
3798                         match_usbpd_device);
3799         if (!pd_dev) {
3800                 platform_device_put(pdev);
3801                 /* device was found but maybe hadn't probed yet, so defer */
3802                 return ERR_PTR(-EPROBE_DEFER);
3803         }
3804
3805         ptr = devres_alloc(devm_usbpd_put, sizeof(*ptr), GFP_KERNEL);
3806         if (!ptr) {
3807                 put_device(pd_dev);
3808                 platform_device_put(pdev);
3809                 return ERR_PTR(-ENOMEM);
3810         }
3811
3812         pd = dev_get_drvdata(pd_dev);
3813         if (!pd)
3814                 return ERR_PTR(-EPROBE_DEFER);
3815
3816         *ptr = pd;
3817         devres_add(dev, ptr);
3818
3819         return pd;
3820 }
3821 EXPORT_SYMBOL(devm_usbpd_get_by_phandle);
3822
3823 static int num_pd_instances;
3824
3825 /**
3826  * usbpd_create - Create a new instance of USB PD protocol/policy engine
3827  * @parent - parent device to associate with
3828  *
3829  * This creates a new usbpd class device which manages the state of a
3830  * USB PD-capable port. The parent device that is passed in should be
3831  * associated with the physical device port, e.g. a PD PHY.
3832  *
3833  * Return: struct usbpd pointer, or an ERR_PTR value
3834  */
3835 struct usbpd *usbpd_create(struct device *parent)
3836 {
3837         int ret;
3838         struct usbpd *pd;
3839
3840         pd = kzalloc(sizeof(*pd), GFP_KERNEL);
3841         if (!pd)
3842                 return ERR_PTR(-ENOMEM);
3843
3844         device_initialize(&pd->dev);
3845         pd->dev.class = &usbpd_class;
3846         pd->dev.parent = parent;
3847         dev_set_drvdata(&pd->dev, pd);
3848
3849         ret = dev_set_name(&pd->dev, "usbpd%d", num_pd_instances++);
3850         if (ret)
3851                 goto free_pd;
3852
3853         ret = device_init_wakeup(&pd->dev, true);
3854         if (ret)
3855                 goto free_pd;
3856
3857         ret = device_add(&pd->dev);
3858         if (ret)
3859                 goto free_pd;
3860
3861         pd->wq = alloc_ordered_workqueue("usbpd_wq", WQ_FREEZABLE | WQ_HIGHPRI);
3862         if (!pd->wq) {
3863                 ret = -ENOMEM;
3864                 goto del_pd;
3865         }
3866         INIT_WORK(&pd->sm_work, usbpd_sm);
3867         hrtimer_init(&pd->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
3868         pd->timer.function = pd_timeout;
3869         mutex_init(&pd->swap_lock);
3870
3871         pd->usb_psy = power_supply_get_by_name("usb");
3872         if (!pd->usb_psy) {
3873                 usbpd_dbg(&pd->dev, "Could not get USB power_supply, deferring probe\n");
3874                 ret = -EPROBE_DEFER;
3875                 goto destroy_wq;
3876         }
3877
3878         /*
3879          * associate extcon with the parent dev as it could have a DT
3880          * node which will be useful for extcon_get_edev_by_phandle()
3881          */
3882         pd->extcon = devm_extcon_dev_allocate(parent, usbpd_extcon_cable);
3883         if (IS_ERR(pd->extcon)) {
3884                 usbpd_err(&pd->dev, "failed to allocate extcon device\n");
3885                 ret = PTR_ERR(pd->extcon);
3886                 goto put_psy;
3887         }
3888
3889         pd->extcon->mutually_exclusive = usbpd_extcon_exclusive;
3890         ret = devm_extcon_dev_register(parent, pd->extcon);
3891         if (ret) {
3892                 usbpd_err(&pd->dev, "failed to register extcon device\n");
3893                 goto put_psy;
3894         }
3895
3896         pd->vbus = devm_regulator_get(parent, "vbus");
3897         if (IS_ERR(pd->vbus)) {
3898                 ret = PTR_ERR(pd->vbus);
3899                 goto put_psy;
3900         }
3901
3902         pd->vconn = devm_regulator_get(parent, "vconn");
3903         if (IS_ERR(pd->vconn)) {
3904                 ret = PTR_ERR(pd->vconn);
3905                 goto put_psy;
3906         }
3907
3908         pd->vconn_is_external = device_property_present(parent,
3909                                         "qcom,vconn-uses-external-source");
3910
3911         pd->num_sink_caps = device_property_read_u32_array(parent,
3912                         "qcom,default-sink-caps", NULL, 0);
3913         if (pd->num_sink_caps > 0) {
3914                 int i;
3915                 u32 sink_caps[14];
3916
3917                 if (pd->num_sink_caps % 2 || pd->num_sink_caps > 14) {
3918                         ret = -EINVAL;
3919                         usbpd_err(&pd->dev, "default-sink-caps must be be specified as voltage/current, max 7 pairs\n");
3920                         goto put_psy;
3921                 }
3922
3923                 ret = device_property_read_u32_array(parent,
3924                                 "qcom,default-sink-caps", sink_caps,
3925                                 pd->num_sink_caps);
3926                 if (ret) {
3927                         usbpd_err(&pd->dev, "Error reading default-sink-caps\n");
3928                         goto put_psy;
3929                 }
3930
3931                 pd->num_sink_caps /= 2;
3932
3933                 for (i = 0; i < pd->num_sink_caps; i++) {
3934                         int v = sink_caps[i * 2] / 50;
3935                         int c = sink_caps[i * 2 + 1] / 10;
3936
3937                         pd->sink_caps[i] =
3938                                 PD_SNK_PDO_FIXED(0, 0, 0, 0, 0, v, c);
3939                 }
3940
3941                 /* First PDO includes additional capabilities */
3942                 pd->sink_caps[0] |= PD_SNK_PDO_FIXED(1, 0, 0, 1, 1, 0, 0);
3943         } else {
3944                 memcpy(pd->sink_caps, default_snk_caps,
3945                                 sizeof(default_snk_caps));
3946                 pd->num_sink_caps = ARRAY_SIZE(default_snk_caps);
3947         }
3948
3949         /*
3950          * Register the Android dual-role class (/sys/class/dual_role_usb/).
3951          * The first instance should be named "otg_default" as that's what
3952          * Android expects.
3953          * Note this is different than the /sys/class/usbpd/ created above.
3954          */
3955         pd->dr_desc.name = (num_pd_instances == 1) ?
3956                                 "otg_default" : dev_name(&pd->dev);
3957         pd->dr_desc.supported_modes = DUAL_ROLE_SUPPORTED_MODES_DFP_AND_UFP;
3958         pd->dr_desc.properties = usbpd_dr_properties;
3959         pd->dr_desc.num_properties = ARRAY_SIZE(usbpd_dr_properties);
3960         pd->dr_desc.get_property = usbpd_dr_get_property;
3961         pd->dr_desc.set_property = usbpd_dr_set_property;
3962         pd->dr_desc.property_is_writeable = usbpd_dr_prop_writeable;
3963
3964         pd->dual_role = devm_dual_role_instance_register(&pd->dev,
3965                         &pd->dr_desc);
3966         if (IS_ERR(pd->dual_role)) {
3967                 usbpd_err(&pd->dev, "could not register dual_role instance\n");
3968                 goto put_psy;
3969         } else {
3970                 pd->dual_role->drv_data = pd;
3971         }
3972
3973         pd->current_pr = PR_NONE;
3974         pd->current_dr = DR_NONE;
3975         list_add_tail(&pd->instance, &_usbpd);
3976
3977         spin_lock_init(&pd->rx_lock);
3978         INIT_LIST_HEAD(&pd->rx_q);
3979         INIT_LIST_HEAD(&pd->svid_handlers);
3980         init_completion(&pd->is_ready);
3981         init_completion(&pd->tx_chunk_request);
3982
3983         pd->psy_nb.notifier_call = psy_changed;
3984         ret = power_supply_reg_notifier(&pd->psy_nb);
3985         if (ret)
3986                 goto del_inst;
3987
3988         /* force read initial power_supply values */
3989         psy_changed(&pd->psy_nb, PSY_EVENT_PROP_CHANGED, pd->usb_psy);
3990
3991         return pd;
3992
3993 del_inst:
3994         list_del(&pd->instance);
3995 put_psy:
3996         power_supply_put(pd->usb_psy);
3997 destroy_wq:
3998         destroy_workqueue(pd->wq);
3999 del_pd:
4000         device_del(&pd->dev);
4001 free_pd:
4002         num_pd_instances--;
4003         kfree(pd);
4004         return ERR_PTR(ret);
4005 }
4006 EXPORT_SYMBOL(usbpd_create);
4007
4008 /**
4009  * usbpd_destroy - Removes and frees a usbpd instance
4010  * @pd: the instance to destroy
4011  */
4012 void usbpd_destroy(struct usbpd *pd)
4013 {
4014         if (!pd)
4015                 return;
4016
4017         list_del(&pd->instance);
4018         power_supply_unreg_notifier(&pd->psy_nb);
4019         power_supply_put(pd->usb_psy);
4020         destroy_workqueue(pd->wq);
4021         device_del(&pd->dev);
4022         kfree(pd);
4023 }
4024 EXPORT_SYMBOL(usbpd_destroy);
4025
4026 static int __init usbpd_init(void)
4027 {
4028         usbpd_ipc_log = ipc_log_context_create(NUM_LOG_PAGES, "usb_pd", 0);
4029         return class_register(&usbpd_class);
4030 }
4031 module_init(usbpd_init);
4032
4033 static void __exit usbpd_exit(void)
4034 {
4035         class_unregister(&usbpd_class);
4036 }
4037 module_exit(usbpd_exit);
4038
4039 MODULE_DESCRIPTION("USB Power Delivery Policy Engine");
4040 MODULE_LICENSE("GPL v2");