drivers/nvmem/lpc18xx_otp.c

   1 /*
   2  * NXP LPC18xx/43xx OTP memory NVMEM driver
   3  *
   4  * Copyright (c) 2016 Joachim Eastwood <[email protected]>
   5  *
   6  * Based on the imx ocotp driver,
   7  * Copyright (c) 2015 Pengutronix, Philipp Zabel <[email protected]>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2
  11  * as published by the Free Software Foundation.
  12  *
  13  * TODO: add support for writing OTP register via API in boot ROM.
  14  */
  15
  16 #include <linux/io.h>
  17 #include <linux/module.h>
  18 #include <linux/nvmem-provider.h>
  19 #include <linux/of.h>
  20 #include <linux/of_device.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/slab.h>
  23
  24 /*
  25  * LPC18xx OTP memory contains 4 banks with 4 32-bit words. Bank 0 starts
  26  * at offset 0 from the base.
  27  *
  28  * Bank 0 contains the part ID for Flashless devices and is reseverd for
  29  * devices with Flash.
  30  * Bank 1/2 is generale purpose or AES key storage for secure devices.
  31  * Bank 3 contains control data, USB ID and generale purpose words.
  32  */
  33 #define LPC18XX_OTP_NUM_BANKS           4
  34 #define LPC18XX_OTP_WORDS_PER_BANK      4
  35 #define LPC18XX_OTP_WORD_SIZE           sizeof(u32)
  36 #define LPC18XX_OTP_SIZE                (LPC18XX_OTP_NUM_BANKS * \
  37                                          LPC18XX_OTP_WORDS_PER_BANK * \
  38                                          LPC18XX_OTP_WORD_SIZE)
  39
  40 struct lpc18xx_otp {
  41         void __iomem *base;
  42 };
  43
  44 static int lpc18xx_otp_read(void *context, unsigned int offset,
  45                             void *val, size_t bytes)
  46 {
  47         struct lpc18xx_otp *otp = context;
  48         unsigned int count = bytes >> 2;
  49         u32 index = offset >> 2;
  50         u32 *buf = val;
  51         int i;
  52
  53         if (count > (LPC18XX_OTP_SIZE - index))
  54                 count = LPC18XX_OTP_SIZE - index;
  55
  56         for (i = index; i < (index + count); i++)
  57                 *buf++ = readl(otp->base + i * LPC18XX_OTP_WORD_SIZE);
  58
  59         return 0;
  60 }
  61
  62 static struct nvmem_config lpc18xx_otp_nvmem_config = {
  63         .name = "lpc18xx-otp",
  64         .read_only = true,
  65         .word_size = LPC18XX_OTP_WORD_SIZE,
  66         .stride = LPC18XX_OTP_WORD_SIZE,
  67         .reg_read = lpc18xx_otp_read,
  68 };
  69
  70 static int lpc18xx_otp_probe(struct platform_device *pdev)
  71 {
  72         struct nvmem_device *nvmem;
  73         struct lpc18xx_otp *otp;
  74         struct resource *res;
  75
  76         otp = devm_kzalloc(&pdev->dev, sizeof(*otp), GFP_KERNEL);
  77         if (!otp)
  78                 return -ENOMEM;
  79
  80         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  81         otp->base = devm_ioremap_resource(&pdev->dev, res);
  82         if (IS_ERR(otp->base))
  83                 return PTR_ERR(otp->base);
  84
  85         lpc18xx_otp_nvmem_config.size = LPC18XX_OTP_SIZE;
  86         lpc18xx_otp_nvmem_config.dev = &pdev->dev;
  87         lpc18xx_otp_nvmem_config.priv = otp;
  88
  89         nvmem = devm_nvmem_register(&pdev->dev, &lpc18xx_otp_nvmem_config);
  90
  91         return PTR_ERR_OR_ZERO(nvmem);
  92 }
  93
  94 static const struct of_device_id lpc18xx_otp_dt_ids[] = {
  95         { .compatible = "nxp,lpc1850-otp" },
  96         { },
  97 };
  98 MODULE_DEVICE_TABLE(of, lpc18xx_otp_dt_ids);
  99
 100 static struct platform_driver lpc18xx_otp_driver = {
 101         .probe  = lpc18xx_otp_probe,
 102         .driver = {
 103                 .name   = "lpc18xx_otp",
 104                 .of_match_table = lpc18xx_otp_dt_ids,
 105         },
 106 };
 107 module_platform_driver(lpc18xx_otp_driver);
 108
 109 MODULE_AUTHOR("Joachim Eastwoood <[email protected]>");
 110 MODULE_DESCRIPTION("NXP LPC18xx OTP NVMEM driver");
 111 MODULE_LICENSE("GPL v2");