1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * w1_ds250x.c - w1 family 09/0b/89/91 (DS250x) driver 4 */ 5 6 #include <linux/kernel.h> 7 #include <linux/module.h> 8 #include <linux/moduleparam.h> 9 #include <linux/device.h> 10 #include <linux/types.h> 11 #include <linux/delay.h> 12 #include <linux/slab.h> 13 #include <linux/crc16.h> 14 15 #include <linux/w1.h> 16 #include <linux/nvmem-provider.h> 17 18 #define W1_DS2501_UNW_FAMILY 0x91 19 #define W1_DS2501_SIZE 64 20 21 #define W1_DS2502_FAMILY 0x09 22 #define W1_DS2502_UNW_FAMILY 0x89 23 #define W1_DS2502_SIZE 128 24 25 #define W1_DS2505_FAMILY 0x0b 26 #define W1_DS2505_SIZE 2048 27 28 #define W1_PAGE_SIZE 32 29 30 #define W1_EXT_READ_MEMORY 0xA5 31 #define W1_READ_DATA_CRC 0xC3 32 33 #define OFF2PG(off) ((off) / W1_PAGE_SIZE) 34 35 #define CRC16_INIT 0 36 #define CRC16_VALID 0xb001 37 38 struct w1_eprom_data { 39 size_t size; 40 int (*read)(struct w1_slave *sl, int pageno); 41 u8 eprom[W1_DS2505_SIZE]; 42 DECLARE_BITMAP(page_present, W1_DS2505_SIZE / W1_PAGE_SIZE); 43 char nvmem_name[64]; 44 }; 45 46 static int w1_ds2502_read_page(struct w1_slave *sl, int pageno) 47 { 48 struct w1_eprom_data *data = sl->family_data; 49 int pgoff = pageno * W1_PAGE_SIZE; 50 int ret = -EIO; 51 u8 buf[3]; 52 u8 crc8; 53 54 if (test_bit(pageno, data->page_present)) 55 return 0; /* page already present */ 56 57 mutex_lock(&sl->master->bus_mutex); 58 59 if (w1_reset_select_slave(sl)) 60 goto err; 61 62 buf[0] = W1_READ_DATA_CRC; 63 buf[1] = pgoff & 0xff; 64 buf[2] = pgoff >> 8; 65 w1_write_block(sl->master, buf, 3); 66 67 crc8 = w1_read_8(sl->master); 68 if (w1_calc_crc8(buf, 3) != crc8) 69 goto err; 70 71 w1_read_block(sl->master, &data->eprom[pgoff], W1_PAGE_SIZE); 72 73 crc8 = w1_read_8(sl->master); 74 if (w1_calc_crc8(&data->eprom[pgoff], W1_PAGE_SIZE) != crc8) 75 goto err; 76 77 set_bit(pageno, data->page_present); /* mark page present */ 78 ret = 0; 79 err: 80 mutex_unlock(&sl->master->bus_mutex); 81 return ret; 82 } 83 84 static int w1_ds2505_read_page(struct w1_slave *sl, int pageno) 85 { 86 struct w1_eprom_data *data = sl->family_data; 87 int redir_retries = 16; 88 int pgoff, epoff; 89 int ret = -EIO; 90 u8 buf[6]; 91 u8 redir; 92 u16 crc; 93 94 if (test_bit(pageno, data->page_present)) 95 return 0; /* page already present */ 96 97 epoff = pgoff = pageno * W1_PAGE_SIZE; 98 mutex_lock(&sl->master->bus_mutex); 99 100 retry: 101 if (w1_reset_select_slave(sl)) 102 goto err; 103 104 buf[0] = W1_EXT_READ_MEMORY; 105 buf[1] = pgoff & 0xff; 106 buf[2] = pgoff >> 8; 107 w1_write_block(sl->master, buf, 3); 108 w1_read_block(sl->master, buf + 3, 3); /* redir, crc16 */ 109 redir = buf[3]; 110 crc = crc16(CRC16_INIT, buf, 6); 111 112 if (crc != CRC16_VALID) 113 goto err; 114 115 116 if (redir != 0xff) { 117 redir_retries--; 118 if (redir_retries < 0) 119 goto err; 120 121 pgoff = (redir ^ 0xff) * W1_PAGE_SIZE; 122 goto retry; 123 } 124 125 w1_read_block(sl->master, &data->eprom[epoff], W1_PAGE_SIZE); 126 w1_read_block(sl->master, buf, 2); /* crc16 */ 127 crc = crc16(CRC16_INIT, &data->eprom[epoff], W1_PAGE_SIZE); 128 crc = crc16(crc, buf, 2); 129 130 if (crc != CRC16_VALID) 131 goto err; 132 133 set_bit(pageno, data->page_present); 134 ret = 0; 135 err: 136 mutex_unlock(&sl->master->bus_mutex); 137 return ret; 138 } 139 140 static int w1_nvmem_read(void *priv, unsigned int off, void *buf, size_t count) 141 { 142 struct w1_slave *sl = priv; 143 struct w1_eprom_data *data = sl->family_data; 144 size_t eprom_size = data->size; 145 int ret; 146 int i; 147 148 if (off > eprom_size) 149 return -EINVAL; 150 151 if ((off + count) > eprom_size) 152 count = eprom_size - off; 153 154 i = OFF2PG(off); 155 do { 156 ret = data->read(sl, i++); 157 if (ret < 0) 158 return ret; 159 } while (i < OFF2PG(off + count)); 160 161 memcpy(buf, &data->eprom[off], count); 162 return 0; 163 } 164 165 static int w1_eprom_add_slave(struct w1_slave *sl) 166 { 167 struct w1_eprom_data *data; 168 struct nvmem_device *nvmem; 169 struct nvmem_config nvmem_cfg = { 170 .dev = &sl->dev, 171 .reg_read = w1_nvmem_read, 172 .type = NVMEM_TYPE_OTP, 173 .read_only = true, 174 .word_size = 1, 175 .priv = sl, 176 .id = -1 177 }; 178 179 data = devm_kzalloc(&sl->dev, sizeof(struct w1_eprom_data), GFP_KERNEL); 180 if (!data) 181 return -ENOMEM; 182 183 sl->family_data = data; 184 switch (sl->family->fid) { 185 case W1_DS2501_UNW_FAMILY: 186 data->size = W1_DS2501_SIZE; 187 data->read = w1_ds2502_read_page; 188 break; 189 case W1_DS2502_FAMILY: 190 case W1_DS2502_UNW_FAMILY: 191 data->size = W1_DS2502_SIZE; 192 data->read = w1_ds2502_read_page; 193 break; 194 case W1_DS2505_FAMILY: 195 data->size = W1_DS2505_SIZE; 196 data->read = w1_ds2505_read_page; 197 break; 198 } 199 200 if (sl->master->bus_master->dev_id) 201 snprintf(data->nvmem_name, sizeof(data->nvmem_name), 202 "%s-%02x-%012llx", 203 sl->master->bus_master->dev_id, sl->reg_num.family, 204 (unsigned long long)sl->reg_num.id); 205 else 206 snprintf(data->nvmem_name, sizeof(data->nvmem_name), 207 "%02x-%012llx", 208 sl->reg_num.family, 209 (unsigned long long)sl->reg_num.id); 210 211 nvmem_cfg.name = data->nvmem_name; 212 nvmem_cfg.size = data->size; 213 214 nvmem = devm_nvmem_register(&sl->dev, &nvmem_cfg); 215 return PTR_ERR_OR_ZERO(nvmem); 216 } 217 218 static const struct w1_family_ops w1_eprom_fops = { 219 .add_slave = w1_eprom_add_slave, 220 }; 221 222 static struct w1_family w1_family_09 = { 223 .fid = W1_DS2502_FAMILY, 224 .fops = &w1_eprom_fops, 225 }; 226 227 static struct w1_family w1_family_0b = { 228 .fid = W1_DS2505_FAMILY, 229 .fops = &w1_eprom_fops, 230 }; 231 232 static struct w1_family w1_family_89 = { 233 .fid = W1_DS2502_UNW_FAMILY, 234 .fops = &w1_eprom_fops, 235 }; 236 237 static struct w1_family w1_family_91 = { 238 .fid = W1_DS2501_UNW_FAMILY, 239 .fops = &w1_eprom_fops, 240 }; 241 242 static int __init w1_ds250x_init(void) 243 { 244 int err; 245 246 err = w1_register_family(&w1_family_09); 247 if (err) 248 return err; 249 250 err = w1_register_family(&w1_family_0b); 251 if (err) 252 goto err_0b; 253 254 err = w1_register_family(&w1_family_89); 255 if (err) 256 goto err_89; 257 258 err = w1_register_family(&w1_family_91); 259 if (err) 260 goto err_91; 261 262 return 0; 263 264 err_91: 265 w1_unregister_family(&w1_family_89); 266 err_89: 267 w1_unregister_family(&w1_family_0b); 268 err_0b: 269 w1_unregister_family(&w1_family_09); 270 return err; 271 } 272 273 static void __exit w1_ds250x_exit(void) 274 { 275 w1_unregister_family(&w1_family_09); 276 w1_unregister_family(&w1_family_0b); 277 w1_unregister_family(&w1_family_89); 278 w1_unregister_family(&w1_family_91); 279 } 280 281 module_init(w1_ds250x_init); 282 module_exit(w1_ds250x_exit); 283 284 MODULE_AUTHOR("Thomas Bogendoerfer <tbogendoerfe@suse.de>"); 285 MODULE_DESCRIPTION("w1 family driver for DS250x Add Only Memory"); 286 MODULE_LICENSE("GPL"); 287 MODULE_ALIAS("w1-family-" __stringify(W1_DS2502_FAMILY)); 288 MODULE_ALIAS("w1-family-" __stringify(W1_DS2505_FAMILY)); 289 MODULE_ALIAS("w1-family-" __stringify(W1_DS2501_UNW_FAMILY)); 290 MODULE_ALIAS("w1-family-" __stringify(W1_DS2502_UNW_FAMILY)); 291