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