drivers/usb/typec/tcpm/fusb302.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright 2016-2017 Google, Inc
   4  *
   5  * Fairchild FUSB302 Type-C Chip Driver
   6  */
   7
   8 #include <linux/debugfs.h>
   9 #include <linux/delay.h>
  10 #include <linux/errno.h>
  11 #include <linux/extcon.h>
  12 #include <linux/gpio/consumer.h>
  13 #include <linux/i2c.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/kernel.h>
  16 #include <linux/module.h>
  17 #include <linux/mutex.h>
  18 #include <linux/of.h>
  19 #include <linux/pinctrl/consumer.h>
  20 #include <linux/proc_fs.h>
  21 #include <linux/regulator/consumer.h>
  22 #include <linux/sched/clock.h>
  23 #include <linux/seq_file.h>
  24 #include <linux/slab.h>
  25 #include <linux/spinlock.h>
  26 #include <linux/string.h>
  27 #include <linux/string_choices.h>
  28 #include <linux/types.h>
  29 #include <linux/usb.h>
  30 #include <linux/usb/typec.h>
  31 #include <linux/usb/tcpm.h>
  32 #include <linux/usb/pd.h>
  33 #include <linux/workqueue.h>
  34
  35 #include "fusb302_reg.h"
  36
  37 /*
  38  * When the device is SNK, BC_LVL interrupt is used to monitor cc pins
  39  * for the current capability offered by the SRC. As FUSB302 chip fires
  40  * the BC_LVL interrupt on PD signalings, cc lvl should be handled after
  41  * a delay to avoid measuring on PD activities. The delay is slightly
  42  * longer than PD_T_PD_DEBPUNCE (10-20ms).
  43  */
  44 #define T_BC_LVL_DEBOUNCE_DELAY_MS 30
  45
  46 enum toggling_mode {
  47         TOGGLING_MODE_OFF,
  48         TOGGLING_MODE_DRP,
  49         TOGGLING_MODE_SNK,
  50         TOGGLING_MODE_SRC,
  51 };
  52
  53 enum src_current_status {
  54         SRC_CURRENT_DEFAULT,
  55         SRC_CURRENT_MEDIUM,
  56         SRC_CURRENT_HIGH,
  57 };
  58
  59 static const u8 ra_mda_value[] = {
  60         [SRC_CURRENT_DEFAULT] = 4,      /* 210mV */
  61         [SRC_CURRENT_MEDIUM] = 9,       /* 420mV */
  62         [SRC_CURRENT_HIGH] = 18,        /* 798mV */
  63 };
  64
  65 static const u8 rd_mda_value[] = {
  66         [SRC_CURRENT_DEFAULT] = 38,     /* 1638mV */
  67         [SRC_CURRENT_MEDIUM] = 38,      /* 1638mV */
  68         [SRC_CURRENT_HIGH] = 61,        /* 2604mV */
  69 };
  70
  71 #define LOG_BUFFER_ENTRIES      1024
  72 #define LOG_BUFFER_ENTRY_SIZE   128
  73
  74 struct fusb302_chip {
  75         struct device *dev;
  76         struct i2c_client *i2c_client;
  77         struct tcpm_port *tcpm_port;
  78         struct tcpc_dev tcpc_dev;
  79
  80         struct regulator *vbus;
  81
  82         spinlock_t irq_lock;
  83         struct work_struct irq_work;
  84         bool irq_suspended;
  85         bool irq_while_suspended;
  86         struct gpio_desc *gpio_int_n;
  87         int gpio_int_n_irq;
  88         struct extcon_dev *extcon;
  89
  90         struct workqueue_struct *wq;
  91         struct delayed_work bc_lvl_handler;
  92
  93         /* lock for sharing chip states */
  94         struct mutex lock;
  95
  96         /* chip status */
  97         enum toggling_mode toggling_mode;
  98         enum src_current_status src_current_status;
  99         bool intr_togdone;
 100         bool intr_bc_lvl;
 101         bool intr_comp_chng;
 102
 103         /* port status */
 104         bool vconn_on;
 105         bool vbus_on;
 106         bool charge_on;
 107         bool vbus_present;
 108         enum typec_cc_polarity cc_polarity;
 109         enum typec_cc_status cc1;
 110         enum typec_cc_status cc2;
 111         u32 snk_pdo[PDO_MAX_OBJECTS];
 112
 113 #ifdef CONFIG_DEBUG_FS
 114         struct dentry *dentry;
 115         /* lock for log buffer access */
 116         struct mutex logbuffer_lock;
 117         int logbuffer_head;
 118         int logbuffer_tail;
 119         u8 *logbuffer[LOG_BUFFER_ENTRIES];
 120 #endif
 121 };
 122
 123 /*
 124  * Logging
 125  */
 126
 127 #ifdef CONFIG_DEBUG_FS
 128 static bool fusb302_log_full(struct fusb302_chip *chip)
 129 {
 130         return chip->logbuffer_tail ==
 131                 (chip->logbuffer_head + 1) % LOG_BUFFER_ENTRIES;
 132 }
 133
 134 __printf(2, 0)
 135 static void _fusb302_log(struct fusb302_chip *chip, const char *fmt,
 136                          va_list args)
 137 {
 138         char tmpbuffer[LOG_BUFFER_ENTRY_SIZE];
 139         u64 ts_nsec = local_clock();
 140         unsigned long rem_nsec;
 141
 142         if (!chip->logbuffer[chip->logbuffer_head]) {
 143                 chip->logbuffer[chip->logbuffer_head] =
 144                                 kzalloc(LOG_BUFFER_ENTRY_SIZE, GFP_KERNEL);
 145                 if (!chip->logbuffer[chip->logbuffer_head])
 146                         return;
 147         }
 148
 149         vsnprintf(tmpbuffer, sizeof(tmpbuffer), fmt, args);
 150
 151         mutex_lock(&chip->logbuffer_lock);
 152
 153         if (fusb302_log_full(chip)) {
 154                 chip->logbuffer_head = max(chip->logbuffer_head - 1, 0);
 155                 strscpy(tmpbuffer, "overflow", sizeof(tmpbuffer));
 156         }
 157
 158         if (chip->logbuffer_head < 0 ||
 159             chip->logbuffer_head >= LOG_BUFFER_ENTRIES) {
 160                 dev_warn(chip->dev,
 161                          "Bad log buffer index %d\n", chip->logbuffer_head);
 162                 goto abort;
 163         }
 164
 165         if (!chip->logbuffer[chip->logbuffer_head]) {
 166                 dev_warn(chip->dev,
 167                          "Log buffer index %d is NULL\n", chip->logbuffer_head);
 168                 goto abort;
 169         }
 170
 171         rem_nsec = do_div(ts_nsec, 1000000000);
 172         scnprintf(chip->logbuffer[chip->logbuffer_head],
 173                   LOG_BUFFER_ENTRY_SIZE, "[%5lu.%06lu] %s",
 174                   (unsigned long)ts_nsec, rem_nsec / 1000,
 175                   tmpbuffer);
 176         chip->logbuffer_head = (chip->logbuffer_head + 1) % LOG_BUFFER_ENTRIES;
 177
 178 abort:
 179         mutex_unlock(&chip->logbuffer_lock);
 180 }
 181
 182 __printf(2, 3)
 183 static void fusb302_log(struct fusb302_chip *chip, const char *fmt, ...)
 184 {
 185         va_list args;
 186
 187         va_start(args, fmt);
 188         _fusb302_log(chip, fmt, args);
 189         va_end(args);
 190 }
 191
 192 static int fusb302_debug_show(struct seq_file *s, void *v)
 193 {
 194         struct fusb302_chip *chip = s->private;
 195         int tail;
 196
 197         mutex_lock(&chip->logbuffer_lock);
 198         tail = chip->logbuffer_tail;
 199         while (tail != chip->logbuffer_head) {
 200                 seq_printf(s, "%s\n", chip->logbuffer[tail]);
 201                 tail = (tail + 1) % LOG_BUFFER_ENTRIES;
 202         }
 203         if (!seq_has_overflowed(s))
 204                 chip->logbuffer_tail = tail;
 205         mutex_unlock(&chip->logbuffer_lock);
 206
 207         return 0;
 208 }
 209 DEFINE_SHOW_ATTRIBUTE(fusb302_debug);
 210
 211 static void fusb302_debugfs_init(struct fusb302_chip *chip)
 212 {
 213         char name[NAME_MAX];
 214
 215         mutex_init(&chip->logbuffer_lock);
 216         snprintf(name, NAME_MAX, "fusb302-%s", dev_name(chip->dev));
 217         chip->dentry = debugfs_create_dir(name, usb_debug_root);
 218         debugfs_create_file("log", S_IFREG | 0444, chip->dentry, chip,
 219                             &fusb302_debug_fops);
 220 }
 221
 222 static void fusb302_debugfs_exit(struct fusb302_chip *chip)
 223 {
 224         debugfs_remove(chip->dentry);
 225 }
 226
 227 #else
 228
 229 static void fusb302_log(const struct fusb302_chip *chip,
 230                         const char *fmt, ...) { }
 231 static void fusb302_debugfs_init(const struct fusb302_chip *chip) { }
 232 static void fusb302_debugfs_exit(const struct fusb302_chip *chip) { }
 233
 234 #endif
 235
 236 static int fusb302_i2c_write(struct fusb302_chip *chip,
 237                              u8 address, u8 data)
 238 {
 239         int ret = 0;
 240
 241         ret = i2c_smbus_write_byte_data(chip->i2c_client, address, data);
 242         if (ret < 0)
 243                 fusb302_log(chip, "cannot write 0x%02x to 0x%02x, ret=%d",
 244                             data, address, ret);
 245
 246         return ret;
 247 }
 248
 249 static int fusb302_i2c_block_write(struct fusb302_chip *chip, u8 address,
 250                                    u8 length, const u8 *data)
 251 {
 252         int ret = 0;
 253
 254         if (length <= 0)
 255                 return ret;
 256
 257         ret = i2c_smbus_write_i2c_block_data(chip->i2c_client, address,
 258                                              length, data);
 259         if (ret < 0)
 260                 fusb302_log(chip, "cannot block write 0x%02x, len=%d, ret=%d",
 261                             address, length, ret);
 262
 263         return ret;
 264 }
 265
 266 static int fusb302_i2c_read(struct fusb302_chip *chip,
 267                             u8 address, u8 *data)
 268 {
 269         int ret = 0;
 270
 271         ret = i2c_smbus_read_byte_data(chip->i2c_client, address);
 272         *data = (u8)ret;
 273         if (ret < 0)
 274                 fusb302_log(chip, "cannot read %02x, ret=%d", address, ret);
 275
 276         return ret;
 277 }
 278
 279 static int fusb302_i2c_block_read(struct fusb302_chip *chip, u8 address,
 280                                   u8 length, u8 *data)
 281 {
 282         int ret = 0;
 283
 284         if (length <= 0)
 285                 return ret;
 286
 287         ret = i2c_smbus_read_i2c_block_data(chip->i2c_client, address,
 288                                             length, data);
 289         if (ret < 0) {
 290                 fusb302_log(chip, "cannot block read 0x%02x, len=%d, ret=%d",
 291                             address, length, ret);
 292                 goto done;
 293         }
 294         if (ret != length) {
 295                 fusb302_log(chip, "only read %d/%d bytes from 0x%02x",
 296                             ret, length, address);
 297                 ret = -EIO;
 298         }
 299
 300 done:
 301         return ret;
 302 }
 303
 304 static int fusb302_i2c_mask_write(struct fusb302_chip *chip, u8 address,
 305                                   u8 mask, u8 value)
 306 {
 307         int ret = 0;
 308         u8 data;
 309
 310         ret = fusb302_i2c_read(chip, address, &data);
 311         if (ret < 0)
 312                 return ret;
 313         data &= ~mask;
 314         data |= value;
 315         ret = fusb302_i2c_write(chip, address, data);
 316         if (ret < 0)
 317                 return ret;
 318
 319         return ret;
 320 }
 321
 322 static int fusb302_i2c_set_bits(struct fusb302_chip *chip, u8 address,
 323                                 u8 set_bits)
 324 {
 325         return fusb302_i2c_mask_write(chip, address, 0x00, set_bits);
 326 }
 327
 328 static int fusb302_i2c_clear_bits(struct fusb302_chip *chip, u8 address,
 329                                   u8 clear_bits)
 330 {
 331         return fusb302_i2c_mask_write(chip, address, clear_bits, 0x00);
 332 }
 333
 334 static int fusb302_sw_reset(struct fusb302_chip *chip)
 335 {
 336         int ret = 0;
 337
 338         ret = fusb302_i2c_write(chip, FUSB_REG_RESET,
 339                                 FUSB_REG_RESET_SW_RESET);
 340         if (ret < 0)
 341                 fusb302_log(chip, "cannot sw reset the chip, ret=%d", ret);
 342         else
 343                 fusb302_log(chip, "sw reset");
 344
 345         return ret;
 346 }
 347
 348 static int fusb302_enable_tx_auto_retries(struct fusb302_chip *chip, u8 retry_count)
 349 {
 350         int ret = 0;
 351
 352         ret = fusb302_i2c_set_bits(chip, FUSB_REG_CONTROL3, retry_count |
 353                                    FUSB_REG_CONTROL3_AUTO_RETRY);
 354
 355         return ret;
 356 }
 357
 358 /*
 359  * initialize interrupt on the chip
 360  * - unmasked interrupt: VBUS_OK
 361  */
 362 static int fusb302_init_interrupt(struct fusb302_chip *chip)
 363 {
 364         int ret = 0;
 365
 366         ret = fusb302_i2c_write(chip, FUSB_REG_MASK,
 367                                 0xFF & ~FUSB_REG_MASK_VBUSOK);
 368         if (ret < 0)
 369                 return ret;
 370         ret = fusb302_i2c_write(chip, FUSB_REG_MASKA, 0xFF);
 371         if (ret < 0)
 372                 return ret;
 373         ret = fusb302_i2c_write(chip, FUSB_REG_MASKB, 0xFF);
 374         if (ret < 0)
 375                 return ret;
 376         ret = fusb302_i2c_clear_bits(chip, FUSB_REG_CONTROL0,
 377                                      FUSB_REG_CONTROL0_INT_MASK);
 378         if (ret < 0)
 379                 return ret;
 380
 381         return ret;
 382 }
 383
 384 static int fusb302_set_power_mode(struct fusb302_chip *chip, u8 power_mode)
 385 {
 386         int ret = 0;
 387
 388         ret = fusb302_i2c_write(chip, FUSB_REG_POWER, power_mode);
 389
 390         return ret;
 391 }
 392
 393 static int tcpm_init(struct tcpc_dev *dev)
 394 {
 395         struct fusb302_chip *chip = container_of(dev, struct fusb302_chip,
 396                                                  tcpc_dev);
 397         int ret = 0;
 398         u8 data;
 399
 400         ret = fusb302_sw_reset(chip);
 401         if (ret < 0)
 402                 return ret;
 403         ret = fusb302_enable_tx_auto_retries(chip, FUSB_REG_CONTROL3_N_RETRIES_3);
 404         if (ret < 0)
 405                 return ret;
 406         ret = fusb302_init_interrupt(chip);
 407         if (ret < 0)
 408                 return ret;
 409         ret = fusb302_set_power_mode(chip, FUSB_REG_POWER_PWR_ALL);
 410         if (ret < 0)
 411                 return ret;
 412         ret = fusb302_i2c_read(chip, FUSB_REG_STATUS0, &data);
 413         if (ret < 0)
 414                 return ret;
 415         chip->vbus_present = !!(data & FUSB_REG_STATUS0_VBUSOK);
 416         ret = fusb302_i2c_read(chip, FUSB_REG_DEVICE_ID, &data);
 417         if (ret < 0)
 418                 return ret;
 419         fusb302_log(chip, "fusb302 device ID: 0x%02x", data);
 420
 421         return ret;
 422 }
 423
 424 static int tcpm_get_vbus(struct tcpc_dev *dev)
 425 {
 426         struct fusb302_chip *chip = container_of(dev, struct fusb302_chip,
 427                                                  tcpc_dev);
 428         int ret = 0;
 429
 430         mutex_lock(&chip->lock);
 431         ret = chip->vbus_present ? 1 : 0;
 432         mutex_unlock(&chip->lock);
 433
 434         return ret;
 435 }
 436
 437 static int tcpm_get_current_limit(struct tcpc_dev *dev)
 438 {
 439         struct fusb302_chip *chip = container_of(dev, struct fusb302_chip,
 440                                                  tcpc_dev);
 441         int current_limit = 0;
 442         unsigned long timeout;
 443
 444         if (!chip->extcon)
 445                 return 0;
 446
 447         /*
 448          * USB2 Charger detection may still be in progress when we get here,
 449          * this can take upto 600ms, wait 800ms max.
 450          */
 451         timeout = jiffies + msecs_to_jiffies(800);
 452         do {
 453                 if (extcon_get_state(chip->extcon, EXTCON_CHG_USB_SDP) == 1)
 454                         current_limit = 500;
 455
 456                 if (extcon_get_state(chip->extcon, EXTCON_CHG_USB_CDP) == 1 ||
 457                     extcon_get_state(chip->extcon, EXTCON_CHG_USB_ACA) == 1)
 458                         current_limit = 1500;
 459
 460                 if (extcon_get_state(chip->extcon, EXTCON_CHG_USB_DCP) == 1)
 461                         current_limit = 2000;
 462
 463                 msleep(50);
 464         } while (current_limit == 0 && time_before(jiffies, timeout));
 465
 466         return current_limit;
 467 }
 468
 469 static int fusb302_set_src_current(struct fusb302_chip *chip,
 470                                    enum src_current_status status)
 471 {
 472         int ret = 0;
 473
 474         chip->src_current_status = status;
 475         switch (status) {
 476         case SRC_CURRENT_DEFAULT:
 477                 ret = fusb302_i2c_mask_write(chip, FUSB_REG_CONTROL0,
 478                                              FUSB_REG_CONTROL0_HOST_CUR_MASK,
 479                                              FUSB_REG_CONTROL0_HOST_CUR_DEF);
 480                 break;
 481         case SRC_CURRENT_MEDIUM:
 482                 ret = fusb302_i2c_mask_write(chip, FUSB_REG_CONTROL0,
 483                                              FUSB_REG_CONTROL0_HOST_CUR_MASK,
 484                                              FUSB_REG_CONTROL0_HOST_CUR_MED);
 485                 break;
 486         case SRC_CURRENT_HIGH:
 487                 ret = fusb302_i2c_mask_write(chip, FUSB_REG_CONTROL0,
 488                                              FUSB_REG_CONTROL0_HOST_CUR_MASK,
 489                                              FUSB_REG_CONTROL0_HOST_CUR_HIGH);
 490                 break;
 491         default:
 492                 break;
 493         }
 494
 495         return ret;
 496 }
 497
 498 static int fusb302_set_toggling(struct fusb302_chip *chip,
 499                                 enum toggling_mode mode)
 500 {
 501         int ret = 0;
 502
 503         /* first disable toggling */
 504         ret = fusb302_i2c_clear_bits(chip, FUSB_REG_CONTROL2,
 505                                      FUSB_REG_CONTROL2_TOGGLE);
 506         if (ret < 0)
 507                 return ret;
 508         /* mask interrupts for SRC or SNK */
 509         ret = fusb302_i2c_set_bits(chip, FUSB_REG_MASK,
 510                                    FUSB_REG_MASK_BC_LVL |
 511                                    FUSB_REG_MASK_COMP_CHNG);
 512         if (ret < 0)
 513                 return ret;
 514         chip->intr_bc_lvl = false;
 515         chip->intr_comp_chng = false;
 516         /* configure toggling mode: none/snk/src/drp */
 517         switch (mode) {
 518         case TOGGLING_MODE_OFF:
 519                 ret = fusb302_i2c_mask_write(chip, FUSB_REG_CONTROL2,
 520                                              FUSB_REG_CONTROL2_MODE_MASK,
 521                                              FUSB_REG_CONTROL2_MODE_NONE);
 522                 if (ret < 0)
 523                         return ret;
 524                 break;
 525         case TOGGLING_MODE_SNK:
 526                 ret = fusb302_i2c_mask_write(chip, FUSB_REG_CONTROL2,
 527                                              FUSB_REG_CONTROL2_MODE_MASK,
 528                                              FUSB_REG_CONTROL2_MODE_UFP);
 529                 if (ret < 0)
 530                         return ret;
 531                 break;
 532         case TOGGLING_MODE_SRC:
 533                 ret = fusb302_i2c_mask_write(chip, FUSB_REG_CONTROL2,
 534                                              FUSB_REG_CONTROL2_MODE_MASK,
 535                                              FUSB_REG_CONTROL2_MODE_DFP);
 536                 if (ret < 0)
 537                         return ret;
 538                 break;
 539         case TOGGLING_MODE_DRP:
 540                 ret = fusb302_i2c_mask_write(chip, FUSB_REG_CONTROL2,
 541                                              FUSB_REG_CONTROL2_MODE_MASK,
 542                                              FUSB_REG_CONTROL2_MODE_DRP);
 543                 if (ret < 0)
 544                         return ret;
 545                 break;
 546         default:
 547                 break;
 548         }
 549
 550         if (mode == TOGGLING_MODE_OFF) {
 551                 /* mask TOGDONE interrupt */
 552                 ret = fusb302_i2c_set_bits(chip, FUSB_REG_MASKA,
 553                                            FUSB_REG_MASKA_TOGDONE);
 554                 if (ret < 0)
 555                         return ret;
 556                 chip->intr_togdone = false;
 557         } else {
 558                 /* Datasheet says vconn MUST be off when toggling */
 559                 WARN(chip->vconn_on, "Vconn is on during toggle start");
 560                 /* unmask TOGDONE interrupt */
 561                 ret = fusb302_i2c_clear_bits(chip, FUSB_REG_MASKA,
 562                                              FUSB_REG_MASKA_TOGDONE);
 563                 if (ret < 0)
 564                         return ret;
 565                 chip->intr_togdone = true;
 566                 /* start toggling */
 567                 ret = fusb302_i2c_set_bits(chip, FUSB_REG_CONTROL2,
 568                                            FUSB_REG_CONTROL2_TOGGLE);
 569                 if (ret < 0)
 570                         return ret;
 571                 /* during toggling, consider cc as Open */
 572                 chip->cc1 = TYPEC_CC_OPEN;
 573                 chip->cc2 = TYPEC_CC_OPEN;
 574         }
 575         chip->toggling_mode = mode;
 576
 577         return ret;
 578 }
 579
 580 static const char * const typec_cc_status_name[] = {
 581         [TYPEC_CC_OPEN]         = "Open",
 582         [TYPEC_CC_RA]           = "Ra",
 583         [TYPEC_CC_RD]           = "Rd",
 584         [TYPEC_CC_RP_DEF]       = "Rp-def",
 585         [TYPEC_CC_RP_1_5]       = "Rp-1.5",
 586         [TYPEC_CC_RP_3_0]       = "Rp-3.0",
 587 };
 588
 589 static const enum src_current_status cc_src_current[] = {
 590         [TYPEC_CC_OPEN]         = SRC_CURRENT_DEFAULT,
 591         [TYPEC_CC_RA]           = SRC_CURRENT_DEFAULT,
 592         [TYPEC_CC_RD]           = SRC_CURRENT_DEFAULT,
 593         [TYPEC_CC_RP_DEF]       = SRC_CURRENT_DEFAULT,
 594         [TYPEC_CC_RP_1_5]       = SRC_CURRENT_MEDIUM,
 595         [TYPEC_CC_RP_3_0]       = SRC_CURRENT_HIGH,
 596 };
 597
 598 static int tcpm_set_cc(struct tcpc_dev *dev, enum typec_cc_status cc)
 599 {
 600         struct fusb302_chip *chip = container_of(dev, struct fusb302_chip,
 601                                                  tcpc_dev);
 602         u8 switches0_mask = FUSB_REG_SWITCHES0_CC1_PU_EN |
 603                             FUSB_REG_SWITCHES0_CC2_PU_EN |
 604                             FUSB_REG_SWITCHES0_CC1_PD_EN |
 605                             FUSB_REG_SWITCHES0_CC2_PD_EN;
 606         u8 rd_mda, switches0_data = 0x00;
 607         int ret = 0;
 608
 609         mutex_lock(&chip->lock);
 610         switch (cc) {
 611         case TYPEC_CC_OPEN:
 612                 break;
 613         case TYPEC_CC_RD:
 614                 switches0_data |= FUSB_REG_SWITCHES0_CC1_PD_EN |
 615                                   FUSB_REG_SWITCHES0_CC2_PD_EN;
 616                 break;
 617         case TYPEC_CC_RP_DEF:
 618         case TYPEC_CC_RP_1_5:
 619         case TYPEC_CC_RP_3_0:
 620                 switches0_data |= (chip->cc_polarity == TYPEC_POLARITY_CC1) ?
 621                                   FUSB_REG_SWITCHES0_CC1_PU_EN :
 622                                   FUSB_REG_SWITCHES0_CC2_PU_EN;
 623                 break;
 624         default:
 625                 fusb302_log(chip, "unsupported cc value %s",
 626                             typec_cc_status_name[cc]);
 627                 ret = -EINVAL;
 628                 goto done;
 629         }
 630
 631         fusb302_log(chip, "cc := %s", typec_cc_status_name[cc]);
 632
 633         ret = fusb302_set_toggling(chip, TOGGLING_MODE_OFF);
 634         if (ret < 0) {
 635                 fusb302_log(chip, "cannot set toggling mode, ret=%d", ret);
 636                 goto done;
 637         }
 638
 639         ret = fusb302_i2c_mask_write(chip, FUSB_REG_SWITCHES0,
 640                                      switches0_mask, switches0_data);
 641         if (ret < 0) {
 642                 fusb302_log(chip, "cannot set pull-up/-down, ret = %d", ret);
 643                 goto done;
 644         }
 645         /* reset the cc status */
 646         chip->cc1 = TYPEC_CC_OPEN;
 647         chip->cc2 = TYPEC_CC_OPEN;
 648
 649         /* adjust current for SRC */
 650         ret = fusb302_set_src_current(chip, cc_src_current[cc]);
 651         if (ret < 0) {
 652                 fusb302_log(chip, "cannot set src current %s, ret=%d",
 653                             typec_cc_status_name[cc], ret);
 654                 goto done;
 655         }
 656
 657         /* enable/disable interrupts, BC_LVL for SNK and COMP_CHNG for SRC */
 658         switch (cc) {
 659         case TYPEC_CC_RP_DEF:
 660         case TYPEC_CC_RP_1_5:
 661         case TYPEC_CC_RP_3_0:
 662                 rd_mda = rd_mda_value[cc_src_current[cc]];
 663                 ret = fusb302_i2c_write(chip, FUSB_REG_MEASURE, rd_mda);
 664                 if (ret < 0) {
 665                         fusb302_log(chip,
 666                                     "cannot set SRC measure value, ret=%d",
 667                                     ret);
 668                         goto done;
 669                 }
 670                 ret = fusb302_i2c_mask_write(chip, FUSB_REG_MASK,
 671                                              FUSB_REG_MASK_BC_LVL |
 672                                              FUSB_REG_MASK_COMP_CHNG,
 673                                              FUSB_REG_MASK_BC_LVL);
 674                 if (ret < 0) {
 675                         fusb302_log(chip, "cannot set SRC interrupt, ret=%d",
 676                                     ret);
 677                         goto done;
 678                 }
 679                 chip->intr_comp_chng = true;
 680                 chip->intr_bc_lvl = false;
 681                 break;
 682         case TYPEC_CC_RD:
 683                 ret = fusb302_i2c_mask_write(chip, FUSB_REG_MASK,
 684                                              FUSB_REG_MASK_BC_LVL |
 685                                              FUSB_REG_MASK_COMP_CHNG,
 686                                              FUSB_REG_MASK_COMP_CHNG);
 687                 if (ret < 0) {
 688                         fusb302_log(chip, "cannot set SRC interrupt, ret=%d",
 689                                     ret);
 690                         goto done;
 691                 }
 692                 chip->intr_bc_lvl = true;
 693                 chip->intr_comp_chng = false;
 694                 break;
 695         default:
 696                 break;
 697         }
 698 done:
 699         mutex_unlock(&chip->lock);
 700
 701         return ret;
 702 }
 703
 704 static int tcpm_get_cc(struct tcpc_dev *dev, enum typec_cc_status *cc1,
 705                        enum typec_cc_status *cc2)
 706 {
 707         struct fusb302_chip *chip = container_of(dev, struct fusb302_chip,
 708                                                  tcpc_dev);
 709
 710         mutex_lock(&chip->lock);
 711         *cc1 = chip->cc1;
 712         *cc2 = chip->cc2;
 713         fusb302_log(chip, "cc1=%s, cc2=%s", typec_cc_status_name[*cc1],
 714                     typec_cc_status_name[*cc2]);
 715         mutex_unlock(&chip->lock);
 716
 717         return 0;
 718 }
 719
 720 static int tcpm_set_polarity(struct tcpc_dev *dev,
 721                              enum typec_cc_polarity polarity)
 722 {
 723         return 0;
 724 }
 725
 726 static int tcpm_set_vconn(struct tcpc_dev *dev, bool on)
 727 {
 728         struct fusb302_chip *chip = container_of(dev, struct fusb302_chip,
 729                                                  tcpc_dev);
 730         int ret = 0;
 731         u8 switches0_data = 0x00;
 732         u8 switches0_mask = FUSB_REG_SWITCHES0_VCONN_CC1 |
 733                             FUSB_REG_SWITCHES0_VCONN_CC2;
 734
 735         mutex_lock(&chip->lock);
 736         if (chip->vconn_on == on) {
 737                 fusb302_log(chip, "vconn is already %s", str_on_off(on));
 738                 goto done;
 739         }
 740         if (on) {
 741                 switches0_data = (chip->cc_polarity == TYPEC_POLARITY_CC1) ?
 742                                  FUSB_REG_SWITCHES0_VCONN_CC2 :
 743                                  FUSB_REG_SWITCHES0_VCONN_CC1;
 744         }
 745         ret = fusb302_i2c_mask_write(chip, FUSB_REG_SWITCHES0,
 746                                      switches0_mask, switches0_data);
 747         if (ret < 0)
 748                 goto done;
 749         chip->vconn_on = on;
 750         fusb302_log(chip, "vconn := %s", str_on_off(on));
 751 done:
 752         mutex_unlock(&chip->lock);
 753
 754         return ret;
 755 }
 756
 757 static int tcpm_set_vbus(struct tcpc_dev *dev, bool on, bool charge)
 758 {
 759         struct fusb302_chip *chip = container_of(dev, struct fusb302_chip,
 760                                                  tcpc_dev);
 761         int ret = 0;
 762
 763         mutex_lock(&chip->lock);
 764         if (chip->vbus_on == on) {
 765                 fusb302_log(chip, "vbus is already %s", str_on_off(on));
 766         } else {
 767                 if (on)
 768                         ret = regulator_enable(chip->vbus);
 769                 else
 770                         ret = regulator_disable(chip->vbus);
 771                 if (ret < 0) {
 772                         fusb302_log(chip, "cannot %s vbus regulator, ret=%d",
 773                                     str_enable_disable(on), ret);
 774                         goto done;
 775                 }
 776                 chip->vbus_on = on;
 777                 fusb302_log(chip, "vbus := %s", str_on_off(on));
 778         }
 779         if (chip->charge_on == charge)
 780                 fusb302_log(chip, "charge is already %s", str_on_off(charge));
 781         else
 782                 chip->charge_on = charge;
 783
 784 done:
 785         mutex_unlock(&chip->lock);
 786
 787         return ret;
 788 }
 789
 790 static int fusb302_pd_tx_flush(struct fusb302_chip *chip)
 791 {
 792         return fusb302_i2c_set_bits(chip, FUSB_REG_CONTROL0,
 793                                     FUSB_REG_CONTROL0_TX_FLUSH);
 794 }
 795
 796 static int fusb302_pd_rx_flush(struct fusb302_chip *chip)
 797 {
 798         return fusb302_i2c_set_bits(chip, FUSB_REG_CONTROL1,
 799                                     FUSB_REG_CONTROL1_RX_FLUSH);
 800 }
 801
 802 static int fusb302_pd_set_auto_goodcrc(struct fusb302_chip *chip, bool on)
 803 {
 804         if (on)
 805                 return fusb302_i2c_set_bits(chip, FUSB_REG_SWITCHES1,
 806                                             FUSB_REG_SWITCHES1_AUTO_GCRC);
 807         return fusb302_i2c_clear_bits(chip, FUSB_REG_SWITCHES1,
 808                                             FUSB_REG_SWITCHES1_AUTO_GCRC);
 809 }
 810
 811 static int fusb302_pd_set_interrupts(struct fusb302_chip *chip, bool on)
 812 {
 813         int ret = 0;
 814         u8 mask_interrupts = FUSB_REG_MASK_COLLISION;
 815         u8 maska_interrupts = FUSB_REG_MASKA_RETRYFAIL |
 816                               FUSB_REG_MASKA_HARDSENT |
 817                               FUSB_REG_MASKA_TX_SUCCESS |
 818                               FUSB_REG_MASKA_HARDRESET;
 819         u8 maskb_interrupts = FUSB_REG_MASKB_GCRCSENT;
 820
 821         ret = on ?
 822                 fusb302_i2c_clear_bits(chip, FUSB_REG_MASK, mask_interrupts) :
 823                 fusb302_i2c_set_bits(chip, FUSB_REG_MASK, mask_interrupts);
 824         if (ret < 0)
 825                 return ret;
 826         ret = on ?
 827                 fusb302_i2c_clear_bits(chip, FUSB_REG_MASKA, maska_interrupts) :
 828                 fusb302_i2c_set_bits(chip, FUSB_REG_MASKA, maska_interrupts);
 829         if (ret < 0)
 830                 return ret;
 831         ret = on ?
 832                 fusb302_i2c_clear_bits(chip, FUSB_REG_MASKB, maskb_interrupts) :
 833                 fusb302_i2c_set_bits(chip, FUSB_REG_MASKB, maskb_interrupts);
 834         return ret;
 835 }
 836
 837 static int tcpm_set_pd_rx(struct tcpc_dev *dev, bool on)
 838 {
 839         struct fusb302_chip *chip = container_of(dev, struct fusb302_chip,
 840                                                  tcpc_dev);
 841         int ret = 0;
 842
 843         mutex_lock(&chip->lock);
 844         ret = fusb302_pd_rx_flush(chip);
 845         if (ret < 0) {
 846                 fusb302_log(chip, "cannot flush pd rx buffer, ret=%d", ret);
 847                 goto done;
 848         }
 849         ret = fusb302_pd_tx_flush(chip);
 850         if (ret < 0) {
 851                 fusb302_log(chip, "cannot flush pd tx buffer, ret=%d", ret);
 852                 goto done;
 853         }
 854         ret = fusb302_pd_set_auto_goodcrc(chip, on);
 855         if (ret < 0) {
 856                 fusb302_log(chip, "cannot turn %s auto GCRC, ret=%d",
 857                             str_on_off(on), ret);
 858                 goto done;
 859         }
 860         ret = fusb302_pd_set_interrupts(chip, on);
 861         if (ret < 0) {
 862                 fusb302_log(chip, "cannot turn %s pd interrupts, ret=%d",
 863                             str_on_off(on), ret);
 864                 goto done;
 865         }
 866         fusb302_log(chip, "pd := %s", str_on_off(on));
 867 done:
 868         mutex_unlock(&chip->lock);
 869
 870         return ret;
 871 }
 872
 873 static const char * const typec_role_name[] = {
 874         [TYPEC_SINK]            = "Sink",
 875         [TYPEC_SOURCE]          = "Source",
 876 };
 877
 878 static const char * const typec_data_role_name[] = {
 879         [TYPEC_DEVICE]          = "Device",
 880         [TYPEC_HOST]            = "Host",
 881 };
 882
 883 static int tcpm_set_roles(struct tcpc_dev *dev, bool attached,
 884                           enum typec_role pwr, enum typec_data_role data)
 885 {
 886         struct fusb302_chip *chip = container_of(dev, struct fusb302_chip,
 887                                                  tcpc_dev);
 888         int ret = 0;
 889         u8 switches1_mask = FUSB_REG_SWITCHES1_POWERROLE |
 890                             FUSB_REG_SWITCHES1_DATAROLE;
 891         u8 switches1_data = 0x00;
 892
 893         mutex_lock(&chip->lock);
 894         if (pwr == TYPEC_SOURCE)
 895                 switches1_data |= FUSB_REG_SWITCHES1_POWERROLE;
 896         if (data == TYPEC_HOST)
 897                 switches1_data |= FUSB_REG_SWITCHES1_DATAROLE;
 898         ret = fusb302_i2c_mask_write(chip, FUSB_REG_SWITCHES1,
 899                                      switches1_mask, switches1_data);
 900         if (ret < 0) {
 901                 fusb302_log(chip, "unable to set pd header %s, %s, ret=%d",
 902                             typec_role_name[pwr], typec_data_role_name[data],
 903                             ret);
 904                 goto done;
 905         }
 906         fusb302_log(chip, "pd header := %s, %s", typec_role_name[pwr],
 907                     typec_data_role_name[data]);
 908 done:
 909         mutex_unlock(&chip->lock);
 910
 911         return ret;
 912 }
 913
 914 static int tcpm_start_toggling(struct tcpc_dev *dev,
 915                                enum typec_port_type port_type,
 916                                enum typec_cc_status cc)
 917 {
 918         struct fusb302_chip *chip = container_of(dev, struct fusb302_chip,
 919                                                  tcpc_dev);
 920         enum toggling_mode mode = TOGGLING_MODE_OFF;
 921         int ret = 0;
 922
 923         switch (port_type) {
 924         case TYPEC_PORT_SRC:
 925                 mode = TOGGLING_MODE_SRC;
 926                 break;
 927         case TYPEC_PORT_SNK:
 928                 mode = TOGGLING_MODE_SNK;
 929                 break;
 930         case TYPEC_PORT_DRP:
 931                 mode = TOGGLING_MODE_DRP;
 932                 break;
 933         }
 934
 935         mutex_lock(&chip->lock);
 936         ret = fusb302_set_src_current(chip, cc_src_current[cc]);
 937         if (ret < 0) {
 938                 fusb302_log(chip, "unable to set src current %s, ret=%d",
 939                             typec_cc_status_name[cc], ret);
 940                 goto done;
 941         }
 942         ret = fusb302_set_toggling(chip, mode);
 943         if (ret < 0) {
 944                 fusb302_log(chip,
 945                             "unable to start drp toggling, ret=%d", ret);
 946                 goto done;
 947         }
 948         fusb302_log(chip, "start drp toggling");
 949 done:
 950         mutex_unlock(&chip->lock);
 951
 952         return ret;
 953 }
 954
 955 static int fusb302_pd_send_message(struct fusb302_chip *chip,
 956                                    const struct pd_message *msg)
 957 {
 958         int ret = 0;
 959         u8 buf[40];
 960         u8 pos = 0;
 961         int len;
 962
 963         /* SOP tokens */
 964         buf[pos++] = FUSB302_TKN_SYNC1;
 965         buf[pos++] = FUSB302_TKN_SYNC1;
 966         buf[pos++] = FUSB302_TKN_SYNC1;
 967         buf[pos++] = FUSB302_TKN_SYNC2;
 968
 969         len = pd_header_cnt_le(msg->header) * 4;
 970         /* plug 2 for header */
 971         len += 2;
 972         if (len > 0x1F) {
 973                 fusb302_log(chip,
 974                             "PD message too long %d (incl. header)", len);
 975                 return -EINVAL;
 976         }
 977         /* packsym tells the FUSB302 chip that the next X bytes are payload */
 978         buf[pos++] = FUSB302_TKN_PACKSYM | (len & 0x1F);
 979         memcpy(&buf[pos], &msg->header, sizeof(msg->header));
 980         pos += sizeof(msg->header);
 981
 982         len -= 2;
 983         memcpy(&buf[pos], msg->payload, len);
 984         pos += len;
 985
 986         /* CRC */
 987         buf[pos++] = FUSB302_TKN_JAMCRC;
 988         /* EOP */
 989         buf[pos++] = FUSB302_TKN_EOP;
 990         /* turn tx off after sending message */
 991         buf[pos++] = FUSB302_TKN_TXOFF;
 992         /* start transmission */
 993         buf[pos++] = FUSB302_TKN_TXON;
 994
 995         ret = fusb302_i2c_block_write(chip, FUSB_REG_FIFOS, pos, buf);
 996         if (ret < 0)
 997                 return ret;
 998         fusb302_log(chip, "sending PD message header: %x", msg->header);
 999         fusb302_log(chip, "sending PD message len: %d", len);
1000
1001         return ret;
1002 }
1003
1004 static int fusb302_pd_send_hardreset(struct fusb302_chip *chip)
1005 {
1006         return fusb302_i2c_set_bits(chip, FUSB_REG_CONTROL3,
1007                                     FUSB_REG_CONTROL3_SEND_HARDRESET);
1008 }
1009
1010 static const char * const transmit_type_name[] = {
1011         [TCPC_TX_SOP]                   = "SOP",
1012         [TCPC_TX_SOP_PRIME]             = "SOP'",
1013         [TCPC_TX_SOP_PRIME_PRIME]       = "SOP''",
1014         [TCPC_TX_SOP_DEBUG_PRIME]       = "DEBUG'",
1015         [TCPC_TX_SOP_DEBUG_PRIME_PRIME] = "DEBUG''",
1016         [TCPC_TX_HARD_RESET]            = "HARD_RESET",
1017         [TCPC_TX_CABLE_RESET]           = "CABLE_RESET",
1018         [TCPC_TX_BIST_MODE_2]           = "BIST_MODE_2",
1019 };
1020
1021 static int tcpm_pd_transmit(struct tcpc_dev *dev, enum tcpm_transmit_type type,
1022                             const struct pd_message *msg, unsigned int negotiated_rev)
1023 {
1024         struct fusb302_chip *chip = container_of(dev, struct fusb302_chip,
1025                                                  tcpc_dev);
1026         int ret = 0;
1027
1028         mutex_lock(&chip->lock);
1029         switch (type) {
1030         case TCPC_TX_SOP:
1031                 /* nRetryCount 3 in P2.0 spec, whereas 2 in PD3.0 spec */
1032                 ret = fusb302_enable_tx_auto_retries(chip, negotiated_rev > PD_REV20 ?
1033                                                      FUSB_REG_CONTROL3_N_RETRIES_2 :
1034                                                      FUSB_REG_CONTROL3_N_RETRIES_3);
1035                 if (ret < 0)
1036                         fusb302_log(chip, "Cannot update retry count ret=%d", ret);
1037
1038                 ret = fusb302_pd_send_message(chip, msg);
1039                 if (ret < 0)
1040                         fusb302_log(chip,
1041                                     "cannot send PD message, ret=%d", ret);
1042                 break;
1043         case TCPC_TX_HARD_RESET:
1044                 ret = fusb302_pd_send_hardreset(chip);
1045                 if (ret < 0)
1046                         fusb302_log(chip,
1047                                     "cannot send hardreset, ret=%d", ret);
1048                 break;
1049         default:
1050                 fusb302_log(chip, "type %s not supported",
1051                             transmit_type_name[type]);
1052                 ret = -EINVAL;
1053         }
1054         mutex_unlock(&chip->lock);
1055
1056         return ret;
1057 }
1058
1059 static enum typec_cc_status fusb302_bc_lvl_to_cc(u8 bc_lvl)
1060 {
1061         if (bc_lvl == FUSB_REG_STATUS0_BC_LVL_1230_MAX)
1062                 return TYPEC_CC_RP_3_0;
1063         if (bc_lvl == FUSB_REG_STATUS0_BC_LVL_600_1230)
1064                 return TYPEC_CC_RP_1_5;
1065         if (bc_lvl == FUSB_REG_STATUS0_BC_LVL_200_600)
1066                 return TYPEC_CC_RP_DEF;
1067         return TYPEC_CC_OPEN;
1068 }
1069
1070 static void fusb302_bc_lvl_handler_work(struct work_struct *work)
1071 {
1072         struct fusb302_chip *chip = container_of(work, struct fusb302_chip,
1073                                                  bc_lvl_handler.work);
1074         int ret = 0;
1075         u8 status0;
1076         u8 bc_lvl;
1077         enum typec_cc_status cc_status;
1078
1079         mutex_lock(&chip->lock);
1080         if (!chip->intr_bc_lvl) {
1081                 fusb302_log(chip, "BC_LVL interrupt is turned off, abort");
1082                 goto done;
1083         }
1084         ret = fusb302_i2c_read(chip, FUSB_REG_STATUS0, &status0);
1085         if (ret < 0)
1086                 goto done;
1087         fusb302_log(chip, "BC_LVL handler, status0=0x%02x", status0);
1088         if (status0 & FUSB_REG_STATUS0_ACTIVITY) {
1089                 fusb302_log(chip, "CC activities detected, delay handling");
1090                 mod_delayed_work(chip->wq, &chip->bc_lvl_handler,
1091                                  msecs_to_jiffies(T_BC_LVL_DEBOUNCE_DELAY_MS));
1092                 goto done;
1093         }
1094         bc_lvl = status0 & FUSB_REG_STATUS0_BC_LVL_MASK;
1095         cc_status = fusb302_bc_lvl_to_cc(bc_lvl);
1096         if (chip->cc_polarity == TYPEC_POLARITY_CC1) {
1097                 if (chip->cc1 != cc_status) {
1098                         fusb302_log(chip, "cc1: %s -> %s",
1099                                     typec_cc_status_name[chip->cc1],
1100                                     typec_cc_status_name[cc_status]);
1101                         chip->cc1 = cc_status;
1102                         tcpm_cc_change(chip->tcpm_port);
1103                 }
1104         } else {
1105                 if (chip->cc2 != cc_status) {
1106                         fusb302_log(chip, "cc2: %s -> %s",
1107                                     typec_cc_status_name[chip->cc2],
1108                                     typec_cc_status_name[cc_status]);
1109                         chip->cc2 = cc_status;
1110                         tcpm_cc_change(chip->tcpm_port);
1111                 }
1112         }
1113
1114 done:
1115         mutex_unlock(&chip->lock);
1116 }
1117
1118 static void init_tcpc_dev(struct tcpc_dev *fusb302_tcpc_dev)
1119 {
1120         fusb302_tcpc_dev->init = tcpm_init;
1121         fusb302_tcpc_dev->get_vbus = tcpm_get_vbus;
1122         fusb302_tcpc_dev->get_current_limit = tcpm_get_current_limit;
1123         fusb302_tcpc_dev->set_cc = tcpm_set_cc;
1124         fusb302_tcpc_dev->get_cc = tcpm_get_cc;
1125         fusb302_tcpc_dev->set_polarity = tcpm_set_polarity;
1126         fusb302_tcpc_dev->set_vconn = tcpm_set_vconn;
1127         fusb302_tcpc_dev->set_vbus = tcpm_set_vbus;
1128         fusb302_tcpc_dev->set_pd_rx = tcpm_set_pd_rx;
1129         fusb302_tcpc_dev->set_roles = tcpm_set_roles;
1130         fusb302_tcpc_dev->start_toggling = tcpm_start_toggling;
1131         fusb302_tcpc_dev->pd_transmit = tcpm_pd_transmit;
1132 }
1133
1134 static const char * const cc_polarity_name[] = {
1135         [TYPEC_POLARITY_CC1]    = "Polarity_CC1",
1136         [TYPEC_POLARITY_CC2]    = "Polarity_CC2",
1137 };
1138
1139 static int fusb302_set_cc_polarity_and_pull(struct fusb302_chip *chip,
1140                                             enum typec_cc_polarity cc_polarity,
1141                                             bool pull_up, bool pull_down)
1142 {
1143         int ret = 0;
1144         u8 switches0_data = 0x00;
1145         u8 switches1_mask = FUSB_REG_SWITCHES1_TXCC1_EN |
1146                             FUSB_REG_SWITCHES1_TXCC2_EN;
1147         u8 switches1_data = 0x00;
1148
1149         if (pull_down)
1150                 switches0_data |= FUSB_REG_SWITCHES0_CC1_PD_EN |
1151                                   FUSB_REG_SWITCHES0_CC2_PD_EN;
1152
1153         if (cc_polarity == TYPEC_POLARITY_CC1) {
1154                 switches0_data |= FUSB_REG_SWITCHES0_MEAS_CC1;
1155                 if (chip->vconn_on)
1156                         switches0_data |= FUSB_REG_SWITCHES0_VCONN_CC2;
1157                 if (pull_up)
1158                         switches0_data |= FUSB_REG_SWITCHES0_CC1_PU_EN;
1159                 switches1_data = FUSB_REG_SWITCHES1_TXCC1_EN;
1160         } else {
1161                 switches0_data |= FUSB_REG_SWITCHES0_MEAS_CC2;
1162                 if (chip->vconn_on)
1163                         switches0_data |= FUSB_REG_SWITCHES0_VCONN_CC1;
1164                 if (pull_up)
1165                         switches0_data |= FUSB_REG_SWITCHES0_CC2_PU_EN;
1166                 switches1_data = FUSB_REG_SWITCHES1_TXCC2_EN;
1167         }
1168         ret = fusb302_i2c_write(chip, FUSB_REG_SWITCHES0, switches0_data);
1169         if (ret < 0)
1170                 return ret;
1171         ret = fusb302_i2c_mask_write(chip, FUSB_REG_SWITCHES1,
1172                                      switches1_mask, switches1_data);
1173         if (ret < 0)
1174                 return ret;
1175         chip->cc_polarity = cc_polarity;
1176
1177         return ret;
1178 }
1179
1180 static int fusb302_handle_togdone_snk(struct fusb302_chip *chip,
1181                                       u8 togdone_result)
1182 {
1183         int ret = 0;
1184         u8 status0;
1185         u8 bc_lvl;
1186         enum typec_cc_polarity cc_polarity;
1187         enum typec_cc_status cc_status_active, cc1, cc2;
1188
1189         /* set polarity and pull_up, pull_down */
1190         cc_polarity = (togdone_result == FUSB_REG_STATUS1A_TOGSS_SNK1) ?
1191                       TYPEC_POLARITY_CC1 : TYPEC_POLARITY_CC2;
1192         ret = fusb302_set_cc_polarity_and_pull(chip, cc_polarity, false, true);
1193         if (ret < 0) {
1194                 fusb302_log(chip, "cannot set cc polarity %s, ret=%d",
1195                             cc_polarity_name[cc_polarity], ret);
1196                 return ret;
1197         }
1198         /* fusb302_set_cc_polarity() has set the correct measure block */
1199         ret = fusb302_i2c_read(chip, FUSB_REG_STATUS0, &status0);
1200         if (ret < 0)
1201                 return ret;
1202         bc_lvl = status0 & FUSB_REG_STATUS0_BC_LVL_MASK;
1203         cc_status_active = fusb302_bc_lvl_to_cc(bc_lvl);
1204         /* restart toggling if the cc status on the active line is OPEN */
1205         if (cc_status_active == TYPEC_CC_OPEN) {
1206                 fusb302_log(chip, "restart toggling as CC_OPEN detected");
1207                 ret = fusb302_set_toggling(chip, chip->toggling_mode);
1208                 return ret;
1209         }
1210         /* update tcpm with the new cc value */
1211         cc1 = (cc_polarity == TYPEC_POLARITY_CC1) ?
1212               cc_status_active : TYPEC_CC_OPEN;
1213         cc2 = (cc_polarity == TYPEC_POLARITY_CC2) ?
1214               cc_status_active : TYPEC_CC_OPEN;
1215         if ((chip->cc1 != cc1) || (chip->cc2 != cc2)) {
1216                 chip->cc1 = cc1;
1217                 chip->cc2 = cc2;
1218                 tcpm_cc_change(chip->tcpm_port);
1219         }
1220         /* turn off toggling */
1221         ret = fusb302_set_toggling(chip, TOGGLING_MODE_OFF);
1222         if (ret < 0) {
1223                 fusb302_log(chip,
1224                             "cannot set toggling mode off, ret=%d", ret);
1225                 return ret;
1226         }
1227         /* unmask bc_lvl interrupt */
1228         ret = fusb302_i2c_clear_bits(chip, FUSB_REG_MASK, FUSB_REG_MASK_BC_LVL);
1229         if (ret < 0) {
1230                 fusb302_log(chip,
1231                             "cannot unmask bc_lcl interrupt, ret=%d", ret);
1232                 return ret;
1233         }
1234         chip->intr_bc_lvl = true;
1235         fusb302_log(chip, "detected cc1=%s, cc2=%s",
1236                     typec_cc_status_name[cc1],
1237                     typec_cc_status_name[cc2]);
1238
1239         return ret;
1240 }
1241
1242 /* On error returns < 0, otherwise a typec_cc_status value */
1243 static int fusb302_get_src_cc_status(struct fusb302_chip *chip,
1244                                      enum typec_cc_polarity cc_polarity,
1245                                      enum typec_cc_status *cc)
1246 {
1247         u8 ra_mda = ra_mda_value[chip->src_current_status];
1248         u8 rd_mda = rd_mda_value[chip->src_current_status];
1249         u8 switches0_data, status0;
1250         int ret;
1251
1252         /* Step 1: Set switches so that we measure the right CC pin */
1253         switches0_data = (cc_polarity == TYPEC_POLARITY_CC1) ?
1254                 FUSB_REG_SWITCHES0_CC1_PU_EN | FUSB_REG_SWITCHES0_MEAS_CC1 :
1255                 FUSB_REG_SWITCHES0_CC2_PU_EN | FUSB_REG_SWITCHES0_MEAS_CC2;
1256         ret = fusb302_i2c_write(chip, FUSB_REG_SWITCHES0, switches0_data);
1257         if (ret < 0)
1258                 return ret;
1259
1260         fusb302_i2c_read(chip, FUSB_REG_SWITCHES0, &status0);
1261         fusb302_log(chip, "get_src_cc_status switches: 0x%0x", status0);
1262
1263         /* Step 2: Set compararator volt to differentiate between Open and Rd */
1264         ret = fusb302_i2c_write(chip, FUSB_REG_MEASURE, rd_mda);
1265         if (ret < 0)
1266                 return ret;
1267
1268         usleep_range(50, 100);
1269         ret = fusb302_i2c_read(chip, FUSB_REG_STATUS0, &status0);
1270         if (ret < 0)
1271                 return ret;
1272
1273         fusb302_log(chip, "get_src_cc_status rd_mda status0: 0x%0x", status0);
1274         if (status0 & FUSB_REG_STATUS0_COMP) {
1275                 *cc = TYPEC_CC_OPEN;
1276                 return 0;
1277         }
1278
1279         /* Step 3: Set compararator input to differentiate between Rd and Ra. */
1280         ret = fusb302_i2c_write(chip, FUSB_REG_MEASURE, ra_mda);
1281         if (ret < 0)
1282                 return ret;
1283
1284         usleep_range(50, 100);
1285         ret = fusb302_i2c_read(chip, FUSB_REG_STATUS0, &status0);
1286         if (ret < 0)
1287                 return ret;
1288
1289         fusb302_log(chip, "get_src_cc_status ra_mda status0: 0x%0x", status0);
1290         if (status0 & FUSB_REG_STATUS0_COMP)
1291                 *cc = TYPEC_CC_RD;
1292         else
1293                 *cc = TYPEC_CC_RA;
1294
1295         return 0;
1296 }
1297
1298 static int fusb302_handle_togdone_src(struct fusb302_chip *chip,
1299                                       u8 togdone_result)
1300 {
1301         /*
1302          * - set polarity (measure cc, vconn, tx)
1303          * - set pull_up, pull_down
1304          * - set cc1, cc2, and update to tcpm_port
1305          * - set I_COMP interrupt on
1306          */
1307         int ret = 0;
1308         u8 rd_mda = rd_mda_value[chip->src_current_status];
1309         enum toggling_mode toggling_mode = chip->toggling_mode;
1310         enum typec_cc_polarity cc_polarity;
1311         enum typec_cc_status cc1, cc2;
1312
1313         /*
1314          * The toggle-engine will stop in a src state if it sees either Ra or
1315          * Rd. Determine the status for both CC pins, starting with the one
1316          * where toggling stopped, as that is where the switches point now.
1317          */
1318         if (togdone_result == FUSB_REG_STATUS1A_TOGSS_SRC1)
1319                 ret = fusb302_get_src_cc_status(chip, TYPEC_POLARITY_CC1, &cc1);
1320         else
1321                 ret = fusb302_get_src_cc_status(chip, TYPEC_POLARITY_CC2, &cc2);
1322         if (ret < 0)
1323                 return ret;
1324         /* we must turn off toggling before we can measure the other pin */
1325         ret = fusb302_set_toggling(chip, TOGGLING_MODE_OFF);
1326         if (ret < 0) {
1327                 fusb302_log(chip, "cannot set toggling mode off, ret=%d", ret);
1328                 return ret;
1329         }
1330         /* get the status of the other pin */
1331         if (togdone_result == FUSB_REG_STATUS1A_TOGSS_SRC1)
1332                 ret = fusb302_get_src_cc_status(chip, TYPEC_POLARITY_CC2, &cc2);
1333         else
1334                 ret = fusb302_get_src_cc_status(chip, TYPEC_POLARITY_CC1, &cc1);
1335         if (ret < 0)
1336                 return ret;
1337
1338         /* determine polarity based on the status of both pins */
1339         if (cc1 == TYPEC_CC_RD &&
1340                         (cc2 == TYPEC_CC_OPEN || cc2 == TYPEC_CC_RA)) {
1341                 cc_polarity = TYPEC_POLARITY_CC1;
1342         } else if (cc2 == TYPEC_CC_RD &&
1343                     (cc1 == TYPEC_CC_OPEN || cc1 == TYPEC_CC_RA)) {
1344                 cc_polarity = TYPEC_POLARITY_CC2;
1345         } else {
1346                 fusb302_log(chip, "unexpected CC status cc1=%s, cc2=%s, restarting toggling",
1347                             typec_cc_status_name[cc1],
1348                             typec_cc_status_name[cc2]);
1349                 return fusb302_set_toggling(chip, toggling_mode);
1350         }
1351         /* set polarity and pull_up, pull_down */
1352         ret = fusb302_set_cc_polarity_and_pull(chip, cc_polarity, true, false);
1353         if (ret < 0) {
1354                 fusb302_log(chip, "cannot set cc polarity %s, ret=%d",
1355                             cc_polarity_name[cc_polarity], ret);
1356                 return ret;
1357         }
1358         /* update tcpm with the new cc value */
1359         if ((chip->cc1 != cc1) || (chip->cc2 != cc2)) {
1360                 chip->cc1 = cc1;
1361                 chip->cc2 = cc2;
1362                 tcpm_cc_change(chip->tcpm_port);
1363         }
1364         /* set MDAC to Rd threshold, and unmask I_COMP for unplug detection */
1365         ret = fusb302_i2c_write(chip, FUSB_REG_MEASURE, rd_mda);
1366         if (ret < 0)
1367                 return ret;
1368         /* unmask comp_chng interrupt */
1369         ret = fusb302_i2c_clear_bits(chip, FUSB_REG_MASK,
1370                                      FUSB_REG_MASK_COMP_CHNG);
1371         if (ret < 0) {
1372                 fusb302_log(chip,
1373                             "cannot unmask comp_chng interrupt, ret=%d", ret);
1374                 return ret;
1375         }
1376         chip->intr_comp_chng = true;
1377         fusb302_log(chip, "detected cc1=%s, cc2=%s",
1378                     typec_cc_status_name[cc1],
1379                     typec_cc_status_name[cc2]);
1380
1381         return ret;
1382 }
1383
1384 static int fusb302_handle_togdone(struct fusb302_chip *chip)
1385 {
1386         int ret = 0;
1387         u8 status1a;
1388         u8 togdone_result;
1389
1390         ret = fusb302_i2c_read(chip, FUSB_REG_STATUS1A, &status1a);
1391         if (ret < 0)
1392                 return ret;
1393         togdone_result = (status1a >> FUSB_REG_STATUS1A_TOGSS_POS) &
1394                          FUSB_REG_STATUS1A_TOGSS_MASK;
1395         switch (togdone_result) {
1396         case FUSB_REG_STATUS1A_TOGSS_SNK1:
1397         case FUSB_REG_STATUS1A_TOGSS_SNK2:
1398                 return fusb302_handle_togdone_snk(chip, togdone_result);
1399         case FUSB_REG_STATUS1A_TOGSS_SRC1:
1400         case FUSB_REG_STATUS1A_TOGSS_SRC2:
1401                 return fusb302_handle_togdone_src(chip, togdone_result);
1402         case FUSB_REG_STATUS1A_TOGSS_AA:
1403                 /* doesn't support */
1404                 fusb302_log(chip, "AudioAccessory not supported");
1405                 fusb302_set_toggling(chip, chip->toggling_mode);
1406                 break;
1407         default:
1408                 fusb302_log(chip, "TOGDONE with an invalid state: %d",
1409                             togdone_result);
1410                 fusb302_set_toggling(chip, chip->toggling_mode);
1411                 break;
1412         }
1413         return ret;
1414 }
1415
1416 static int fusb302_pd_reset(struct fusb302_chip *chip)
1417 {
1418         return fusb302_i2c_set_bits(chip, FUSB_REG_RESET,
1419                                     FUSB_REG_RESET_PD_RESET);
1420 }
1421
1422 static int fusb302_pd_read_message(struct fusb302_chip *chip,
1423                                    struct pd_message *msg)
1424 {
1425         int ret = 0;
1426         u8 token;
1427         u8 crc[4];
1428         int len;
1429
1430         /* first SOP token */
1431         ret = fusb302_i2c_read(chip, FUSB_REG_FIFOS, &token);
1432         if (ret < 0)
1433                 return ret;
1434         ret = fusb302_i2c_block_read(chip, FUSB_REG_FIFOS, 2,
1435                                      (u8 *)&msg->header);
1436         if (ret < 0)
1437                 return ret;
1438         len = pd_header_cnt_le(msg->header) * 4;
1439         /* add 4 to length to include the CRC */
1440         if (len > PD_MAX_PAYLOAD * 4) {
1441                 fusb302_log(chip, "PD message too long %d", len);
1442                 return -EINVAL;
1443         }
1444         if (len > 0) {
1445                 ret = fusb302_i2c_block_read(chip, FUSB_REG_FIFOS, len,
1446                                              (u8 *)msg->payload);
1447                 if (ret < 0)
1448                         return ret;
1449         }
1450         /* another 4 bytes to read CRC out */
1451         ret = fusb302_i2c_block_read(chip, FUSB_REG_FIFOS, 4, crc);
1452         if (ret < 0)
1453                 return ret;
1454         fusb302_log(chip, "PD message header: %x", msg->header);
1455         fusb302_log(chip, "PD message len: %d", len);
1456
1457         /*
1458          * Check if we've read off a GoodCRC message. If so then indicate to
1459          * TCPM that the previous transmission has completed. Otherwise we pass
1460          * the received message over to TCPM for processing.
1461          *
1462          * We make this check here instead of basing the reporting decision on
1463          * the IRQ event type, as it's possible for the chip to report the
1464          * TX_SUCCESS and GCRCSENT events out of order on occasion, so we need
1465          * to check the message type to ensure correct reporting to TCPM.
1466          */
1467         if ((!len) && (pd_header_type_le(msg->header) == PD_CTRL_GOOD_CRC))
1468                 tcpm_pd_transmit_complete(chip->tcpm_port, TCPC_TX_SUCCESS);
1469         else
1470                 tcpm_pd_receive(chip->tcpm_port, msg, TCPC_TX_SOP);
1471
1472         return ret;
1473 }
1474
1475 static irqreturn_t fusb302_irq_intn(int irq, void *dev_id)
1476 {
1477         struct fusb302_chip *chip = dev_id;
1478         unsigned long flags;
1479
1480         /* Disable our level triggered IRQ until our irq_work has cleared it */
1481         disable_irq_nosync(chip->gpio_int_n_irq);
1482
1483         spin_lock_irqsave(&chip->irq_lock, flags);
1484         if (chip->irq_suspended)
1485                 chip->irq_while_suspended = true;
1486         else
1487                 schedule_work(&chip->irq_work);
1488         spin_unlock_irqrestore(&chip->irq_lock, flags);
1489
1490         return IRQ_HANDLED;
1491 }
1492
1493 static void fusb302_irq_work(struct work_struct *work)
1494 {
1495         struct fusb302_chip *chip = container_of(work, struct fusb302_chip,
1496                                                  irq_work);
1497         int ret = 0;
1498         u8 interrupt;
1499         u8 interrupta;
1500         u8 interruptb;
1501         u8 status0;
1502         bool vbus_present;
1503         bool comp_result;
1504         bool intr_togdone;
1505         bool intr_bc_lvl;
1506         bool intr_comp_chng;
1507         struct pd_message pd_msg;
1508
1509         mutex_lock(&chip->lock);
1510         /* grab a snapshot of intr flags */
1511         intr_togdone = chip->intr_togdone;
1512         intr_bc_lvl = chip->intr_bc_lvl;
1513         intr_comp_chng = chip->intr_comp_chng;
1514
1515         ret = fusb302_i2c_read(chip, FUSB_REG_INTERRUPT, &interrupt);
1516         if (ret < 0)
1517                 goto done;
1518         ret = fusb302_i2c_read(chip, FUSB_REG_INTERRUPTA, &interrupta);
1519         if (ret < 0)
1520                 goto done;
1521         ret = fusb302_i2c_read(chip, FUSB_REG_INTERRUPTB, &interruptb);
1522         if (ret < 0)
1523                 goto done;
1524         ret = fusb302_i2c_read(chip, FUSB_REG_STATUS0, &status0);
1525         if (ret < 0)
1526                 goto done;
1527         fusb302_log(chip,
1528                     "IRQ: 0x%02x, a: 0x%02x, b: 0x%02x, status0: 0x%02x",
1529                     interrupt, interrupta, interruptb, status0);
1530
1531         if (interrupt & FUSB_REG_INTERRUPT_VBUSOK) {
1532                 vbus_present = !!(status0 & FUSB_REG_STATUS0_VBUSOK);
1533                 fusb302_log(chip, "IRQ: VBUS_OK, vbus=%s",
1534                             str_on_off(vbus_present));
1535                 if (vbus_present != chip->vbus_present) {
1536                         chip->vbus_present = vbus_present;
1537                         tcpm_vbus_change(chip->tcpm_port);
1538                 }
1539         }
1540
1541         if ((interrupta & FUSB_REG_INTERRUPTA_TOGDONE) && intr_togdone) {
1542                 fusb302_log(chip, "IRQ: TOGDONE");
1543                 ret = fusb302_handle_togdone(chip);
1544                 if (ret < 0) {
1545                         fusb302_log(chip,
1546                                     "handle togdone error, ret=%d", ret);
1547                         goto done;
1548                 }
1549         }
1550
1551         if ((interrupt & FUSB_REG_INTERRUPT_BC_LVL) && intr_bc_lvl) {
1552                 fusb302_log(chip, "IRQ: BC_LVL, handler pending");
1553                 /*
1554                  * as BC_LVL interrupt can be affected by PD activity,
1555                  * apply delay to for the handler to wait for the PD
1556                  * signaling to finish.
1557                  */
1558                 mod_delayed_work(chip->wq, &chip->bc_lvl_handler,
1559                                  msecs_to_jiffies(T_BC_LVL_DEBOUNCE_DELAY_MS));
1560         }
1561
1562         if ((interrupt & FUSB_REG_INTERRUPT_COMP_CHNG) && intr_comp_chng) {
1563                 comp_result = !!(status0 & FUSB_REG_STATUS0_COMP);
1564                 fusb302_log(chip, "IRQ: COMP_CHNG, comp=%s",
1565                             str_true_false(comp_result));
1566                 if (comp_result) {
1567                         /* cc level > Rd_threshold, detach */
1568                         chip->cc1 = TYPEC_CC_OPEN;
1569                         chip->cc2 = TYPEC_CC_OPEN;
1570                         tcpm_cc_change(chip->tcpm_port);
1571                 }
1572         }
1573
1574         if (interrupt & FUSB_REG_INTERRUPT_COLLISION) {
1575                 fusb302_log(chip, "IRQ: PD collision");
1576                 tcpm_pd_transmit_complete(chip->tcpm_port, TCPC_TX_FAILED);
1577         }
1578
1579         if (interrupta & FUSB_REG_INTERRUPTA_RETRYFAIL) {
1580                 fusb302_log(chip, "IRQ: PD retry failed");
1581                 tcpm_pd_transmit_complete(chip->tcpm_port, TCPC_TX_FAILED);
1582         }
1583
1584         if (interrupta & FUSB_REG_INTERRUPTA_HARDSENT) {
1585                 fusb302_log(chip, "IRQ: PD hardreset sent");
1586                 ret = fusb302_pd_reset(chip);
1587                 if (ret < 0) {
1588                         fusb302_log(chip, "cannot PD reset, ret=%d", ret);
1589                         goto done;
1590                 }
1591                 tcpm_pd_transmit_complete(chip->tcpm_port, TCPC_TX_SUCCESS);
1592         }
1593
1594         if (interrupta & FUSB_REG_INTERRUPTA_TX_SUCCESS) {
1595                 fusb302_log(chip, "IRQ: PD tx success");
1596                 ret = fusb302_pd_read_message(chip, &pd_msg);
1597                 if (ret < 0) {
1598                         fusb302_log(chip,
1599                                     "cannot read in PD message, ret=%d", ret);
1600                         goto done;
1601                 }
1602         }
1603
1604         if (interrupta & FUSB_REG_INTERRUPTA_HARDRESET) {
1605                 fusb302_log(chip, "IRQ: PD received hardreset");
1606                 ret = fusb302_pd_reset(chip);
1607                 if (ret < 0) {
1608                         fusb302_log(chip, "cannot PD reset, ret=%d", ret);
1609                         goto done;
1610                 }
1611                 tcpm_pd_hard_reset(chip->tcpm_port);
1612         }
1613
1614         if (interruptb & FUSB_REG_INTERRUPTB_GCRCSENT) {
1615                 fusb302_log(chip, "IRQ: PD sent good CRC");
1616                 ret = fusb302_pd_read_message(chip, &pd_msg);
1617                 if (ret < 0) {
1618                         fusb302_log(chip,
1619                                     "cannot read in PD message, ret=%d", ret);
1620                         goto done;
1621                 }
1622         }
1623 done:
1624         mutex_unlock(&chip->lock);
1625         enable_irq(chip->gpio_int_n_irq);
1626 }
1627
1628 static int init_gpio(struct fusb302_chip *chip)
1629 {
1630         struct device *dev = chip->dev;
1631         int ret = 0;
1632
1633         chip->gpio_int_n = devm_gpiod_get(dev, "fcs,int_n", GPIOD_IN);
1634         if (IS_ERR(chip->gpio_int_n)) {
1635                 dev_err(dev, "failed to request gpio_int_n\n");
1636                 return PTR_ERR(chip->gpio_int_n);
1637         }
1638         ret = gpiod_to_irq(chip->gpio_int_n);
1639         if (ret < 0) {
1640                 dev_err(dev,
1641                         "cannot request IRQ for GPIO Int_N, ret=%d", ret);
1642                 return ret;
1643         }
1644         chip->gpio_int_n_irq = ret;
1645         return 0;
1646 }
1647
1648 #define PDO_FIXED_FLAGS \
1649         (PDO_FIXED_DUAL_ROLE | PDO_FIXED_DATA_SWAP | PDO_FIXED_USB_COMM)
1650
1651 static const u32 src_pdo[] = {
1652         PDO_FIXED(5000, 400, PDO_FIXED_FLAGS)
1653 };
1654
1655 static const u32 snk_pdo[] = {
1656         PDO_FIXED(5000, 400, PDO_FIXED_FLAGS)
1657 };
1658
1659 static const struct property_entry port_props[] = {
1660         PROPERTY_ENTRY_STRING("data-role", "dual"),
1661         PROPERTY_ENTRY_STRING("power-role", "dual"),
1662         PROPERTY_ENTRY_STRING("try-power-role", "sink"),
1663         PROPERTY_ENTRY_U32_ARRAY("source-pdos", src_pdo),
1664         PROPERTY_ENTRY_U32_ARRAY("sink-pdos", snk_pdo),
1665         PROPERTY_ENTRY_U32("op-sink-microwatt", 2500000),
1666         { }
1667 };
1668
1669 static struct fwnode_handle *fusb302_fwnode_get(struct device *dev)
1670 {
1671         struct fwnode_handle *fwnode;
1672
1673         fwnode = device_get_named_child_node(dev, "connector");
1674         if (!fwnode)
1675                 fwnode = fwnode_create_software_node(port_props, NULL);
1676
1677         return fwnode;
1678 }
1679
1680 static int fusb302_probe(struct i2c_client *client)
1681 {
1682         struct fusb302_chip *chip;
1683         struct i2c_adapter *adapter = client->adapter;
1684         struct device *dev = &client->dev;
1685         const char *name;
1686         int ret = 0;
1687
1688         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_I2C_BLOCK)) {
1689                 dev_err(&client->dev,
1690                         "I2C/SMBus block functionality not supported!\n");
1691                 return -ENODEV;
1692         }
1693         chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
1694         if (!chip)
1695                 return -ENOMEM;
1696
1697         chip->i2c_client = client;
1698         chip->dev = &client->dev;
1699         mutex_init(&chip->lock);
1700
1701         /*
1702          * Devicetree platforms should get extcon via phandle (not yet
1703          * supported). On ACPI platforms, we get the name from a device prop.
1704          * This device prop is for kernel internal use only and is expected
1705          * to be set by the platform code which also registers the i2c client
1706          * for the fusb302.
1707          */
1708         if (device_property_read_string(dev, "linux,extcon-name", &name) == 0) {
1709                 chip->extcon = extcon_get_extcon_dev(name);
1710                 if (IS_ERR(chip->extcon))
1711                         return PTR_ERR(chip->extcon);
1712         }
1713
1714         chip->vbus = devm_regulator_get(chip->dev, "vbus");
1715         if (IS_ERR(chip->vbus))
1716                 return PTR_ERR(chip->vbus);
1717
1718         chip->wq = create_singlethread_workqueue(dev_name(chip->dev));
1719         if (!chip->wq)
1720                 return -ENOMEM;
1721
1722         spin_lock_init(&chip->irq_lock);
1723         INIT_WORK(&chip->irq_work, fusb302_irq_work);
1724         INIT_DELAYED_WORK(&chip->bc_lvl_handler, fusb302_bc_lvl_handler_work);
1725         init_tcpc_dev(&chip->tcpc_dev);
1726         fusb302_debugfs_init(chip);
1727
1728         if (client->irq) {
1729                 chip->gpio_int_n_irq = client->irq;
1730         } else {
1731                 ret = init_gpio(chip);
1732                 if (ret < 0)
1733                         goto destroy_workqueue;
1734         }
1735
1736         chip->tcpc_dev.fwnode = fusb302_fwnode_get(dev);
1737         if (IS_ERR(chip->tcpc_dev.fwnode)) {
1738                 ret = PTR_ERR(chip->tcpc_dev.fwnode);
1739                 goto destroy_workqueue;
1740         }
1741
1742         chip->tcpm_port = tcpm_register_port(&client->dev, &chip->tcpc_dev);
1743         if (IS_ERR(chip->tcpm_port)) {
1744                 fwnode_handle_put(chip->tcpc_dev.fwnode);
1745                 ret = dev_err_probe(dev, PTR_ERR(chip->tcpm_port),
1746                                     "cannot register tcpm port\n");
1747                 goto destroy_workqueue;
1748         }
1749
1750         ret = request_irq(chip->gpio_int_n_irq, fusb302_irq_intn,
1751                           IRQF_ONESHOT | IRQF_TRIGGER_LOW,
1752                           "fsc_interrupt_int_n", chip);
1753         if (ret < 0) {
1754                 dev_err(dev, "cannot request IRQ for GPIO Int_N, ret=%d", ret);
1755                 goto tcpm_unregister_port;
1756         }
1757         enable_irq_wake(chip->gpio_int_n_irq);
1758         i2c_set_clientdata(client, chip);
1759
1760         return ret;
1761
1762 tcpm_unregister_port:
1763         tcpm_unregister_port(chip->tcpm_port);
1764         fwnode_handle_put(chip->tcpc_dev.fwnode);
1765 destroy_workqueue:
1766         fusb302_debugfs_exit(chip);
1767         destroy_workqueue(chip->wq);
1768
1769         return ret;
1770 }
1771
1772 static void fusb302_remove(struct i2c_client *client)
1773 {
1774         struct fusb302_chip *chip = i2c_get_clientdata(client);
1775
1776         disable_irq_wake(chip->gpio_int_n_irq);
1777         free_irq(chip->gpio_int_n_irq, chip);
1778         cancel_work_sync(&chip->irq_work);
1779         cancel_delayed_work_sync(&chip->bc_lvl_handler);
1780         tcpm_unregister_port(chip->tcpm_port);
1781         fwnode_handle_put(chip->tcpc_dev.fwnode);
1782         destroy_workqueue(chip->wq);
1783         fusb302_debugfs_exit(chip);
1784 }
1785
1786 static int fusb302_pm_suspend(struct device *dev)
1787 {
1788         struct fusb302_chip *chip = dev->driver_data;
1789         unsigned long flags;
1790
1791         spin_lock_irqsave(&chip->irq_lock, flags);
1792         chip->irq_suspended = true;
1793         spin_unlock_irqrestore(&chip->irq_lock, flags);
1794
1795         /* Make sure any pending irq_work is finished before the bus suspends */
1796         flush_work(&chip->irq_work);
1797         return 0;
1798 }
1799
1800 static int fusb302_pm_resume(struct device *dev)
1801 {
1802         struct fusb302_chip *chip = dev->driver_data;
1803         unsigned long flags;
1804
1805         spin_lock_irqsave(&chip->irq_lock, flags);
1806         if (chip->irq_while_suspended) {
1807                 schedule_work(&chip->irq_work);
1808                 chip->irq_while_suspended = false;
1809         }
1810         chip->irq_suspended = false;
1811         spin_unlock_irqrestore(&chip->irq_lock, flags);
1812
1813         return 0;
1814 }
1815
1816 static const struct of_device_id fusb302_dt_match[] __maybe_unused = {
1817         {.compatible = "fcs,fusb302"},
1818         {},
1819 };
1820 MODULE_DEVICE_TABLE(of, fusb302_dt_match);
1821
1822 static const struct i2c_device_id fusb302_i2c_device_id[] = {
1823         { "typec_fusb302" },
1824         {}
1825 };
1826 MODULE_DEVICE_TABLE(i2c, fusb302_i2c_device_id);
1827
1828 static const struct dev_pm_ops fusb302_pm_ops = {
1829         .suspend = fusb302_pm_suspend,
1830         .resume = fusb302_pm_resume,
1831 };
1832
1833 static struct i2c_driver fusb302_driver = {
1834         .driver = {
1835                    .name = "typec_fusb302",
1836                    .pm = &fusb302_pm_ops,
1837                    .of_match_table = of_match_ptr(fusb302_dt_match),
1838                    },
1839         .probe = fusb302_probe,
1840         .remove = fusb302_remove,
1841         .id_table = fusb302_i2c_device_id,
1842 };
1843 module_i2c_driver(fusb302_driver);
1844
1845 MODULE_AUTHOR("Yueyao Zhu <[email protected]>");
1846 MODULE_DESCRIPTION("Fairchild FUSB302 Type-C Chip Driver");
1847 MODULE_LICENSE("GPL");