drivers/i2c/i2c-slave-eeprom.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * I2C slave mode EEPROM simulator
   4  *
   5  * Copyright (C) 2014 by Wolfram Sang, Sang Engineering <[email protected]>
   6  * Copyright (C) 2014 by Renesas Electronics Corporation
   7  *
   8  * Because most IP blocks can only detect one I2C slave address anyhow, this
   9  * driver does not support simulating EEPROM types which take more than one
  10  * address. It is prepared to simulate bigger EEPROMs with an internal 16 bit
  11  * pointer, yet implementation is deferred until the need actually arises.
  12  */
  13
  14 #include <linux/i2c.h>
  15 #include <linux/init.h>
  16 #include <linux/module.h>
  17 #include <linux/of.h>
  18 #include <linux/slab.h>
  19 #include <linux/spinlock.h>
  20 #include <linux/sysfs.h>
  21
  22 struct eeprom_data {
  23         struct bin_attribute bin;
  24         bool first_write;
  25         spinlock_t buffer_lock;
  26         u8 buffer_idx;
  27         u8 buffer[];
  28 };
  29
  30 static int i2c_slave_eeprom_slave_cb(struct i2c_client *client,
  31                                      enum i2c_slave_event event, u8 *val)
  32 {
  33         struct eeprom_data *eeprom = i2c_get_clientdata(client);
  34
  35         switch (event) {
  36         case I2C_SLAVE_WRITE_RECEIVED:
  37                 if (eeprom->first_write) {
  38                         eeprom->buffer_idx = *val;
  39                         eeprom->first_write = false;
  40                 } else {
  41                         spin_lock(&eeprom->buffer_lock);
  42                         eeprom->buffer[eeprom->buffer_idx++] = *val;
  43                         spin_unlock(&eeprom->buffer_lock);
  44                 }
  45                 break;
  46
  47         case I2C_SLAVE_READ_PROCESSED:
  48                 /* The previous byte made it to the bus, get next one */
  49                 eeprom->buffer_idx++;
  50                 /* fallthrough */
  51         case I2C_SLAVE_READ_REQUESTED:
  52                 spin_lock(&eeprom->buffer_lock);
  53                 *val = eeprom->buffer[eeprom->buffer_idx];
  54                 spin_unlock(&eeprom->buffer_lock);
  55                 /*
  56                  * Do not increment buffer_idx here, because we don't know if
  57                  * this byte will be actually used. Read Linux I2C slave docs
  58                  * for details.
  59                  */
  60                 break;
  61
  62         case I2C_SLAVE_STOP:
  63         case I2C_SLAVE_WRITE_REQUESTED:
  64                 eeprom->first_write = true;
  65                 break;
  66
  67         default:
  68                 break;
  69         }
  70
  71         return 0;
  72 }
  73
  74 static ssize_t i2c_slave_eeprom_bin_read(struct file *filp, struct kobject *kobj,
  75                 struct bin_attribute *attr, char *buf, loff_t off, size_t count)
  76 {
  77         struct eeprom_data *eeprom;
  78         unsigned long flags;
  79
  80         eeprom = dev_get_drvdata(container_of(kobj, struct device, kobj));
  81
  82         spin_lock_irqsave(&eeprom->buffer_lock, flags);
  83         memcpy(buf, &eeprom->buffer[off], count);
  84         spin_unlock_irqrestore(&eeprom->buffer_lock, flags);
  85
  86         return count;
  87 }
  88
  89 static ssize_t i2c_slave_eeprom_bin_write(struct file *filp, struct kobject *kobj,
  90                 struct bin_attribute *attr, char *buf, loff_t off, size_t count)
  91 {
  92         struct eeprom_data *eeprom;
  93         unsigned long flags;
  94
  95         eeprom = dev_get_drvdata(container_of(kobj, struct device, kobj));
  96
  97         spin_lock_irqsave(&eeprom->buffer_lock, flags);
  98         memcpy(&eeprom->buffer[off], buf, count);
  99         spin_unlock_irqrestore(&eeprom->buffer_lock, flags);
 100
 101         return count;
 102 }
 103
 104 static int i2c_slave_eeprom_probe(struct i2c_client *client, const struct i2c_device_id *id)
 105 {
 106         struct eeprom_data *eeprom;
 107         int ret;
 108         unsigned size = id->driver_data;
 109
 110         eeprom = devm_kzalloc(&client->dev, sizeof(struct eeprom_data) + size, GFP_KERNEL);
 111         if (!eeprom)
 112                 return -ENOMEM;
 113
 114         eeprom->first_write = true;
 115         spin_lock_init(&eeprom->buffer_lock);
 116         i2c_set_clientdata(client, eeprom);
 117
 118         sysfs_bin_attr_init(&eeprom->bin);
 119         eeprom->bin.attr.name = "slave-eeprom";
 120         eeprom->bin.attr.mode = S_IRUSR | S_IWUSR;
 121         eeprom->bin.read = i2c_slave_eeprom_bin_read;
 122         eeprom->bin.write = i2c_slave_eeprom_bin_write;
 123         eeprom->bin.size = size;
 124
 125         ret = sysfs_create_bin_file(&client->dev.kobj, &eeprom->bin);
 126         if (ret)
 127                 return ret;
 128
 129         ret = i2c_slave_register(client, i2c_slave_eeprom_slave_cb);
 130         if (ret) {
 131                 sysfs_remove_bin_file(&client->dev.kobj, &eeprom->bin);
 132                 return ret;
 133         }
 134
 135         return 0;
 136 };
 137
 138 static int i2c_slave_eeprom_remove(struct i2c_client *client)
 139 {
 140         struct eeprom_data *eeprom = i2c_get_clientdata(client);
 141
 142         i2c_slave_unregister(client);
 143         sysfs_remove_bin_file(&client->dev.kobj, &eeprom->bin);
 144
 145         return 0;
 146 }
 147
 148 static const struct i2c_device_id i2c_slave_eeprom_id[] = {
 149         { "slave-24c02", 2048 / 8 },
 150         { }
 151 };
 152 MODULE_DEVICE_TABLE(i2c, i2c_slave_eeprom_id);
 153
 154 static struct i2c_driver i2c_slave_eeprom_driver = {
 155         .driver = {
 156                 .name = "i2c-slave-eeprom",
 157         },
 158         .probe = i2c_slave_eeprom_probe,
 159         .remove = i2c_slave_eeprom_remove,
 160         .id_table = i2c_slave_eeprom_id,
 161 };
 162 module_i2c_driver(i2c_slave_eeprom_driver);
 163
 164 MODULE_AUTHOR("Wolfram Sang <[email protected]>");
 165 MODULE_DESCRIPTION("I2C slave mode EEPROM simulator");
 166 MODULE_LICENSE("GPL v2");