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