drivers/nvmem/rave-sp-eeprom.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2
   3 /*
   4  * EEPROM driver for RAVE SP
   5  *
   6  * Copyright (C) 2018 Zodiac Inflight Innovations
   7  *
   8  */
   9 #include <linux/kernel.h>
  10 #include <linux/mfd/rave-sp.h>
  11 #include <linux/module.h>
  12 #include <linux/nvmem-provider.h>
  13 #include <linux/of_device.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/sizes.h>
  16
  17 /**
  18  * enum rave_sp_eeprom_access_type - Supported types of EEPROM access
  19  *
  20  * @RAVE_SP_EEPROM_WRITE:       EEPROM write
  21  * @RAVE_SP_EEPROM_READ:        EEPROM read
  22  */
  23 enum rave_sp_eeprom_access_type {
  24         RAVE_SP_EEPROM_WRITE = 0,
  25         RAVE_SP_EEPROM_READ  = 1,
  26 };
  27
  28 /**
  29  * enum rave_sp_eeprom_header_size - EEPROM command header sizes
  30  *
  31  * @RAVE_SP_EEPROM_HEADER_SMALL: EEPROM header size for "small" devices (< 8K)
  32  * @RAVE_SP_EEPROM_HEADER_BIG:   EEPROM header size for "big" devices (> 8K)
  33  */
  34 enum rave_sp_eeprom_header_size {
  35         RAVE_SP_EEPROM_HEADER_SMALL = 4U,
  36         RAVE_SP_EEPROM_HEADER_BIG   = 5U,
  37 };
  38 #define RAVE_SP_EEPROM_HEADER_MAX       RAVE_SP_EEPROM_HEADER_BIG
  39
  40 #define RAVE_SP_EEPROM_PAGE_SIZE        32U
  41
  42 /**
  43  * struct rave_sp_eeprom_page - RAVE SP EEPROM page
  44  *
  45  * @type:       Access type (see enum rave_sp_eeprom_access_type)
  46  * @success:    Success flag (Success = 1, Failure = 0)
  47  * @data:       Read data
  48
  49  * Note this structure corresponds to RSP_*_EEPROM payload from RAVE
  50  * SP ICD
  51  */
  52 struct rave_sp_eeprom_page {
  53         u8  type;
  54         u8  success;
  55         u8  data[RAVE_SP_EEPROM_PAGE_SIZE];
  56 } __packed;
  57
  58 /**
  59  * struct rave_sp_eeprom - RAVE SP EEPROM device
  60  *
  61  * @sp:                 Pointer to parent RAVE SP device
  62  * @mutex:              Lock protecting access to EEPROM
  63  * @address:            EEPROM device address
  64  * @header_size:        Size of EEPROM command header for this device
  65  * @dev:                Pointer to corresponding struct device used for logging
  66  */
  67 struct rave_sp_eeprom {
  68         struct rave_sp *sp;
  69         struct mutex mutex;
  70         u8 address;
  71         unsigned int header_size;
  72         struct device *dev;
  73 };
  74
  75 /**
  76  * rave_sp_eeprom_io - Low-level part of EEPROM page access
  77  *
  78  * @eeprom:     EEPROM device to write to
  79  * @type:       EEPROM access type (read or write)
  80  * @idx:        number of the EEPROM page
  81  * @page:       Data to write or buffer to store result (via page->data)
  82  *
  83  * This function does all of the low-level work required to perform a
  84  * EEPROM access. This includes formatting correct command payload,
  85  * sending it and checking received results.
  86  *
  87  * Returns zero in case of success or negative error code in
  88  * case of failure.
  89  */
  90 static int rave_sp_eeprom_io(struct rave_sp_eeprom *eeprom,
  91                              enum rave_sp_eeprom_access_type type,
  92                              u16 idx,
  93                              struct rave_sp_eeprom_page *page)
  94 {
  95         const bool is_write = type == RAVE_SP_EEPROM_WRITE;
  96         const unsigned int data_size = is_write ? sizeof(page->data) : 0;
  97         const unsigned int cmd_size = eeprom->header_size + data_size;
  98         const unsigned int rsp_size =
  99                 is_write ? sizeof(*page) - sizeof(page->data) : sizeof(*page);
 100         unsigned int offset = 0;
 101         u8 cmd[RAVE_SP_EEPROM_HEADER_MAX + sizeof(page->data)];
 102         int ret;
 103
 104         if (WARN_ON(cmd_size > sizeof(cmd)))
 105                 return -EINVAL;
 106
 107         cmd[offset++] = eeprom->address;
 108         cmd[offset++] = 0;
 109         cmd[offset++] = type;
 110         cmd[offset++] = idx;
 111
 112         /*
 113          * If there's still room in this command's header it means we
 114          * are talkin to EEPROM that uses 16-bit page numbers and we
 115          * have to specify index's MSB in payload as well.
 116          */
 117         if (offset < eeprom->header_size)
 118                 cmd[offset++] = idx >> 8;
 119         /*
 120          * Copy our data to write to command buffer first. In case of
 121          * a read data_size should be zero and memcpy would become a
 122          * no-op
 123          */
 124         memcpy(&cmd[offset], page->data, data_size);
 125
 126         ret = rave_sp_exec(eeprom->sp, cmd, cmd_size, page, rsp_size);
 127         if (ret)
 128                 return ret;
 129
 130         if (page->type != type)
 131                 return -EPROTO;
 132
 133         if (!page->success)
 134                 return -EIO;
 135
 136         return 0;
 137 }
 138
 139 /**
 140  * rave_sp_eeprom_page_access - Access single EEPROM page
 141  *
 142  * @eeprom:     EEPROM device to access
 143  * @type:       Access type to perform (read or write)
 144  * @offset:     Offset within EEPROM to access
 145  * @data:       Data buffer
 146  * @data_len:   Size of the data buffer
 147  *
 148  * This function performs a generic access to a single page or a
 149  * portion thereof. Requested access MUST NOT cross the EEPROM page
 150  * boundary.
 151  *
 152  * Returns zero in case of success or negative error code in
 153  * case of failure.
 154  */
 155 static int
 156 rave_sp_eeprom_page_access(struct rave_sp_eeprom *eeprom,
 157                            enum rave_sp_eeprom_access_type type,
 158                            unsigned int offset, u8 *data,
 159                            size_t data_len)
 160 {
 161         const unsigned int page_offset = offset % RAVE_SP_EEPROM_PAGE_SIZE;
 162         const unsigned int page_nr     = offset / RAVE_SP_EEPROM_PAGE_SIZE;
 163         struct rave_sp_eeprom_page page;
 164         int ret;
 165
 166         /*
 167          * This function will not work if data access we've been asked
 168          * to do is crossing EEPROM page boundary. Normally this
 169          * should never happen and getting here would indicate a bug
 170          * in the code.
 171          */
 172         if (WARN_ON(data_len > sizeof(page.data) - page_offset))
 173                 return -EINVAL;
 174
 175         if (type == RAVE_SP_EEPROM_WRITE) {
 176                 /*
 177                  * If doing a partial write we need to do a read first
 178                  * to fill the rest of the page with correct data.
 179                  */
 180                 if (data_len < RAVE_SP_EEPROM_PAGE_SIZE) {
 181                         ret = rave_sp_eeprom_io(eeprom, RAVE_SP_EEPROM_READ,
 182                                                 page_nr, &page);
 183                         if (ret)
 184                                 return ret;
 185                 }
 186
 187                 memcpy(&page.data[page_offset], data, data_len);
 188         }
 189
 190         ret = rave_sp_eeprom_io(eeprom, type, page_nr, &page);
 191         if (ret)
 192                 return ret;
 193
 194         /*
 195          * Since we receive the result of the read via 'page.data'
 196          * buffer we need to copy that to 'data'
 197          */
 198         if (type == RAVE_SP_EEPROM_READ)
 199                 memcpy(data, &page.data[page_offset], data_len);
 200
 201         return 0;
 202 }
 203
 204 /**
 205  * rave_sp_eeprom_access - Access EEPROM data
 206  *
 207  * @eeprom:     EEPROM device to access
 208  * @type:       Access type to perform (read or write)
 209  * @offset:     Offset within EEPROM to access
 210  * @data:       Data buffer
 211  * @data_len:   Size of the data buffer
 212  *
 213  * This function performs a generic access (either read or write) at
 214  * arbitrary offset (not necessary page aligned) of arbitrary length
 215  * (is not constrained by EEPROM page size).
 216  *
 217  * Returns zero in case of success or negative error code in case of
 218  * failure.
 219  */
 220 static int rave_sp_eeprom_access(struct rave_sp_eeprom *eeprom,
 221                                  enum rave_sp_eeprom_access_type type,
 222                                  unsigned int offset, u8 *data,
 223                                  unsigned int data_len)
 224 {
 225         unsigned int residue;
 226         unsigned int chunk;
 227         unsigned int head;
 228         int ret;
 229
 230         mutex_lock(&eeprom->mutex);
 231
 232         head    = offset % RAVE_SP_EEPROM_PAGE_SIZE;
 233         residue = data_len;
 234
 235         do {
 236                 /*
 237                  * First iteration, if we are doing an access that is
 238                  * not 32-byte aligned, we need to access only data up
 239                  * to a page boundary to avoid corssing it in
 240                  * rave_sp_eeprom_page_access()
 241                  */
 242                 if (unlikely(head)) {
 243                         chunk = RAVE_SP_EEPROM_PAGE_SIZE - head;
 244                         /*
 245                          * This can only happen once per
 246                          * rave_sp_eeprom_access() call, so we set
 247                          * head to zero to process all the other
 248                          * iterations normally.
 249                          */
 250                         head  = 0;
 251                 } else {
 252                         chunk = RAVE_SP_EEPROM_PAGE_SIZE;
 253                 }
 254
 255                 /*
 256                  * We should never read more that 'residue' bytes
 257                  */
 258                 chunk = min(chunk, residue);
 259                 ret = rave_sp_eeprom_page_access(eeprom, type, offset,
 260                                                  data, chunk);
 261                 if (ret)
 262                         goto out;
 263
 264                 residue -= chunk;
 265                 offset  += chunk;
 266                 data    += chunk;
 267         } while (residue);
 268 out:
 269         mutex_unlock(&eeprom->mutex);
 270         return ret;
 271 }
 272
 273 static int rave_sp_eeprom_reg_read(void *eeprom, unsigned int offset,
 274                                    void *val, size_t bytes)
 275 {
 276         return rave_sp_eeprom_access(eeprom, RAVE_SP_EEPROM_READ,
 277                                      offset, val, bytes);
 278 }
 279
 280 static int rave_sp_eeprom_reg_write(void *eeprom, unsigned int offset,
 281                                     void *val, size_t bytes)
 282 {
 283         return rave_sp_eeprom_access(eeprom, RAVE_SP_EEPROM_WRITE,
 284                                      offset, val, bytes);
 285 }
 286
 287 static int rave_sp_eeprom_probe(struct platform_device *pdev)
 288 {
 289         struct device *dev = &pdev->dev;
 290         struct rave_sp *sp = dev_get_drvdata(dev->parent);
 291         struct device_node *np = dev->of_node;
 292         struct nvmem_config config = { 0 };
 293         struct rave_sp_eeprom *eeprom;
 294         struct nvmem_device *nvmem;
 295         u32 reg[2], size;
 296
 297         if (of_property_read_u32_array(np, "reg", reg, ARRAY_SIZE(reg))) {
 298                 dev_err(dev, "Failed to parse \"reg\" property\n");
 299                 return -EINVAL;
 300         }
 301
 302         size = reg[1];
 303         /*
 304          * Per ICD, we have no more than 2 bytes to specify EEPROM
 305          * page.
 306          */
 307         if (size > U16_MAX * RAVE_SP_EEPROM_PAGE_SIZE) {
 308                 dev_err(dev, "Specified size is too big\n");
 309                 return -EINVAL;
 310         }
 311
 312         eeprom = devm_kzalloc(dev, sizeof(*eeprom), GFP_KERNEL);
 313         if (!eeprom)
 314                 return -ENOMEM;
 315
 316         eeprom->address = reg[0];
 317         eeprom->sp      = sp;
 318         eeprom->dev     = dev;
 319
 320         if (size > SZ_8K)
 321                 eeprom->header_size = RAVE_SP_EEPROM_HEADER_BIG;
 322         else
 323                 eeprom->header_size = RAVE_SP_EEPROM_HEADER_SMALL;
 324
 325         mutex_init(&eeprom->mutex);
 326
 327         config.id               = -1;
 328         of_property_read_string(np, "zii,eeprom-name", &config.name);
 329         config.priv             = eeprom;
 330         config.dev              = dev;
 331         config.size             = size;
 332         config.reg_read         = rave_sp_eeprom_reg_read;
 333         config.reg_write        = rave_sp_eeprom_reg_write;
 334         config.word_size        = 1;
 335         config.stride           = 1;
 336
 337         nvmem = devm_nvmem_register(dev, &config);
 338
 339         return PTR_ERR_OR_ZERO(nvmem);
 340 }
 341
 342 static const struct of_device_id rave_sp_eeprom_of_match[] = {
 343         { .compatible = "zii,rave-sp-eeprom" },
 344         {}
 345 };
 346 MODULE_DEVICE_TABLE(of, rave_sp_eeprom_of_match);
 347
 348 static struct platform_driver rave_sp_eeprom_driver = {
 349         .probe = rave_sp_eeprom_probe,
 350         .driver = {
 351                 .name = KBUILD_MODNAME,
 352                 .of_match_table = rave_sp_eeprom_of_match,
 353         },
 354 };
 355 module_platform_driver(rave_sp_eeprom_driver);
 356
 357 MODULE_LICENSE("GPL");
 358 MODULE_AUTHOR("Andrey Vostrikov <andrey.vostrikov@cogentembedded.com>");
 359 MODULE_AUTHOR("Nikita Yushchenko <nikita.yoush@cogentembedded.com>");
 360 MODULE_AUTHOR("Andrey Smirnov <andrew.smirnov@gmail.com>");
 361 MODULE_DESCRIPTION("RAVE SP EEPROM driver");