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