drivers/i2c/busses/i2c-cht-wc.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Intel CHT Whiskey Cove PMIC I2C controller driver
   4  * Copyright (C) 2017 Hans de Goede <hdegoede@redhat.com>
   5  *
   6  * Based on various non upstream patches to support the CHT Whiskey Cove PMIC:
   7  * Copyright (C) 2011 - 2014 Intel Corporation. All rights reserved.
   8  */
   9
  10 #include <linux/acpi.h>
  11 #include <linux/completion.h>
  12 #include <linux/delay.h>
  13 #include <linux/i2c.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/irq.h>
  16 #include <linux/irqdomain.h>
  17 #include <linux/mfd/intel_soc_pmic.h>
  18 #include <linux/module.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/power/bq24190_charger.h>
  21 #include <linux/power/bq25890_charger.h>
  22 #include <linux/slab.h>
  23
  24 #define CHT_WC_I2C_CTRL                 0x5e24
  25 #define CHT_WC_I2C_CTRL_WR              BIT(0)
  26 #define CHT_WC_I2C_CTRL_RD              BIT(1)
  27 #define CHT_WC_I2C_CLIENT_ADDR          0x5e25
  28 #define CHT_WC_I2C_REG_OFFSET           0x5e26
  29 #define CHT_WC_I2C_WRDATA               0x5e27
  30 #define CHT_WC_I2C_RDDATA               0x5e28
  31
  32 #define CHT_WC_EXTCHGRIRQ               0x6e0a
  33 #define CHT_WC_EXTCHGRIRQ_CLIENT_IRQ    BIT(0)
  34 #define CHT_WC_EXTCHGRIRQ_WRITE_IRQ     BIT(1)
  35 #define CHT_WC_EXTCHGRIRQ_READ_IRQ      BIT(2)
  36 #define CHT_WC_EXTCHGRIRQ_NACK_IRQ      BIT(3)
  37 #define CHT_WC_EXTCHGRIRQ_ADAP_IRQMASK  ((u8)GENMASK(3, 1))
  38 #define CHT_WC_EXTCHGRIRQ_MSK           0x6e17
  39
  40 struct cht_wc_i2c_adap {
  41         struct i2c_adapter adapter;
  42         wait_queue_head_t wait;
  43         struct irq_chip irqchip;
  44         struct mutex adap_lock;
  45         struct mutex irqchip_lock;
  46         struct regmap *regmap;
  47         struct irq_domain *irq_domain;
  48         struct i2c_client *client;
  49         int client_irq;
  50         u8 irq_mask;
  51         u8 old_irq_mask;
  52         int read_data;
  53         bool io_error;
  54         bool done;
  55 };
  56
  57 static irqreturn_t cht_wc_i2c_adap_thread_handler(int id, void *data)
  58 {
  59         struct cht_wc_i2c_adap *adap = data;
  60         int ret, reg;
  61
  62         mutex_lock(&adap->adap_lock);
  63
  64         /* Read IRQs */
  65         ret = regmap_read(adap->regmap, CHT_WC_EXTCHGRIRQ, &reg);
  66         if (ret) {
  67                 dev_err(&adap->adapter.dev, "Error reading extchgrirq reg\n");
  68                 mutex_unlock(&adap->adap_lock);
  69                 return IRQ_NONE;
  70         }
  71
  72         reg &= ~adap->irq_mask;
  73
  74         /* Reads must be acked after reading the received data. */
  75         ret = regmap_read(adap->regmap, CHT_WC_I2C_RDDATA, &adap->read_data);
  76         if (ret)
  77                 adap->io_error = true;
  78
  79         /*
  80          * Immediately ack IRQs, so that if new IRQs arrives while we're
  81          * handling the previous ones our irq will re-trigger when we're done.
  82          */
  83         ret = regmap_write(adap->regmap, CHT_WC_EXTCHGRIRQ, reg);
  84         if (ret)
  85                 dev_err(&adap->adapter.dev, "Error writing extchgrirq reg\n");
  86
  87         if (reg & CHT_WC_EXTCHGRIRQ_ADAP_IRQMASK) {
  88                 adap->io_error |= !!(reg & CHT_WC_EXTCHGRIRQ_NACK_IRQ);
  89                 adap->done = true;
  90         }
  91
  92         mutex_unlock(&adap->adap_lock);
  93
  94         if (reg & CHT_WC_EXTCHGRIRQ_ADAP_IRQMASK)
  95                 wake_up(&adap->wait);
  96
  97         /*
  98          * Do NOT use handle_nested_irq here, the client irq handler will
  99          * likely want to do i2c transfers and the i2c controller uses this
 100          * interrupt handler as well, so running the client irq handler from
 101          * this thread will cause things to lock up.
 102          */
 103         if (reg & CHT_WC_EXTCHGRIRQ_CLIENT_IRQ)
 104                 generic_handle_irq_safe(adap->client_irq);
 105
 106         return IRQ_HANDLED;
 107 }
 108
 109 static u32 cht_wc_i2c_adap_func(struct i2c_adapter *adap)
 110 {
 111         /* This i2c adapter only supports SMBUS byte transfers */
 112         return I2C_FUNC_SMBUS_BYTE_DATA;
 113 }
 114
 115 static int cht_wc_i2c_adap_smbus_xfer(struct i2c_adapter *_adap, u16 addr,
 116                                       unsigned short flags, char read_write,
 117                                       u8 command, int size,
 118                                       union i2c_smbus_data *data)
 119 {
 120         struct cht_wc_i2c_adap *adap = i2c_get_adapdata(_adap);
 121         int ret;
 122
 123         mutex_lock(&adap->adap_lock);
 124         adap->io_error = false;
 125         adap->done = false;
 126         mutex_unlock(&adap->adap_lock);
 127
 128         ret = regmap_write(adap->regmap, CHT_WC_I2C_CLIENT_ADDR, addr);
 129         if (ret)
 130                 return ret;
 131
 132         if (read_write == I2C_SMBUS_WRITE) {
 133                 ret = regmap_write(adap->regmap, CHT_WC_I2C_WRDATA, data->byte);
 134                 if (ret)
 135                         return ret;
 136         }
 137
 138         ret = regmap_write(adap->regmap, CHT_WC_I2C_REG_OFFSET, command);
 139         if (ret)
 140                 return ret;
 141
 142         ret = regmap_write(adap->regmap, CHT_WC_I2C_CTRL,
 143                            (read_write == I2C_SMBUS_WRITE) ?
 144                            CHT_WC_I2C_CTRL_WR : CHT_WC_I2C_CTRL_RD);
 145         if (ret)
 146                 return ret;
 147
 148         ret = wait_event_timeout(adap->wait, adap->done, msecs_to_jiffies(30));
 149         if (ret == 0) {
 150                 /*
 151                  * The CHT GPIO controller serializes all IRQs, sometimes
 152                  * causing significant delays, check status manually.
 153                  */
 154                 cht_wc_i2c_adap_thread_handler(0, adap);
 155                 if (!adap->done)
 156                         return -ETIMEDOUT;
 157         }
 158
 159         ret = 0;
 160         mutex_lock(&adap->adap_lock);
 161         if (adap->io_error)
 162                 ret = -EIO;
 163         else if (read_write == I2C_SMBUS_READ)
 164                 data->byte = adap->read_data;
 165         mutex_unlock(&adap->adap_lock);
 166
 167         return ret;
 168 }
 169
 170 static const struct i2c_algorithm cht_wc_i2c_adap_algo = {
 171         .functionality = cht_wc_i2c_adap_func,
 172         .smbus_xfer = cht_wc_i2c_adap_smbus_xfer,
 173 };
 174
 175 /*
 176  * We are an i2c-adapter which itself is part of an i2c-client. This means that
 177  * transfers done through us take adapter->bus_lock twice, once for our parent
 178  * i2c-adapter and once to take our own bus_lock. Lockdep does not like this
 179  * nested locking, to make lockdep happy in the case of busses with muxes, the
 180  * i2c-core's i2c_adapter_lock_bus function calls:
 181  * rt_mutex_lock_nested(&adapter->bus_lock, i2c_adapter_depth(adapter));
 182  *
 183  * But i2c_adapter_depth only works when the direct parent of the adapter is
 184  * another adapter, as it is only meant for muxes. In our case there is an
 185  * i2c-client and MFD instantiated platform_device in the parent->child chain
 186  * between the 2 devices.
 187  *
 188  * So we override the default i2c_lock_operations and pass a hardcoded
 189  * depth of 1 to rt_mutex_lock_nested, to make lockdep happy.
 190  *
 191  * Note that if there were to be a mux attached to our adapter, this would
 192  * break things again since the i2c-mux code expects the root-adapter to have
 193  * a locking depth of 0. But we always have only 1 client directly attached
 194  * in the form of the Charger IC paired with the CHT Whiskey Cove PMIC.
 195  */
 196 static void cht_wc_i2c_adap_lock_bus(struct i2c_adapter *adapter,
 197                                  unsigned int flags)
 198 {
 199         rt_mutex_lock_nested(&adapter->bus_lock, 1);
 200 }
 201
 202 static int cht_wc_i2c_adap_trylock_bus(struct i2c_adapter *adapter,
 203                                    unsigned int flags)
 204 {
 205         return rt_mutex_trylock(&adapter->bus_lock);
 206 }
 207
 208 static void cht_wc_i2c_adap_unlock_bus(struct i2c_adapter *adapter,
 209                                    unsigned int flags)
 210 {
 211         rt_mutex_unlock(&adapter->bus_lock);
 212 }
 213
 214 static const struct i2c_lock_operations cht_wc_i2c_adap_lock_ops = {
 215         .lock_bus =    cht_wc_i2c_adap_lock_bus,
 216         .trylock_bus = cht_wc_i2c_adap_trylock_bus,
 217         .unlock_bus =  cht_wc_i2c_adap_unlock_bus,
 218 };
 219
 220 /**** irqchip for the client connected to the extchgr i2c adapter ****/
 221 static void cht_wc_i2c_irq_lock(struct irq_data *data)
 222 {
 223         struct cht_wc_i2c_adap *adap = irq_data_get_irq_chip_data(data);
 224
 225         mutex_lock(&adap->irqchip_lock);
 226 }
 227
 228 static void cht_wc_i2c_irq_sync_unlock(struct irq_data *data)
 229 {
 230         struct cht_wc_i2c_adap *adap = irq_data_get_irq_chip_data(data);
 231         int ret;
 232
 233         if (adap->irq_mask != adap->old_irq_mask) {
 234                 ret = regmap_write(adap->regmap, CHT_WC_EXTCHGRIRQ_MSK,
 235                                    adap->irq_mask);
 236                 if (ret == 0)
 237                         adap->old_irq_mask = adap->irq_mask;
 238                 else
 239                         dev_err(&adap->adapter.dev, "Error writing EXTCHGRIRQ_MSK\n");
 240         }
 241
 242         mutex_unlock(&adap->irqchip_lock);
 243 }
 244
 245 static void cht_wc_i2c_irq_enable(struct irq_data *data)
 246 {
 247         struct cht_wc_i2c_adap *adap = irq_data_get_irq_chip_data(data);
 248
 249         adap->irq_mask &= ~CHT_WC_EXTCHGRIRQ_CLIENT_IRQ;
 250 }
 251
 252 static void cht_wc_i2c_irq_disable(struct irq_data *data)
 253 {
 254         struct cht_wc_i2c_adap *adap = irq_data_get_irq_chip_data(data);
 255
 256         adap->irq_mask |= CHT_WC_EXTCHGRIRQ_CLIENT_IRQ;
 257 }
 258
 259 static const struct irq_chip cht_wc_i2c_irq_chip = {
 260         .irq_bus_lock           = cht_wc_i2c_irq_lock,
 261         .irq_bus_sync_unlock    = cht_wc_i2c_irq_sync_unlock,
 262         .irq_disable            = cht_wc_i2c_irq_disable,
 263         .irq_enable             = cht_wc_i2c_irq_enable,
 264         .name                   = "cht_wc_ext_chrg_irq_chip",
 265 };
 266
 267 /********** GPD Win / Pocket charger IC settings **********/
 268 static const char * const bq24190_suppliers[] = {
 269         "tcpm-source-psy-i2c-fusb302" };
 270
 271 static const struct property_entry bq24190_props[] = {
 272         PROPERTY_ENTRY_STRING_ARRAY("supplied-from", bq24190_suppliers),
 273         PROPERTY_ENTRY_BOOL("omit-battery-class"),
 274         PROPERTY_ENTRY_BOOL("disable-reset"),
 275         { }
 276 };
 277
 278 static const struct software_node bq24190_node = {
 279         .properties = bq24190_props,
 280 };
 281
 282 static struct regulator_consumer_supply fusb302_consumer = {
 283         .supply = "vbus",
 284         /* Must match fusb302 dev_name in intel_cht_int33fe.c */
 285         .dev_name = "i2c-fusb302",
 286 };
 287
 288 static const struct regulator_init_data bq24190_vbus_init_data = {
 289         .constraints = {
 290                 /* The name is used in intel_cht_int33fe.c do not change. */
 291                 .name = "cht_wc_usb_typec_vbus",
 292                 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
 293         },
 294         .consumer_supplies = &fusb302_consumer,
 295         .num_consumer_supplies = 1,
 296 };
 297
 298 static struct bq24190_platform_data bq24190_pdata = {
 299         .regulator_init_data = &bq24190_vbus_init_data,
 300 };
 301
 302 static struct i2c_board_info gpd_win_board_info = {
 303         .type = "bq24190",
 304         .addr = 0x6b,
 305         .dev_name = "bq24190",
 306         .swnode = &bq24190_node,
 307         .platform_data = &bq24190_pdata,
 308 };
 309
 310 /********** Xiaomi Mi Pad 2 charger IC settings  **********/
 311 static struct regulator_consumer_supply bq2589x_vbus_consumer = {
 312         .supply = "vbus",
 313         .dev_name = "cht_wcove_pwrsrc",
 314 };
 315
 316 static const struct regulator_init_data bq2589x_vbus_init_data = {
 317         .constraints = {
 318                 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
 319         },
 320         .consumer_supplies = &bq2589x_vbus_consumer,
 321         .num_consumer_supplies = 1,
 322 };
 323
 324 static struct bq25890_platform_data bq2589x_pdata = {
 325         .regulator_init_data = &bq2589x_vbus_init_data,
 326 };
 327
 328 static const struct property_entry xiaomi_mipad2_props[] = {
 329         PROPERTY_ENTRY_BOOL("linux,skip-reset"),
 330         PROPERTY_ENTRY_BOOL("linux,read-back-settings"),
 331         { }
 332 };
 333
 334 static const struct software_node xiaomi_mipad2_node = {
 335         .properties = xiaomi_mipad2_props,
 336 };
 337
 338 static struct i2c_board_info xiaomi_mipad2_board_info = {
 339         .type = "bq25890",
 340         .addr = 0x6a,
 341         .dev_name = "bq25890",
 342         .swnode = &xiaomi_mipad2_node,
 343         .platform_data = &bq2589x_pdata,
 344 };
 345
 346 /********** Lenovo Yogabook YB1-X90F/-X91F/-X91L charger settings **********/
 347 static const char * const lenovo_yb1_bq25892_suppliers[] = { "cht_wcove_pwrsrc" };
 348
 349 static const struct property_entry lenovo_yb1_bq25892_props[] = {
 350         PROPERTY_ENTRY_STRING_ARRAY("supplied-from",
 351                                     lenovo_yb1_bq25892_suppliers),
 352         PROPERTY_ENTRY_U32("linux,pump-express-vbus-max", 12000000),
 353         PROPERTY_ENTRY_BOOL("linux,skip-reset"),
 354         /*
 355          * The firmware sets everything to the defaults, which leads to a
 356          * somewhat low charge-current of 2048mA and worse to a battery-voltage
 357          * of 4.2V instead of 4.35V (when booted without a charger connected).
 358          * Use our own values instead of "linux,read-back-settings" to fix this.
 359          */
 360         PROPERTY_ENTRY_U32("ti,charge-current", 4224000),
 361         PROPERTY_ENTRY_U32("ti,battery-regulation-voltage", 4352000),
 362         PROPERTY_ENTRY_U32("ti,termination-current", 256000),
 363         PROPERTY_ENTRY_U32("ti,precharge-current", 128000),
 364         PROPERTY_ENTRY_U32("ti,minimum-sys-voltage", 3500000),
 365         PROPERTY_ENTRY_U32("ti,boost-voltage", 4998000),
 366         PROPERTY_ENTRY_U32("ti,boost-max-current", 1400000),
 367         PROPERTY_ENTRY_BOOL("ti,use-ilim-pin"),
 368         { }
 369 };
 370
 371 static const struct software_node lenovo_yb1_bq25892_node = {
 372         .properties = lenovo_yb1_bq25892_props,
 373 };
 374
 375 static struct i2c_board_info lenovo_yogabook1_board_info = {
 376         .type = "bq25892",
 377         .addr = 0x6b,
 378         .dev_name = "bq25892",
 379         .swnode = &lenovo_yb1_bq25892_node,
 380         .platform_data = &bq2589x_pdata,
 381 };
 382
 383 /********** Lenovo Yogabook YT3-X90F charger settings **********/
 384 static const char * const lenovo_yt3_bq25892_1_suppliers[] = { "cht_wcove_pwrsrc" };
 385
 386 /*
 387  * bq25892 charger settings for the round li-ion cells in the hinge,
 388  * this is the main / biggest battery.
 389  */
 390 static const struct property_entry lenovo_yt3_bq25892_1_props[] = {
 391         PROPERTY_ENTRY_STRING_ARRAY("supplied-from", lenovo_yt3_bq25892_1_suppliers),
 392         PROPERTY_ENTRY_STRING("linux,secondary-charger-name", "bq25890-charger-0"),
 393         PROPERTY_ENTRY_U32("linux,iinlim-percentage", 60),
 394         PROPERTY_ENTRY_U32("linux,pump-express-vbus-max", 12000000),
 395         PROPERTY_ENTRY_BOOL("linux,skip-reset"),
 396         /*
 397          * The firmware sets everything to the defaults, leading to a low(ish)
 398          * charge-current and battery-voltage of 2048mA resp 4.2V. Use the
 399          * Android values instead of "linux,read-back-settings" to fix this.
 400          */
 401         PROPERTY_ENTRY_U32("ti,charge-current", 3072000),
 402         PROPERTY_ENTRY_U32("ti,battery-regulation-voltage", 4352000),
 403         PROPERTY_ENTRY_U32("ti,termination-current", 128000),
 404         PROPERTY_ENTRY_U32("ti,precharge-current", 128000),
 405         PROPERTY_ENTRY_U32("ti,minimum-sys-voltage", 3700000),
 406         PROPERTY_ENTRY_BOOL("ti,use-ilim-pin"),
 407         /* Set 5V boost current-limit to 1.2A (MAX/POR values are 2.45A/1.4A) */
 408         PROPERTY_ENTRY_U32("ti,boost-voltage", 4998000),
 409         PROPERTY_ENTRY_U32("ti,boost-max-current", 1200000),
 410         { }
 411 };
 412
 413 static const struct software_node lenovo_yt3_bq25892_1_node = {
 414         .properties = lenovo_yt3_bq25892_1_props,
 415 };
 416
 417 /* bq25892 charger for the round li-ion cells in the hinge */
 418 static struct i2c_board_info lenovo_yoga_tab3_board_info = {
 419         .type = "bq25892",
 420         .addr = 0x6b,
 421         .dev_name = "bq25892_1",
 422         .swnode = &lenovo_yt3_bq25892_1_node,
 423         .platform_data = &bq2589x_pdata,
 424 };
 425
 426 static int cht_wc_i2c_adap_i2c_probe(struct platform_device *pdev)
 427 {
 428         struct intel_soc_pmic *pmic = dev_get_drvdata(pdev->dev.parent);
 429         struct i2c_board_info *board_info = NULL;
 430         struct cht_wc_i2c_adap *adap;
 431         int ret, reg, irq;
 432
 433         irq = platform_get_irq(pdev, 0);
 434         if (irq < 0)
 435                 return irq;
 436
 437         adap = devm_kzalloc(&pdev->dev, sizeof(*adap), GFP_KERNEL);
 438         if (!adap)
 439                 return -ENOMEM;
 440
 441         init_waitqueue_head(&adap->wait);
 442         mutex_init(&adap->adap_lock);
 443         mutex_init(&adap->irqchip_lock);
 444         adap->irqchip = cht_wc_i2c_irq_chip;
 445         adap->regmap = pmic->regmap;
 446         adap->adapter.owner = THIS_MODULE;
 447         adap->adapter.class = I2C_CLASS_HWMON;
 448         adap->adapter.algo = &cht_wc_i2c_adap_algo;
 449         adap->adapter.lock_ops = &cht_wc_i2c_adap_lock_ops;
 450         strscpy(adap->adapter.name, "PMIC I2C Adapter",
 451                 sizeof(adap->adapter.name));
 452         adap->adapter.dev.parent = &pdev->dev;
 453
 454         /* Clear and activate i2c-adapter interrupts, disable client IRQ */
 455         adap->old_irq_mask = adap->irq_mask = ~CHT_WC_EXTCHGRIRQ_ADAP_IRQMASK;
 456
 457         ret = regmap_read(adap->regmap, CHT_WC_I2C_RDDATA, &reg);
 458         if (ret)
 459                 return ret;
 460
 461         ret = regmap_write(adap->regmap, CHT_WC_EXTCHGRIRQ, ~adap->irq_mask);
 462         if (ret)
 463                 return ret;
 464
 465         ret = regmap_write(adap->regmap, CHT_WC_EXTCHGRIRQ_MSK, adap->irq_mask);
 466         if (ret)
 467                 return ret;
 468
 469         /* Alloc and register client IRQ */
 470         adap->irq_domain = irq_domain_add_linear(NULL, 1, &irq_domain_simple_ops, NULL);
 471         if (!adap->irq_domain)
 472                 return -ENOMEM;
 473
 474         adap->client_irq = irq_create_mapping(adap->irq_domain, 0);
 475         if (!adap->client_irq) {
 476                 ret = -ENOMEM;
 477                 goto remove_irq_domain;
 478         }
 479
 480         irq_set_chip_data(adap->client_irq, adap);
 481         irq_set_chip_and_handler(adap->client_irq, &adap->irqchip,
 482                                  handle_simple_irq);
 483
 484         ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
 485                                         cht_wc_i2c_adap_thread_handler,
 486                                         IRQF_ONESHOT, "PMIC I2C Adapter", adap);
 487         if (ret)
 488                 goto remove_irq_domain;
 489
 490         i2c_set_adapdata(&adap->adapter, adap);
 491         ret = i2c_add_adapter(&adap->adapter);
 492         if (ret)
 493                 goto remove_irq_domain;
 494
 495         switch (pmic->cht_wc_model) {
 496         case INTEL_CHT_WC_GPD_WIN_POCKET:
 497                 board_info = &gpd_win_board_info;
 498                 break;
 499         case INTEL_CHT_WC_XIAOMI_MIPAD2:
 500                 board_info = &xiaomi_mipad2_board_info;
 501                 break;
 502         case INTEL_CHT_WC_LENOVO_YOGABOOK1:
 503                 board_info = &lenovo_yogabook1_board_info;
 504                 break;
 505         case INTEL_CHT_WC_LENOVO_YT3_X90:
 506                 board_info = &lenovo_yoga_tab3_board_info;
 507                 break;
 508         default:
 509                 dev_warn(&pdev->dev, "Unknown model, not instantiating charger device\n");
 510                 break;
 511         }
 512
 513         if (board_info) {
 514                 board_info->irq = adap->client_irq;
 515                 adap->client = i2c_new_client_device(&adap->adapter, board_info);
 516                 if (IS_ERR(adap->client)) {
 517                         ret = PTR_ERR(adap->client);
 518                         goto del_adapter;
 519                 }
 520         }
 521
 522         platform_set_drvdata(pdev, adap);
 523         return 0;
 524
 525 del_adapter:
 526         i2c_del_adapter(&adap->adapter);
 527 remove_irq_domain:
 528         irq_domain_remove(adap->irq_domain);
 529         return ret;
 530 }
 531
 532 static void cht_wc_i2c_adap_i2c_remove(struct platform_device *pdev)
 533 {
 534         struct cht_wc_i2c_adap *adap = platform_get_drvdata(pdev);
 535
 536         i2c_unregister_device(adap->client);
 537         i2c_del_adapter(&adap->adapter);
 538         irq_domain_remove(adap->irq_domain);
 539 }
 540
 541 static const struct platform_device_id cht_wc_i2c_adap_id_table[] = {
 542         { .name = "cht_wcove_ext_chgr" },
 543         {},
 544 };
 545 MODULE_DEVICE_TABLE(platform, cht_wc_i2c_adap_id_table);
 546
 547 static struct platform_driver cht_wc_i2c_adap_driver = {
 548         .probe = cht_wc_i2c_adap_i2c_probe,
 549         .remove = cht_wc_i2c_adap_i2c_remove,
 550         .driver = {
 551                 .name = "cht_wcove_ext_chgr",
 552         },
 553         .id_table = cht_wc_i2c_adap_id_table,
 554 };
 555 module_platform_driver(cht_wc_i2c_adap_driver);
 556
 557 MODULE_DESCRIPTION("Intel CHT Whiskey Cove PMIC I2C controller driver");
 558 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
 559 MODULE_LICENSE("GPL");