1 /* 2 * w1_ds2433.c - w1 family 23 (DS2433) driver 3 * 4 * Copyright (c) 2005 Ben Gardner <bgardner@wabtec.com> 5 * 6 * This source code is licensed under the GNU General Public License, 7 * Version 2. See the file COPYING for more details. 8 */ 9 10 #include <linux/kernel.h> 11 #include <linux/module.h> 12 #include <linux/moduleparam.h> 13 #include <linux/device.h> 14 #include <linux/types.h> 15 #include <linux/delay.h> 16 #ifdef CONFIG_W1_F23_CRC 17 #include <linux/crc16.h> 18 19 #define CRC16_INIT 0 20 #define CRC16_VALID 0xb001 21 22 #endif 23 24 #include "../w1.h" 25 #include "../w1_io.h" 26 #include "../w1_int.h" 27 #include "../w1_family.h" 28 29 MODULE_LICENSE("GPL"); 30 MODULE_AUTHOR("Ben Gardner <bgardner@wabtec.com>"); 31 MODULE_DESCRIPTION("w1 family 23 driver for DS2433, 4kb EEPROM"); 32 33 #define W1_EEPROM_SIZE 512 34 #define W1_PAGE_COUNT 16 35 #define W1_PAGE_SIZE 32 36 #define W1_PAGE_BITS 5 37 #define W1_PAGE_MASK 0x1F 38 39 #define W1_F23_TIME 300 40 41 #define W1_F23_READ_EEPROM 0xF0 42 #define W1_F23_WRITE_SCRATCH 0x0F 43 #define W1_F23_READ_SCRATCH 0xAA 44 #define W1_F23_COPY_SCRATCH 0x55 45 46 struct w1_f23_data { 47 u8 memory[W1_EEPROM_SIZE]; 48 u32 validcrc; 49 }; 50 51 /** 52 * Check the file size bounds and adjusts count as needed. 53 * This would not be needed if the file size didn't reset to 0 after a write. 54 */ 55 static inline size_t w1_f23_fix_count(loff_t off, size_t count, size_t size) 56 { 57 if (off > size) 58 return 0; 59 60 if ((off + count) > size) 61 return (size - off); 62 63 return count; 64 } 65 66 #ifdef CONFIG_W1_F23_CRC 67 static int w1_f23_refresh_block(struct w1_slave *sl, struct w1_f23_data *data, 68 int block) 69 { 70 u8 wrbuf[3]; 71 int off = block * W1_PAGE_SIZE; 72 73 if (data->validcrc & (1 << block)) 74 return 0; 75 76 if (w1_reset_select_slave(sl)) { 77 data->validcrc = 0; 78 return -EIO; 79 } 80 81 wrbuf[0] = W1_F23_READ_EEPROM; 82 wrbuf[1] = off & 0xff; 83 wrbuf[2] = off >> 8; 84 w1_write_block(sl->master, wrbuf, 3); 85 w1_read_block(sl->master, &data->memory[off], W1_PAGE_SIZE); 86 87 /* cache the block if the CRC is valid */ 88 if (crc16(CRC16_INIT, &data->memory[off], W1_PAGE_SIZE) == CRC16_VALID) 89 data->validcrc |= (1 << block); 90 91 return 0; 92 } 93 #endif /* CONFIG_W1_F23_CRC */ 94 95 static ssize_t w1_f23_read_bin(struct kobject *kobj, char *buf, loff_t off, 96 size_t count) 97 { 98 struct w1_slave *sl = kobj_to_w1_slave(kobj); 99 #ifdef CONFIG_W1_F23_CRC 100 struct w1_f23_data *data = sl->family_data; 101 int i, min_page, max_page; 102 #else 103 u8 wrbuf[3]; 104 #endif 105 106 if ((count = w1_f23_fix_count(off, count, W1_EEPROM_SIZE)) == 0) 107 return 0; 108 109 atomic_inc(&sl->refcnt); 110 if (down_interruptible(&sl->master->mutex)) { 111 count = 0; 112 goto out_dec; 113 } 114 115 #ifdef CONFIG_W1_F23_CRC 116 117 min_page = (off >> W1_PAGE_BITS); 118 max_page = (off + count - 1) >> W1_PAGE_BITS; 119 for (i = min_page; i <= max_page; i++) { 120 if (w1_f23_refresh_block(sl, data, i)) { 121 count = -EIO; 122 goto out_up; 123 } 124 } 125 memcpy(buf, &data->memory[off], count); 126 127 #else /* CONFIG_W1_F23_CRC */ 128 129 /* read directly from the EEPROM */ 130 if (w1_reset_select_slave(sl)) { 131 count = -EIO; 132 goto out_up; 133 } 134 135 wrbuf[0] = W1_F23_READ_EEPROM; 136 wrbuf[1] = off & 0xff; 137 wrbuf[2] = off >> 8; 138 w1_write_block(sl->master, wrbuf, 3); 139 w1_read_block(sl->master, buf, count); 140 141 #endif /* CONFIG_W1_F23_CRC */ 142 143 out_up: 144 up(&sl->master->mutex); 145 out_dec: 146 atomic_dec(&sl->refcnt); 147 148 return count; 149 } 150 151 /** 152 * Writes to the scratchpad and reads it back for verification. 153 * Then copies the scratchpad to EEPROM. 154 * The data must be on one page. 155 * The master must be locked. 156 * 157 * @param sl The slave structure 158 * @param addr Address for the write 159 * @param len length must be <= (W1_PAGE_SIZE - (addr & W1_PAGE_MASK)) 160 * @param data The data to write 161 * @return 0=Success -1=failure 162 */ 163 static int w1_f23_write(struct w1_slave *sl, int addr, int len, const u8 *data) 164 { 165 u8 wrbuf[4]; 166 u8 rdbuf[W1_PAGE_SIZE + 3]; 167 u8 es = (addr + len - 1) & 0x1f; 168 169 /* Write the data to the scratchpad */ 170 if (w1_reset_select_slave(sl)) 171 return -1; 172 173 wrbuf[0] = W1_F23_WRITE_SCRATCH; 174 wrbuf[1] = addr & 0xff; 175 wrbuf[2] = addr >> 8; 176 177 w1_write_block(sl->master, wrbuf, 3); 178 w1_write_block(sl->master, data, len); 179 180 /* Read the scratchpad and verify */ 181 if (w1_reset_select_slave(sl)) 182 return -1; 183 184 w1_write_8(sl->master, W1_F23_READ_SCRATCH); 185 w1_read_block(sl->master, rdbuf, len + 3); 186 187 /* Compare what was read against the data written */ 188 if ((rdbuf[0] != wrbuf[1]) || (rdbuf[1] != wrbuf[2]) || 189 (rdbuf[2] != es) || (memcmp(data, &rdbuf[3], len) != 0)) 190 return -1; 191 192 /* Copy the scratchpad to EEPROM */ 193 if (w1_reset_select_slave(sl)) 194 return -1; 195 196 wrbuf[0] = W1_F23_COPY_SCRATCH; 197 wrbuf[3] = es; 198 w1_write_block(sl->master, wrbuf, 4); 199 200 /* Sleep for 5 ms to wait for the write to complete */ 201 msleep(5); 202 203 /* Reset the bus to wake up the EEPROM (this may not be needed) */ 204 w1_reset_bus(sl->master); 205 206 return 0; 207 } 208 209 static ssize_t w1_f23_write_bin(struct kobject *kobj, char *buf, loff_t off, 210 size_t count) 211 { 212 struct w1_slave *sl = kobj_to_w1_slave(kobj); 213 int addr, len, idx; 214 215 if ((count = w1_f23_fix_count(off, count, W1_EEPROM_SIZE)) == 0) 216 return 0; 217 218 #ifdef CONFIG_W1_F23_CRC 219 /* can only write full blocks in cached mode */ 220 if ((off & W1_PAGE_MASK) || (count & W1_PAGE_MASK)) { 221 dev_err(&sl->dev, "invalid offset/count off=%d cnt=%zd\n", 222 (int)off, count); 223 return -EINVAL; 224 } 225 226 /* make sure the block CRCs are valid */ 227 for (idx = 0; idx < count; idx += W1_PAGE_SIZE) { 228 if (crc16(CRC16_INIT, &buf[idx], W1_PAGE_SIZE) != CRC16_VALID) { 229 dev_err(&sl->dev, "bad CRC at offset %d\n", (int)off); 230 return -EINVAL; 231 } 232 } 233 #endif /* CONFIG_W1_F23_CRC */ 234 235 atomic_inc(&sl->refcnt); 236 if (down_interruptible(&sl->master->mutex)) { 237 count = 0; 238 goto out_dec; 239 } 240 241 /* Can only write data to one page at a time */ 242 idx = 0; 243 while (idx < count) { 244 addr = off + idx; 245 len = W1_PAGE_SIZE - (addr & W1_PAGE_MASK); 246 if (len > (count - idx)) 247 len = count - idx; 248 249 if (w1_f23_write(sl, addr, len, &buf[idx]) < 0) { 250 count = -EIO; 251 goto out_up; 252 } 253 idx += len; 254 } 255 256 out_up: 257 up(&sl->master->mutex); 258 out_dec: 259 atomic_dec(&sl->refcnt); 260 261 return count; 262 } 263 264 static struct bin_attribute w1_f23_bin_attr = { 265 .attr = { 266 .name = "eeprom", 267 .mode = S_IRUGO | S_IWUSR, 268 .owner = THIS_MODULE, 269 }, 270 .size = W1_EEPROM_SIZE, 271 .read = w1_f23_read_bin, 272 .write = w1_f23_write_bin, 273 }; 274 275 static int w1_f23_add_slave(struct w1_slave *sl) 276 { 277 int err; 278 #ifdef CONFIG_W1_F23_CRC 279 struct w1_f23_data *data; 280 281 data = kmalloc(sizeof(struct w1_f23_data), GFP_KERNEL); 282 if (!data) 283 return -ENOMEM; 284 memset(data, 0, sizeof(struct w1_f23_data)); 285 sl->family_data = data; 286 287 #endif /* CONFIG_W1_F23_CRC */ 288 289 err = sysfs_create_bin_file(&sl->dev.kobj, &w1_f23_bin_attr); 290 291 #ifdef CONFIG_W1_F23_CRC 292 if (err) 293 kfree(data); 294 #endif /* CONFIG_W1_F23_CRC */ 295 296 return err; 297 } 298 299 static void w1_f23_remove_slave(struct w1_slave *sl) 300 { 301 #ifdef CONFIG_W1_F23_CRC 302 kfree(sl->family_data); 303 sl->family_data = NULL; 304 #endif /* CONFIG_W1_F23_CRC */ 305 sysfs_remove_bin_file(&sl->dev.kobj, &w1_f23_bin_attr); 306 } 307 308 static struct w1_family_ops w1_f23_fops = { 309 .add_slave = w1_f23_add_slave, 310 .remove_slave = w1_f23_remove_slave, 311 }; 312 313 static struct w1_family w1_family_23 = { 314 .fid = W1_EEPROM_DS2433, 315 .fops = &w1_f23_fops, 316 }; 317 318 static int __init w1_f23_init(void) 319 { 320 return w1_register_family(&w1_family_23); 321 } 322 323 static void __exit w1_f23_fini(void) 324 { 325 w1_unregister_family(&w1_family_23); 326 } 327 328 module_init(w1_f23_init); 329 module_exit(w1_f23_fini); 330