260 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * mchp23k256.c4 *5 * Driver for Microchip 23k256 SPI RAM chips6 *7 * Copyright © 2016 Andrew Lunn <andrew@lunn.ch>8 */9#include <linux/device.h>10#include <linux/module.h>11#include <linux/mtd/mtd.h>12#include <linux/mtd/partitions.h>13#include <linux/mutex.h>14#include <linux/sched.h>15#include <linux/sizes.h>16#include <linux/spi/flash.h>17#include <linux/spi/spi.h>18#include <linux/of.h>19 20#define MAX_CMD_SIZE 421 22struct mchp23_caps {23 u8 addr_width;24 unsigned int size;25};26 27struct mchp23k256_flash {28 struct spi_device *spi;29 struct mutex lock;30 struct mtd_info mtd;31 const struct mchp23_caps *caps;32};33 34#define MCHP23K256_CMD_WRITE_STATUS 0x0135#define MCHP23K256_CMD_WRITE 0x0236#define MCHP23K256_CMD_READ 0x0337#define MCHP23K256_MODE_SEQ BIT(6)38 39#define to_mchp23k256_flash(x) container_of(x, struct mchp23k256_flash, mtd)40 41static void mchp23k256_addr2cmd(struct mchp23k256_flash *flash,42 unsigned int addr, u8 *cmd)43{44 int i;45 46 /*47 * Address is sent in big endian (MSB first) and we skip48 * the first entry of the cmd array which contains the cmd49 * opcode.50 */51 for (i = flash->caps->addr_width; i > 0; i--, addr >>= 8)52 cmd[i] = addr;53}54 55static int mchp23k256_cmdsz(struct mchp23k256_flash *flash)56{57 return 1 + flash->caps->addr_width;58}59 60static int mchp23k256_write(struct mtd_info *mtd, loff_t to, size_t len,61 size_t *retlen, const unsigned char *buf)62{63 struct mchp23k256_flash *flash = to_mchp23k256_flash(mtd);64 struct spi_transfer transfer[2] = {};65 struct spi_message message;66 unsigned char command[MAX_CMD_SIZE];67 int ret, cmd_len;68 69 spi_message_init(&message);70 71 cmd_len = mchp23k256_cmdsz(flash);72 73 command[0] = MCHP23K256_CMD_WRITE;74 mchp23k256_addr2cmd(flash, to, command);75 76 transfer[0].tx_buf = command;77 transfer[0].len = cmd_len;78 spi_message_add_tail(&transfer[0], &message);79 80 transfer[1].tx_buf = buf;81 transfer[1].len = len;82 spi_message_add_tail(&transfer[1], &message);83 84 mutex_lock(&flash->lock);85 86 ret = spi_sync(flash->spi, &message);87 88 mutex_unlock(&flash->lock);89 90 if (ret)91 return ret;92 93 if (retlen && message.actual_length > cmd_len)94 *retlen += message.actual_length - cmd_len;95 96 return 0;97}98 99static int mchp23k256_read(struct mtd_info *mtd, loff_t from, size_t len,100 size_t *retlen, unsigned char *buf)101{102 struct mchp23k256_flash *flash = to_mchp23k256_flash(mtd);103 struct spi_transfer transfer[2] = {};104 struct spi_message message;105 unsigned char command[MAX_CMD_SIZE];106 int ret, cmd_len;107 108 spi_message_init(&message);109 110 cmd_len = mchp23k256_cmdsz(flash);111 112 memset(&transfer, 0, sizeof(transfer));113 command[0] = MCHP23K256_CMD_READ;114 mchp23k256_addr2cmd(flash, from, command);115 116 transfer[0].tx_buf = command;117 transfer[0].len = cmd_len;118 spi_message_add_tail(&transfer[0], &message);119 120 transfer[1].rx_buf = buf;121 transfer[1].len = len;122 spi_message_add_tail(&transfer[1], &message);123 124 mutex_lock(&flash->lock);125 126 ret = spi_sync(flash->spi, &message);127 128 mutex_unlock(&flash->lock);129 130 if (ret)131 return ret;132 133 if (retlen && message.actual_length > cmd_len)134 *retlen += message.actual_length - cmd_len;135 136 return 0;137}138 139/*140 * Set the device into sequential mode. This allows read/writes to the141 * entire SRAM in a single operation142 */143static int mchp23k256_set_mode(struct spi_device *spi)144{145 struct spi_transfer transfer = {};146 struct spi_message message;147 unsigned char command[2];148 149 spi_message_init(&message);150 151 command[0] = MCHP23K256_CMD_WRITE_STATUS;152 command[1] = MCHP23K256_MODE_SEQ;153 154 transfer.tx_buf = command;155 transfer.len = sizeof(command);156 spi_message_add_tail(&transfer, &message);157 158 return spi_sync(spi, &message);159}160 161static const struct mchp23_caps mchp23k256_caps = {162 .size = SZ_32K,163 .addr_width = 2,164};165 166static const struct mchp23_caps mchp23lcv1024_caps = {167 .size = SZ_128K,168 .addr_width = 3,169};170 171static int mchp23k256_probe(struct spi_device *spi)172{173 struct mchp23k256_flash *flash;174 struct flash_platform_data *data;175 int err;176 177 flash = devm_kzalloc(&spi->dev, sizeof(*flash), GFP_KERNEL);178 if (!flash)179 return -ENOMEM;180 181 flash->spi = spi;182 mutex_init(&flash->lock);183 spi_set_drvdata(spi, flash);184 185 err = mchp23k256_set_mode(spi);186 if (err)187 return err;188 189 data = dev_get_platdata(&spi->dev);190 191 flash->caps = of_device_get_match_data(&spi->dev);192 if (!flash->caps)193 flash->caps = &mchp23k256_caps;194 195 mtd_set_of_node(&flash->mtd, spi->dev.of_node);196 flash->mtd.dev.parent = &spi->dev;197 flash->mtd.type = MTD_RAM;198 flash->mtd.flags = MTD_CAP_RAM;199 flash->mtd.writesize = 1;200 flash->mtd.size = flash->caps->size;201 flash->mtd._read = mchp23k256_read;202 flash->mtd._write = mchp23k256_write;203 204 err = mtd_device_register(&flash->mtd, data ? data->parts : NULL,205 data ? data->nr_parts : 0);206 if (err)207 return err;208 209 return 0;210}211 212static void mchp23k256_remove(struct spi_device *spi)213{214 struct mchp23k256_flash *flash = spi_get_drvdata(spi);215 216 WARN_ON(mtd_device_unregister(&flash->mtd));217}218 219static const struct of_device_id mchp23k256_of_table[] = {220 {221 .compatible = "microchip,mchp23k256",222 .data = &mchp23k256_caps,223 },224 {225 .compatible = "microchip,mchp23lcv1024",226 .data = &mchp23lcv1024_caps,227 },228 {}229};230MODULE_DEVICE_TABLE(of, mchp23k256_of_table);231 232static const struct spi_device_id mchp23k256_spi_ids[] = {233 {234 .name = "mchp23k256",235 .driver_data = (kernel_ulong_t)&mchp23k256_caps,236 },237 {238 .name = "mchp23lcv1024",239 .driver_data = (kernel_ulong_t)&mchp23lcv1024_caps,240 },241 {}242};243MODULE_DEVICE_TABLE(spi, mchp23k256_spi_ids);244 245static struct spi_driver mchp23k256_driver = {246 .driver = {247 .name = "mchp23k256",248 .of_match_table = mchp23k256_of_table,249 },250 .probe = mchp23k256_probe,251 .remove = mchp23k256_remove,252 .id_table = mchp23k256_spi_ids,253};254 255module_spi_driver(mchp23k256_driver);256 257MODULE_DESCRIPTION("MTD SPI driver for MCHP23K256 RAM chips");258MODULE_AUTHOR("Andrew Lunn <andre@lunn.ch>");259MODULE_LICENSE("GPL v2");260