drivers/i2c/busses/i2c-amd-mp2-plat.c

   1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
   2 /*
   3  * AMD MP2 platform driver
   4  *
   5  * Setup the I2C adapters enumerated in the ACPI namespace.
   6  * MP2 controllers have 2 separate busses, up to 2 I2C adapters may be listed.
   7  *
   8  * Authors: Nehal Bakulchandra Shah <Nehal-bakulchandra.shah@amd.com>
   9  *          Elie Morisse <syniurge@gmail.com>
  10  */
  11
  12 #include <linux/acpi.h>
  13 #include <linux/kernel.h>
  14 #include <linux/module.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/slab.h>
  17 #include <linux/types.h>
  18
  19 #include "i2c-amd-mp2.h"
  20
  21 #define AMD_MP2_I2C_MAX_RW_LENGTH ((1 << 12) - 1)
  22 #define AMD_I2C_TIMEOUT (msecs_to_jiffies(250))
  23
  24 /**
  25  * struct amd_i2c_dev - MP2 bus/i2c adapter context
  26  * @common: shared context with the MP2 PCI driver
  27  * @pdev: platform driver node
  28  * @adap: i2c adapter
  29  * @cmd_complete: xfer completion object
  30  */
  31 struct amd_i2c_dev {
  32         struct amd_i2c_common common;
  33         struct platform_device *pdev;
  34         struct i2c_adapter adap;
  35         struct completion cmd_complete;
  36 };
  37
  38 #define amd_i2c_dev_common(__common) \
  39         container_of(__common, struct amd_i2c_dev, common)
  40
  41 static int i2c_amd_dma_map(struct amd_i2c_common *i2c_common)
  42 {
  43         struct device *dev_pci = &i2c_common->mp2_dev->pci_dev->dev;
  44         struct amd_i2c_dev *i2c_dev = amd_i2c_dev_common(i2c_common);
  45         enum dma_data_direction dma_direction =
  46                         i2c_common->msg->flags & I2C_M_RD ?
  47                         DMA_FROM_DEVICE : DMA_TO_DEVICE;
  48
  49         i2c_common->dma_buf = i2c_get_dma_safe_msg_buf(i2c_common->msg, 0);
  50         i2c_common->dma_addr = dma_map_single(dev_pci, i2c_common->dma_buf,
  51                                               i2c_common->msg->len,
  52                                               dma_direction);
  53
  54         if (unlikely(dma_mapping_error(dev_pci, i2c_common->dma_addr))) {
  55                 dev_err(&i2c_dev->pdev->dev,
  56                         "Error while mapping dma buffer %p\n",
  57                         i2c_common->dma_buf);
  58                 return -EIO;
  59         }
  60
  61         return 0;
  62 }
  63
  64 static void i2c_amd_dma_unmap(struct amd_i2c_common *i2c_common)
  65 {
  66         struct device *dev_pci = &i2c_common->mp2_dev->pci_dev->dev;
  67         enum dma_data_direction dma_direction =
  68                         i2c_common->msg->flags & I2C_M_RD ?
  69                         DMA_FROM_DEVICE : DMA_TO_DEVICE;
  70
  71         dma_unmap_single(dev_pci, i2c_common->dma_addr,
  72                          i2c_common->msg->len, dma_direction);
  73
  74         i2c_put_dma_safe_msg_buf(i2c_common->dma_buf, i2c_common->msg, true);
  75 }
  76
  77 static void i2c_amd_start_cmd(struct amd_i2c_dev *i2c_dev)
  78 {
  79         struct amd_i2c_common *i2c_common = &i2c_dev->common;
  80
  81         reinit_completion(&i2c_dev->cmd_complete);
  82         i2c_common->cmd_success = false;
  83 }
  84
  85 static void i2c_amd_cmd_completion(struct amd_i2c_common *i2c_common)
  86 {
  87         struct amd_i2c_dev *i2c_dev = amd_i2c_dev_common(i2c_common);
  88         union i2c_event *event = &i2c_common->eventval;
  89
  90         if (event->r.status == i2c_readcomplete_event)
  91                 dev_dbg(&i2c_dev->pdev->dev, "%s readdata:%*ph\n",
  92                         __func__, event->r.length,
  93                         i2c_common->msg->buf);
  94
  95         complete(&i2c_dev->cmd_complete);
  96 }
  97
  98 static int i2c_amd_check_cmd_completion(struct amd_i2c_dev *i2c_dev)
  99 {
 100         struct amd_i2c_common *i2c_common = &i2c_dev->common;
 101         unsigned long timeout;
 102
 103         timeout = wait_for_completion_timeout(&i2c_dev->cmd_complete,
 104                                               i2c_dev->adap.timeout);
 105
 106         if ((i2c_common->reqcmd == i2c_read ||
 107              i2c_common->reqcmd == i2c_write) &&
 108             i2c_common->msg->len > 32)
 109                 i2c_amd_dma_unmap(i2c_common);
 110
 111         if (timeout == 0) {
 112                 amd_mp2_rw_timeout(i2c_common);
 113                 return -ETIMEDOUT;
 114         }
 115
 116         amd_mp2_process_event(i2c_common);
 117
 118         if (!i2c_common->cmd_success)
 119                 return -EIO;
 120
 121         return 0;
 122 }
 123
 124 static int i2c_amd_enable_set(struct amd_i2c_dev *i2c_dev, bool enable)
 125 {
 126         struct amd_i2c_common *i2c_common = &i2c_dev->common;
 127
 128         i2c_amd_start_cmd(i2c_dev);
 129         amd_mp2_bus_enable_set(i2c_common, enable);
 130
 131         return i2c_amd_check_cmd_completion(i2c_dev);
 132 }
 133
 134 static int i2c_amd_xfer_msg(struct amd_i2c_dev *i2c_dev, struct i2c_msg *pmsg)
 135 {
 136         struct amd_i2c_common *i2c_common = &i2c_dev->common;
 137
 138         i2c_amd_start_cmd(i2c_dev);
 139         i2c_common->msg = pmsg;
 140
 141         if (pmsg->len > 32)
 142                 if (i2c_amd_dma_map(i2c_common))
 143                         return -EIO;
 144
 145         if (pmsg->flags & I2C_M_RD)
 146                 amd_mp2_rw(i2c_common, i2c_read);
 147         else
 148                 amd_mp2_rw(i2c_common, i2c_write);
 149
 150         return i2c_amd_check_cmd_completion(i2c_dev);
 151 }
 152
 153 static int i2c_amd_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
 154 {
 155         struct amd_i2c_dev *i2c_dev = i2c_get_adapdata(adap);
 156         int i;
 157         struct i2c_msg *pmsg;
 158         int err;
 159
 160         /* the adapter might have been deleted while waiting for the bus lock */
 161         if (unlikely(!i2c_dev->common.mp2_dev))
 162                 return -EINVAL;
 163
 164         amd_mp2_pm_runtime_get(i2c_dev->common.mp2_dev);
 165
 166         for (i = 0; i < num; i++) {
 167                 pmsg = &msgs[i];
 168                 err = i2c_amd_xfer_msg(i2c_dev, pmsg);
 169                 if (err)
 170                         break;
 171         }
 172
 173         amd_mp2_pm_runtime_put(i2c_dev->common.mp2_dev);
 174         return err ? err : num;
 175 }
 176
 177 static u32 i2c_amd_func(struct i2c_adapter *a)
 178 {
 179         return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
 180 }
 181
 182 static const struct i2c_algorithm i2c_amd_algorithm = {
 183         .master_xfer = i2c_amd_xfer,
 184         .functionality = i2c_amd_func,
 185 };
 186
 187 #ifdef CONFIG_PM
 188 static int i2c_amd_suspend(struct amd_i2c_common *i2c_common)
 189 {
 190         struct amd_i2c_dev *i2c_dev = amd_i2c_dev_common(i2c_common);
 191
 192         i2c_amd_enable_set(i2c_dev, false);
 193         return 0;
 194 }
 195
 196 static int i2c_amd_resume(struct amd_i2c_common *i2c_common)
 197 {
 198         struct amd_i2c_dev *i2c_dev = amd_i2c_dev_common(i2c_common);
 199
 200         return i2c_amd_enable_set(i2c_dev, true);
 201 }
 202 #endif
 203
 204 static const u32 supported_speeds[] = {
 205         I2C_MAX_HIGH_SPEED_MODE_FREQ,
 206         I2C_MAX_TURBO_MODE_FREQ,
 207         I2C_MAX_FAST_MODE_PLUS_FREQ,
 208         I2C_MAX_FAST_MODE_FREQ,
 209         I2C_MAX_STANDARD_MODE_FREQ,
 210 };
 211
 212 static enum speed_enum i2c_amd_get_bus_speed(struct platform_device *pdev)
 213 {
 214         u32 acpi_speed;
 215         int i;
 216
 217         acpi_speed = i2c_acpi_find_bus_speed(&pdev->dev);
 218         /* round down to the lowest standard speed */
 219         for (i = 0; i < ARRAY_SIZE(supported_speeds); i++) {
 220                 if (acpi_speed >= supported_speeds[i])
 221                         break;
 222         }
 223         acpi_speed = i < ARRAY_SIZE(supported_speeds) ? supported_speeds[i] : 0;
 224
 225         switch (acpi_speed) {
 226         case I2C_MAX_STANDARD_MODE_FREQ:
 227                 return speed100k;
 228         case I2C_MAX_FAST_MODE_FREQ:
 229                 return speed400k;
 230         case I2C_MAX_FAST_MODE_PLUS_FREQ:
 231                 return speed1000k;
 232         case I2C_MAX_TURBO_MODE_FREQ:
 233                 return speed1400k;
 234         case I2C_MAX_HIGH_SPEED_MODE_FREQ:
 235                 return speed3400k;
 236         default:
 237                 return speed400k;
 238         }
 239 }
 240
 241 static const struct i2c_adapter_quirks amd_i2c_dev_quirks = {
 242         .max_read_len = AMD_MP2_I2C_MAX_RW_LENGTH,
 243         .max_write_len = AMD_MP2_I2C_MAX_RW_LENGTH,
 244 };
 245
 246 static int i2c_amd_probe(struct platform_device *pdev)
 247 {
 248         int ret;
 249         struct amd_i2c_dev *i2c_dev;
 250         acpi_handle handle = ACPI_HANDLE(&pdev->dev);
 251         struct acpi_device *adev;
 252         struct amd_mp2_dev *mp2_dev;
 253         const char *uid;
 254
 255         if (acpi_bus_get_device(handle, &adev))
 256                 return -ENODEV;
 257
 258         /* The ACPI namespace doesn't contain information about which MP2 PCI
 259          * device an AMDI0011 ACPI device is related to, so assume that there's
 260          * only one MP2 PCI device per system.
 261          */
 262         mp2_dev = amd_mp2_find_device();
 263         if (!mp2_dev || !mp2_dev->probed)
 264                 /* The MP2 PCI device should get probed later */
 265                 return -EPROBE_DEFER;
 266
 267         i2c_dev = devm_kzalloc(&pdev->dev, sizeof(*i2c_dev), GFP_KERNEL);
 268         if (!i2c_dev)
 269                 return -ENOMEM;
 270
 271         i2c_dev->common.mp2_dev = mp2_dev;
 272         i2c_dev->pdev = pdev;
 273         platform_set_drvdata(pdev, i2c_dev);
 274
 275         i2c_dev->common.cmd_completion = &i2c_amd_cmd_completion;
 276 #ifdef CONFIG_PM
 277         i2c_dev->common.suspend = &i2c_amd_suspend;
 278         i2c_dev->common.resume = &i2c_amd_resume;
 279 #endif
 280
 281         uid = adev->pnp.unique_id;
 282         if (!uid) {
 283                 dev_err(&pdev->dev, "missing UID/bus id!\n");
 284                 return -EINVAL;
 285         } else if (strcmp(uid, "0") == 0) {
 286                 i2c_dev->common.bus_id = 0;
 287         } else if (strcmp(uid, "1") == 0) {
 288                 i2c_dev->common.bus_id = 1;
 289         } else {
 290                 dev_err(&pdev->dev, "incorrect UID/bus id \"%s\"!\n", uid);
 291                 return -EINVAL;
 292         }
 293         dev_dbg(&pdev->dev, "bus id is %u\n", i2c_dev->common.bus_id);
 294
 295         /* Register the adapter */
 296         amd_mp2_pm_runtime_get(mp2_dev);
 297
 298         i2c_dev->common.reqcmd = i2c_none;
 299         if (amd_mp2_register_cb(&i2c_dev->common))
 300                 return -EINVAL;
 301         device_link_add(&i2c_dev->pdev->dev, &mp2_dev->pci_dev->dev,
 302                         DL_FLAG_AUTOREMOVE_CONSUMER);
 303
 304         i2c_dev->common.i2c_speed = i2c_amd_get_bus_speed(pdev);
 305
 306         /* Setup i2c adapter description */
 307         i2c_dev->adap.owner = THIS_MODULE;
 308         i2c_dev->adap.algo = &i2c_amd_algorithm;
 309         i2c_dev->adap.quirks = &amd_i2c_dev_quirks;
 310         i2c_dev->adap.dev.parent = &pdev->dev;
 311         i2c_dev->adap.algo_data = i2c_dev;
 312         i2c_dev->adap.timeout = AMD_I2C_TIMEOUT;
 313         ACPI_COMPANION_SET(&i2c_dev->adap.dev, ACPI_COMPANION(&pdev->dev));
 314         i2c_dev->adap.dev.of_node = pdev->dev.of_node;
 315         snprintf(i2c_dev->adap.name, sizeof(i2c_dev->adap.name),
 316                  "AMD MP2 i2c bus %u", i2c_dev->common.bus_id);
 317         i2c_set_adapdata(&i2c_dev->adap, i2c_dev);
 318
 319         init_completion(&i2c_dev->cmd_complete);
 320
 321         /* Enable the bus */
 322         if (i2c_amd_enable_set(i2c_dev, true))
 323                 dev_err(&pdev->dev, "initial bus enable failed\n");
 324
 325         /* Attach to the i2c layer */
 326         ret = i2c_add_adapter(&i2c_dev->adap);
 327
 328         amd_mp2_pm_runtime_put(mp2_dev);
 329
 330         if (ret < 0)
 331                 dev_err(&pdev->dev, "i2c add adapter failed = %d\n", ret);
 332
 333         return ret;
 334 }
 335
 336 static int i2c_amd_remove(struct platform_device *pdev)
 337 {
 338         struct amd_i2c_dev *i2c_dev = platform_get_drvdata(pdev);
 339         struct amd_i2c_common *i2c_common = &i2c_dev->common;
 340
 341         i2c_lock_bus(&i2c_dev->adap, I2C_LOCK_ROOT_ADAPTER);
 342
 343         i2c_amd_enable_set(i2c_dev, false);
 344         amd_mp2_unregister_cb(i2c_common);
 345         i2c_common->mp2_dev = NULL;
 346
 347         i2c_unlock_bus(&i2c_dev->adap, I2C_LOCK_ROOT_ADAPTER);
 348
 349         i2c_del_adapter(&i2c_dev->adap);
 350         return 0;
 351 }
 352
 353 static const struct acpi_device_id i2c_amd_acpi_match[] = {
 354         { "AMDI0011" },
 355         { },
 356 };
 357 MODULE_DEVICE_TABLE(acpi, i2c_amd_acpi_match);
 358
 359 static struct platform_driver i2c_amd_plat_driver = {
 360         .probe = i2c_amd_probe,
 361         .remove = i2c_amd_remove,
 362         .driver = {
 363                 .name = "i2c_amd_mp2",
 364                 .acpi_match_table = ACPI_PTR(i2c_amd_acpi_match),
 365         },
 366 };
 367 module_platform_driver(i2c_amd_plat_driver);
 368
 369 MODULE_DESCRIPTION("AMD(R) MP2 I2C Platform Driver");
 370 MODULE_AUTHOR("Nehal Shah <nehal-bakulchandra.shah@amd.com>");
 371 MODULE_AUTHOR("Elie Morisse <syniurge@gmail.com>");
 372 MODULE_LICENSE("Dual BSD/GPL");