drivers/misc/eeprom/ee1004.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * ee1004 - driver for DDR4 SPD EEPROMs
   4  *
   5  * Copyright (C) 2017-2019 Jean Delvare
   6  *
   7  * Based on the at24 driver:
   8  * Copyright (C) 2005-2007 David Brownell
   9  * Copyright (C) 2008 Wolfram Sang, Pengutronix
  10  */
  11
  12 #include <linux/i2c.h>
  13 #include <linux/init.h>
  14 #include <linux/kernel.h>
  15 #include <linux/mod_devicetable.h>
  16 #include <linux/module.h>
  17 #include <linux/mutex.h>
  18
  19 /*
  20  * DDR4 memory modules use special EEPROMs following the Jedec EE1004
  21  * specification. These are 512-byte EEPROMs using a single I2C address
  22  * in the 0x50-0x57 range for data. One of two 256-byte page is selected
  23  * by writing a command to I2C address 0x36 or 0x37 on the same I2C bus.
  24  *
  25  * Therefore we need to request these 2 additional addresses, and serialize
  26  * access to all such EEPROMs with a single mutex.
  27  *
  28  * We assume it is safe to read up to 32 bytes at once from these EEPROMs.
  29  * We use SMBus access even if I2C is available, these EEPROMs are small
  30  * enough, and reading from them infrequent enough, that we favor simplicity
  31  * over performance.
  32  */
  33
  34 #define EE1004_MAX_BUSSES               8
  35 #define EE1004_ADDR_SET_PAGE            0x36
  36 #define EE1004_NUM_PAGES                2
  37 #define EE1004_PAGE_SIZE                256
  38 #define EE1004_PAGE_SHIFT               8
  39 #define EE1004_EEPROM_SIZE              (EE1004_PAGE_SIZE * EE1004_NUM_PAGES)
  40
  41 /*
  42  * Mutex protects ee1004_set_page and ee1004_dev_count, and must be held
  43  * from page selection to end of read.
  44  */
  45 static DEFINE_MUTEX(ee1004_bus_lock);
  46
  47 static struct ee1004_bus_data {
  48         struct i2c_adapter *adap;
  49         struct i2c_client *set_page[EE1004_NUM_PAGES];
  50         unsigned int dev_count;
  51         int current_page;
  52 } ee1004_bus_data[EE1004_MAX_BUSSES];
  53
  54 static const struct i2c_device_id ee1004_ids[] = {
  55         { "ee1004", 0 },
  56         { }
  57 };
  58 MODULE_DEVICE_TABLE(i2c, ee1004_ids);
  59
  60 /*-------------------------------------------------------------------------*/
  61
  62 static struct ee1004_bus_data *ee1004_get_bus_data(struct i2c_adapter *adap)
  63 {
  64         int i;
  65
  66         for (i = 0; i < EE1004_MAX_BUSSES; i++)
  67                 if (ee1004_bus_data[i].adap == adap)
  68                         return ee1004_bus_data + i;
  69
  70         /* If not existent yet, create new entry */
  71         for (i = 0; i < EE1004_MAX_BUSSES; i++)
  72                 if (!ee1004_bus_data[i].adap) {
  73                         ee1004_bus_data[i].adap = adap;
  74                         return ee1004_bus_data + i;
  75                 }
  76
  77         return NULL;
  78 }
  79
  80 static int ee1004_get_current_page(struct ee1004_bus_data *bd)
  81 {
  82         int err;
  83
  84         err = i2c_smbus_read_byte(bd->set_page[0]);
  85         if (err == -ENXIO) {
  86                 /* Nack means page 1 is selected */
  87                 return 1;
  88         }
  89         if (err < 0) {
  90                 /* Anything else is a real error, bail out */
  91                 return err;
  92         }
  93
  94         /* Ack means page 0 is selected, returned value meaningless */
  95         return 0;
  96 }
  97
  98 static int ee1004_set_current_page(struct i2c_client *client, int page)
  99 {
 100         struct ee1004_bus_data *bd = i2c_get_clientdata(client);
 101         int ret;
 102
 103         if (page == bd->current_page)
 104                 return 0;
 105
 106         /* Data is ignored */
 107         ret = i2c_smbus_write_byte(bd->set_page[page], 0x00);
 108         /*
 109          * Don't give up just yet. Some memory modules will select the page
 110          * but not ack the command. Check which page is selected now.
 111          */
 112         if (ret == -ENXIO && ee1004_get_current_page(bd) == page)
 113                 ret = 0;
 114         if (ret < 0) {
 115                 dev_err(&client->dev, "Failed to select page %d (%d)\n", page, ret);
 116                 return ret;
 117         }
 118
 119         dev_dbg(&client->dev, "Selected page %d\n", page);
 120         bd->current_page = page;
 121
 122         return 0;
 123 }
 124
 125 static ssize_t ee1004_eeprom_read(struct i2c_client *client, char *buf,
 126                                   unsigned int offset, size_t count)
 127 {
 128         int status, page;
 129
 130         page = offset >> EE1004_PAGE_SHIFT;
 131         offset &= (1 << EE1004_PAGE_SHIFT) - 1;
 132
 133         status = ee1004_set_current_page(client, page);
 134         if (status)
 135                 return status;
 136
 137         /* Can't cross page boundaries */
 138         if (offset + count > EE1004_PAGE_SIZE)
 139                 count = EE1004_PAGE_SIZE - offset;
 140
 141         if (count > I2C_SMBUS_BLOCK_MAX)
 142                 count = I2C_SMBUS_BLOCK_MAX;
 143
 144         return i2c_smbus_read_i2c_block_data_or_emulated(client, offset, count, buf);
 145 }
 146
 147 static ssize_t eeprom_read(struct file *filp, struct kobject *kobj,
 148                            struct bin_attribute *bin_attr,
 149                            char *buf, loff_t off, size_t count)
 150 {
 151         struct i2c_client *client = kobj_to_i2c_client(kobj);
 152         size_t requested = count;
 153         int ret = 0;
 154
 155         /*
 156          * Read data from chip, protecting against concurrent access to
 157          * other EE1004 SPD EEPROMs on the same adapter.
 158          */
 159         mutex_lock(&ee1004_bus_lock);
 160
 161         while (count) {
 162                 ret = ee1004_eeprom_read(client, buf, off, count);
 163                 if (ret < 0)
 164                         goto out;
 165
 166                 buf += ret;
 167                 off += ret;
 168                 count -= ret;
 169         }
 170 out:
 171         mutex_unlock(&ee1004_bus_lock);
 172
 173         return ret < 0 ? ret : requested;
 174 }
 175
 176 static BIN_ATTR_RO(eeprom, EE1004_EEPROM_SIZE);
 177
 178 static struct bin_attribute *ee1004_attrs[] = {
 179         &bin_attr_eeprom,
 180         NULL
 181 };
 182
 183 BIN_ATTRIBUTE_GROUPS(ee1004);
 184
 185 static void ee1004_probe_temp_sensor(struct i2c_client *client)
 186 {
 187         struct i2c_board_info info = { .type = "jc42" };
 188         u8 byte14;
 189         int ret;
 190
 191         /* byte 14, bit 7 is set if temp sensor is present */
 192         ret = ee1004_eeprom_read(client, &byte14, 14, 1);
 193         if (ret != 1 || !(byte14 & BIT(7)))
 194                 return;
 195
 196         info.addr = 0x18 | (client->addr & 7);
 197
 198         i2c_new_client_device(client->adapter, &info);
 199 }
 200
 201 static void ee1004_cleanup(int idx, struct ee1004_bus_data *bd)
 202 {
 203         if (--bd->dev_count == 0) {
 204                 while (--idx >= 0)
 205                         i2c_unregister_device(bd->set_page[idx]);
 206                 memset(bd, 0, sizeof(struct ee1004_bus_data));
 207         }
 208 }
 209
 210 static int ee1004_probe(struct i2c_client *client)
 211 {
 212         struct ee1004_bus_data *bd;
 213         int err, cnr = 0;
 214
 215         /* Make sure we can operate on this adapter */
 216         if (!i2c_check_functionality(client->adapter,
 217                                      I2C_FUNC_SMBUS_BYTE | I2C_FUNC_SMBUS_READ_I2C_BLOCK) &&
 218             !i2c_check_functionality(client->adapter,
 219                                      I2C_FUNC_SMBUS_BYTE | I2C_FUNC_SMBUS_READ_BYTE_DATA))
 220                 return -EPFNOSUPPORT;
 221
 222         mutex_lock(&ee1004_bus_lock);
 223
 224         bd = ee1004_get_bus_data(client->adapter);
 225         if (!bd) {
 226                 mutex_unlock(&ee1004_bus_lock);
 227                 return dev_err_probe(&client->dev, -ENOSPC,
 228                                      "Only %d busses supported", EE1004_MAX_BUSSES);
 229         }
 230
 231         i2c_set_clientdata(client, bd);
 232
 233         if (++bd->dev_count == 1) {
 234                 /* Use 2 dummy devices for page select command */
 235                 for (cnr = 0; cnr < EE1004_NUM_PAGES; cnr++) {
 236                         struct i2c_client *cl;
 237
 238                         cl = i2c_new_dummy_device(client->adapter, EE1004_ADDR_SET_PAGE + cnr);
 239                         if (IS_ERR(cl)) {
 240                                 err = PTR_ERR(cl);
 241                                 goto err_clients;
 242                         }
 243                         bd->set_page[cnr] = cl;
 244                 }
 245
 246                 /* Remember current page to avoid unneeded page select */
 247                 err = ee1004_get_current_page(bd);
 248                 if (err < 0)
 249                         goto err_clients;
 250                 dev_dbg(&client->dev, "Currently selected page: %d\n", err);
 251                 bd->current_page = err;
 252         }
 253
 254         ee1004_probe_temp_sensor(client);
 255
 256         mutex_unlock(&ee1004_bus_lock);
 257
 258         dev_info(&client->dev,
 259                  "%u byte EE1004-compliant SPD EEPROM, read-only\n",
 260                  EE1004_EEPROM_SIZE);
 261
 262         return 0;
 263
 264  err_clients:
 265         ee1004_cleanup(cnr, bd);
 266         mutex_unlock(&ee1004_bus_lock);
 267
 268         return err;
 269 }
 270
 271 static void ee1004_remove(struct i2c_client *client)
 272 {
 273         struct ee1004_bus_data *bd = i2c_get_clientdata(client);
 274
 275         /* Remove page select clients if this is the last device */
 276         mutex_lock(&ee1004_bus_lock);
 277         ee1004_cleanup(EE1004_NUM_PAGES, bd);
 278         mutex_unlock(&ee1004_bus_lock);
 279 }
 280
 281 /*-------------------------------------------------------------------------*/
 282
 283 static struct i2c_driver ee1004_driver = {
 284         .driver = {
 285                 .name = "ee1004",
 286                 .dev_groups = ee1004_groups,
 287         },
 288         .probe = ee1004_probe,
 289         .remove = ee1004_remove,
 290         .id_table = ee1004_ids,
 291 };
 292 module_i2c_driver(ee1004_driver);
 293
 294 MODULE_DESCRIPTION("Driver for EE1004-compliant DDR4 SPD EEPROMs");
 295 MODULE_AUTHOR("Jean Delvare");
 296 MODULE_LICENSE("GPL");