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