1 /*
2  * Copyright (c) 2023 Antmicro <www.antmicro.com>
3  *
4  * SPDX-License-Identifier: Apache-2.0
5  */
6 
7 #define DT_DRV_COMPAT fujitsu_mb85rcxx
8 
9 #include <zephyr/device.h>
10 #include <zephyr/drivers/eeprom.h>
11 #include <zephyr/drivers/gpio.h>
12 #include <zephyr/drivers/i2c.h>
13 #include <zephyr/kernel.h>
14 #include <zephyr/sys/byteorder.h>
15 
16 #include <zephyr/logging/log.h>
17 LOG_MODULE_REGISTER(EEPROM_MB85RCXX, CONFIG_EEPROM_LOG_LEVEL);
18 
19 struct mb85rcxx_config {
20 	struct i2c_dt_spec i2c;
21 	struct gpio_dt_spec wp_gpio;
22 	size_t size;
23 	size_t pagesize;
24 	uint8_t addr_width;
25 	bool readonly;
26 };
27 
28 struct mb85rcxx_data {
29 	struct k_mutex lock;
30 };
31 
mb85rcxx_write_protect_set(const struct device * dev,int value)32 static int mb85rcxx_write_protect_set(const struct device *dev, int value)
33 {
34 	const struct mb85rcxx_config *cfg = dev->config;
35 
36 	if (!cfg->wp_gpio.port) {
37 		return 0;
38 	}
39 
40 	return gpio_pin_set_dt(&cfg->wp_gpio, value);
41 }
42 
mb85rcxx_translate_address(const struct device * dev,off_t offset,uint8_t * addr)43 static uint16_t mb85rcxx_translate_address(const struct device *dev, off_t offset, uint8_t *addr)
44 {
45 	const struct mb85rcxx_config *cfg = dev->config;
46 
47 	off_t page_offset = offset % cfg->pagesize;
48 
49 	if (cfg->addr_width > 8) {
50 		sys_put_be16(page_offset, addr);
51 		addr[0] &= BIT_MASK(cfg->addr_width - 8);
52 	} else {
53 		addr[0] = page_offset & BIT_MASK(cfg->addr_width);
54 	}
55 
56 	return cfg->i2c.addr + (offset >> cfg->addr_width);
57 }
58 
mb85rcxx_remaining_len_in_page(const struct device * dev,off_t offset,size_t len)59 static size_t mb85rcxx_remaining_len_in_page(const struct device *dev, off_t offset, size_t len)
60 {
61 	const struct mb85rcxx_config *cfg = dev->config;
62 	off_t page_offset = offset % cfg->pagesize;
63 	size_t rem = cfg->pagesize - page_offset;
64 
65 	if (rem > len) {
66 		rem = len;
67 	}
68 
69 	return rem;
70 }
71 
mb85rcxx_init(const struct device * dev)72 static int mb85rcxx_init(const struct device *dev)
73 {
74 	const struct mb85rcxx_config *cfg = dev->config;
75 	struct mb85rcxx_data *data = dev->data;
76 
77 	k_mutex_init(&data->lock);
78 
79 	if (!i2c_is_ready_dt(&cfg->i2c)) {
80 		LOG_ERR("i2c bus device not ready");
81 		return -EINVAL;
82 	}
83 
84 	if (cfg->wp_gpio.port) {
85 		if (!gpio_is_ready_dt(&cfg->wp_gpio)) {
86 			LOG_ERR("wp gpio device not ready");
87 			return -EINVAL;
88 		}
89 
90 		int err = gpio_pin_configure_dt(&cfg->wp_gpio, GPIO_OUTPUT_ACTIVE);
91 
92 		if (err) {
93 			LOG_ERR("failed to configure WP GPIO pin (err %d)", err);
94 			return err;
95 		}
96 	}
97 	return 0;
98 }
99 
mb85rcxx_read(const struct device * dev,off_t offset,void * buf,size_t len)100 static int mb85rcxx_read(const struct device *dev, off_t offset, void *buf, size_t len)
101 {
102 	const struct mb85rcxx_config *cfg = dev->config;
103 	struct mb85rcxx_data *data = dev->data;
104 	uint8_t addr[2];
105 	uint16_t i2c_addr;
106 	size_t len_in_page;
107 	int ret;
108 
109 	if (offset + len > cfg->size) {
110 		LOG_ERR("attempt to read past device boundary");
111 		return -EINVAL;
112 	}
113 
114 	k_mutex_lock(&data->lock, K_FOREVER);
115 
116 	while (len) {
117 		i2c_addr = mb85rcxx_translate_address(dev, offset, addr);
118 		len_in_page = mb85rcxx_remaining_len_in_page(dev, offset, len);
119 
120 		ret = i2c_write_read(cfg->i2c.bus, i2c_addr, addr, DIV_ROUND_UP(cfg->addr_width, 8),
121 				     buf, len_in_page);
122 		if (ret < 0) {
123 			LOG_ERR("failed to read FRAM (err %d)", ret);
124 			k_mutex_unlock(&data->lock);
125 			return ret;
126 		}
127 
128 		len -= len_in_page;
129 		*(char *)&buf += len_in_page;
130 		offset += len_in_page;
131 	}
132 
133 	k_mutex_unlock(&data->lock);
134 	return 0;
135 }
136 
mb85rcxx_i2c_write(const struct device * dev,uint16_t i2c_addr,uint8_t * addr,const void * buf,size_t len)137 static int mb85rcxx_i2c_write(const struct device *dev, uint16_t i2c_addr, uint8_t *addr,
138 			      const void *buf, size_t len)
139 {
140 	const struct mb85rcxx_config *cfg = dev->config;
141 	struct i2c_msg msgs[2];
142 
143 	msgs[0].buf = addr;
144 	msgs[0].len = DIV_ROUND_UP(cfg->addr_width, 8);
145 	msgs[0].flags = I2C_MSG_WRITE;
146 
147 	msgs[1].buf = (void *)buf;
148 	msgs[1].len = len;
149 	msgs[1].flags = I2C_MSG_WRITE | I2C_MSG_STOP;
150 
151 	return i2c_transfer(cfg->i2c.bus, &msgs[0], 2, i2c_addr);
152 }
153 
mb85rcxx_write(const struct device * dev,off_t offset,const void * buf,size_t len)154 static int mb85rcxx_write(const struct device *dev, off_t offset, const void *buf, size_t len)
155 {
156 	const struct mb85rcxx_config *cfg = dev->config;
157 	struct mb85rcxx_data *data = dev->data;
158 	uint8_t addr[2];
159 	uint16_t i2c_addr;
160 	size_t len_in_page;
161 	int ret;
162 
163 	if (cfg->readonly) {
164 		LOG_ERR("attempt to write to read-only device");
165 		return -EACCES;
166 	}
167 
168 	if (offset + len > cfg->size) {
169 		LOG_ERR("attempt to write past device boundary");
170 		return -EINVAL;
171 	}
172 
173 	ret = mb85rcxx_write_protect_set(dev, 0);
174 	if (ret) {
175 		LOG_ERR("failed to write-enable FRAM (err %d)", ret);
176 		return ret;
177 	}
178 
179 	k_mutex_lock(&data->lock, K_FOREVER);
180 
181 	while (len) {
182 		i2c_addr = mb85rcxx_translate_address(dev, offset, addr);
183 		len_in_page = mb85rcxx_remaining_len_in_page(dev, offset, len);
184 
185 		ret = mb85rcxx_i2c_write(dev, i2c_addr, addr, buf, len);
186 		if (ret < 0) {
187 			LOG_ERR("failed to write to FRAM (err %d)", ret);
188 			k_mutex_unlock(&data->lock);
189 			return ret;
190 		}
191 
192 		len -= len_in_page;
193 		*(char *)&buf += len_in_page;
194 		offset += len_in_page;
195 	}
196 
197 	k_mutex_unlock(&data->lock);
198 	mb85rcxx_write_protect_set(dev, 1);
199 	return ret;
200 }
201 
mb85rcxx_get_size(const struct device * dev)202 static size_t mb85rcxx_get_size(const struct device *dev)
203 {
204 	const struct mb85rcxx_config *cfg = dev->config;
205 
206 	return cfg->size;
207 }
208 
209 static DEVICE_API(eeprom, mb85rcxx_driver_api) = {
210 	.read = &mb85rcxx_read,
211 	.write = &mb85rcxx_write,
212 	.size = &mb85rcxx_get_size,
213 };
214 
215 #define MB85RCXX_DEFINE(inst)                                                                      \
216 	static struct mb85rcxx_data mb85rcxx_data_##inst;                                          \
217                                                                                                    \
218 	static const struct mb85rcxx_config mb85rcxx_config_##inst = {                             \
219 		.i2c = I2C_DT_SPEC_INST_GET(inst),                                                 \
220 		IF_ENABLED(DT_INST_NODE_HAS_PROP(inst, wp_gpios),                                  \
221 			   (.wp_gpio = GPIO_DT_SPEC_INST_GET(inst, wp_gpios),))                    \
222 			.size = DT_INST_PROP(inst, size),                                          \
223 		.pagesize =                                                                        \
224 			COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, pagesize),                         \
225 				    (DT_INST_PROP(inst, pagesize)), (DT_INST_PROP(inst, size))),   \
226 		.addr_width = DT_INST_PROP(inst, address_width),                                   \
227 		.readonly = DT_INST_PROP(inst, read_only)};                                        \
228                                                                                                    \
229 	DEVICE_DT_INST_DEFINE(inst, mb85rcxx_init, NULL, &mb85rcxx_data_##inst,                    \
230 			      &mb85rcxx_config_##inst, POST_KERNEL, CONFIG_EEPROM_INIT_PRIORITY,   \
231 			      &mb85rcxx_driver_api);
232 
233 DT_INST_FOREACH_STATUS_OKAY(MB85RCXX_DEFINE)
234