1 /* 2 * w1_ds2408.c - w1 family 29 (DS2408) driver 3 * 4 * Copyright (c) 2010 Jean-Francois Dagenais <dagenaisj@sonatest.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 18 #include "../w1.h" 19 #include "../w1_int.h" 20 #include "../w1_family.h" 21 22 MODULE_LICENSE("GPL"); 23 MODULE_AUTHOR("Jean-Francois Dagenais <dagenaisj@sonatest.com>"); 24 MODULE_DESCRIPTION("w1 family 29 driver for DS2408 8 Pin IO"); 25 MODULE_ALIAS("w1-family-" __stringify(W1_FAMILY_DS2408)); 26 27 28 #define W1_F29_RETRIES 3 29 30 #define W1_F29_REG_LOGIG_STATE 0x88 /* R */ 31 #define W1_F29_REG_OUTPUT_LATCH_STATE 0x89 /* R */ 32 #define W1_F29_REG_ACTIVITY_LATCH_STATE 0x8A /* R */ 33 #define W1_F29_REG_COND_SEARCH_SELECT_MASK 0x8B /* RW */ 34 #define W1_F29_REG_COND_SEARCH_POL_SELECT 0x8C /* RW */ 35 #define W1_F29_REG_CONTROL_AND_STATUS 0x8D /* RW */ 36 37 #define W1_F29_FUNC_READ_PIO_REGS 0xF0 38 #define W1_F29_FUNC_CHANN_ACCESS_READ 0xF5 39 #define W1_F29_FUNC_CHANN_ACCESS_WRITE 0x5A 40 /* also used to write the control/status reg (0x8D): */ 41 #define W1_F29_FUNC_WRITE_COND_SEARCH_REG 0xCC 42 #define W1_F29_FUNC_RESET_ACTIVITY_LATCHES 0xC3 43 44 #define W1_F29_SUCCESS_CONFIRM_BYTE 0xAA 45 46 static int _read_reg(struct w1_slave *sl, u8 address, unsigned char* buf) 47 { 48 u8 wrbuf[3]; 49 dev_dbg(&sl->dev, 50 "Reading with slave: %p, reg addr: %0#4x, buff addr: %p", 51 sl, (unsigned int)address, buf); 52 53 if (!buf) 54 return -EINVAL; 55 56 mutex_lock(&sl->master->bus_mutex); 57 dev_dbg(&sl->dev, "mutex locked"); 58 59 if (w1_reset_select_slave(sl)) { 60 mutex_unlock(&sl->master->bus_mutex); 61 return -EIO; 62 } 63 64 wrbuf[0] = W1_F29_FUNC_READ_PIO_REGS; 65 wrbuf[1] = address; 66 wrbuf[2] = 0; 67 w1_write_block(sl->master, wrbuf, 3); 68 *buf = w1_read_8(sl->master); 69 70 mutex_unlock(&sl->master->bus_mutex); 71 dev_dbg(&sl->dev, "mutex unlocked"); 72 return 1; 73 } 74 75 static ssize_t state_read(struct file *filp, struct kobject *kobj, 76 struct bin_attribute *bin_attr, char *buf, loff_t off, 77 size_t count) 78 { 79 dev_dbg(&kobj_to_w1_slave(kobj)->dev, 80 "Reading %s kobj: %p, off: %0#10x, count: %zu, buff addr: %p", 81 bin_attr->attr.name, kobj, (unsigned int)off, count, buf); 82 if (count != 1 || off != 0) 83 return -EFAULT; 84 return _read_reg(kobj_to_w1_slave(kobj), W1_F29_REG_LOGIG_STATE, buf); 85 } 86 87 static ssize_t output_read(struct file *filp, struct kobject *kobj, 88 struct bin_attribute *bin_attr, char *buf, 89 loff_t off, size_t count) 90 { 91 dev_dbg(&kobj_to_w1_slave(kobj)->dev, 92 "Reading %s kobj: %p, off: %0#10x, count: %zu, buff addr: %p", 93 bin_attr->attr.name, kobj, (unsigned int)off, count, buf); 94 if (count != 1 || off != 0) 95 return -EFAULT; 96 return _read_reg(kobj_to_w1_slave(kobj), 97 W1_F29_REG_OUTPUT_LATCH_STATE, buf); 98 } 99 100 static ssize_t activity_read(struct file *filp, struct kobject *kobj, 101 struct bin_attribute *bin_attr, char *buf, 102 loff_t off, size_t count) 103 { 104 dev_dbg(&kobj_to_w1_slave(kobj)->dev, 105 "Reading %s kobj: %p, off: %0#10x, count: %zu, buff addr: %p", 106 bin_attr->attr.name, kobj, (unsigned int)off, count, buf); 107 if (count != 1 || off != 0) 108 return -EFAULT; 109 return _read_reg(kobj_to_w1_slave(kobj), 110 W1_F29_REG_ACTIVITY_LATCH_STATE, buf); 111 } 112 113 static ssize_t cond_search_mask_read(struct file *filp, struct kobject *kobj, 114 struct bin_attribute *bin_attr, char *buf, 115 loff_t off, size_t count) 116 { 117 dev_dbg(&kobj_to_w1_slave(kobj)->dev, 118 "Reading %s kobj: %p, off: %0#10x, count: %zu, buff addr: %p", 119 bin_attr->attr.name, kobj, (unsigned int)off, count, buf); 120 if (count != 1 || off != 0) 121 return -EFAULT; 122 return _read_reg(kobj_to_w1_slave(kobj), 123 W1_F29_REG_COND_SEARCH_SELECT_MASK, buf); 124 } 125 126 static ssize_t cond_search_polarity_read(struct file *filp, 127 struct kobject *kobj, 128 struct bin_attribute *bin_attr, 129 char *buf, loff_t off, size_t count) 130 { 131 if (count != 1 || off != 0) 132 return -EFAULT; 133 return _read_reg(kobj_to_w1_slave(kobj), 134 W1_F29_REG_COND_SEARCH_POL_SELECT, buf); 135 } 136 137 static ssize_t status_control_read(struct file *filp, struct kobject *kobj, 138 struct bin_attribute *bin_attr, char *buf, 139 loff_t off, size_t count) 140 { 141 if (count != 1 || off != 0) 142 return -EFAULT; 143 return _read_reg(kobj_to_w1_slave(kobj), 144 W1_F29_REG_CONTROL_AND_STATUS, buf); 145 } 146 147 static ssize_t output_write(struct file *filp, struct kobject *kobj, 148 struct bin_attribute *bin_attr, char *buf, 149 loff_t off, size_t count) 150 { 151 struct w1_slave *sl = kobj_to_w1_slave(kobj); 152 u8 w1_buf[3]; 153 u8 readBack; 154 unsigned int retries = W1_F29_RETRIES; 155 156 if (count != 1 || off != 0) 157 return -EFAULT; 158 159 dev_dbg(&sl->dev, "locking mutex for write_output"); 160 mutex_lock(&sl->master->bus_mutex); 161 dev_dbg(&sl->dev, "mutex locked"); 162 163 if (w1_reset_select_slave(sl)) 164 goto error; 165 166 while (retries--) { 167 w1_buf[0] = W1_F29_FUNC_CHANN_ACCESS_WRITE; 168 w1_buf[1] = *buf; 169 w1_buf[2] = ~(*buf); 170 w1_write_block(sl->master, w1_buf, 3); 171 172 readBack = w1_read_8(sl->master); 173 174 if (readBack != W1_F29_SUCCESS_CONFIRM_BYTE) { 175 if (w1_reset_resume_command(sl->master)) 176 goto error; 177 /* try again, the slave is ready for a command */ 178 continue; 179 } 180 181 #ifdef CONFIG_W1_SLAVE_DS2408_READBACK 182 /* here the master could read another byte which 183 would be the PIO reg (the actual pin logic state) 184 since in this driver we don't know which pins are 185 in and outs, there's no value to read the state and 186 compare. with (*buf) so end this command abruptly: */ 187 if (w1_reset_resume_command(sl->master)) 188 goto error; 189 190 /* go read back the output latches */ 191 /* (the direct effect of the write above) */ 192 w1_buf[0] = W1_F29_FUNC_READ_PIO_REGS; 193 w1_buf[1] = W1_F29_REG_OUTPUT_LATCH_STATE; 194 w1_buf[2] = 0; 195 w1_write_block(sl->master, w1_buf, 3); 196 /* read the result of the READ_PIO_REGS command */ 197 if (w1_read_8(sl->master) == *buf) 198 #endif 199 { 200 /* success! */ 201 mutex_unlock(&sl->master->bus_mutex); 202 dev_dbg(&sl->dev, 203 "mutex unlocked, retries:%d", retries); 204 return 1; 205 } 206 } 207 error: 208 mutex_unlock(&sl->master->bus_mutex); 209 dev_dbg(&sl->dev, "mutex unlocked in error, retries:%d", retries); 210 211 return -EIO; 212 } 213 214 215 /** 216 * Writing to the activity file resets the activity latches. 217 */ 218 static ssize_t activity_write(struct file *filp, struct kobject *kobj, 219 struct bin_attribute *bin_attr, char *buf, 220 loff_t off, size_t count) 221 { 222 struct w1_slave *sl = kobj_to_w1_slave(kobj); 223 unsigned int retries = W1_F29_RETRIES; 224 225 if (count != 1 || off != 0) 226 return -EFAULT; 227 228 mutex_lock(&sl->master->bus_mutex); 229 230 if (w1_reset_select_slave(sl)) 231 goto error; 232 233 while (retries--) { 234 w1_write_8(sl->master, W1_F29_FUNC_RESET_ACTIVITY_LATCHES); 235 if (w1_read_8(sl->master) == W1_F29_SUCCESS_CONFIRM_BYTE) { 236 mutex_unlock(&sl->master->bus_mutex); 237 return 1; 238 } 239 if (w1_reset_resume_command(sl->master)) 240 goto error; 241 } 242 243 error: 244 mutex_unlock(&sl->master->bus_mutex); 245 return -EIO; 246 } 247 248 static ssize_t status_control_write(struct file *filp, struct kobject *kobj, 249 struct bin_attribute *bin_attr, char *buf, 250 loff_t off, size_t count) 251 { 252 struct w1_slave *sl = kobj_to_w1_slave(kobj); 253 u8 w1_buf[4]; 254 unsigned int retries = W1_F29_RETRIES; 255 256 if (count != 1 || off != 0) 257 return -EFAULT; 258 259 mutex_lock(&sl->master->bus_mutex); 260 261 if (w1_reset_select_slave(sl)) 262 goto error; 263 264 while (retries--) { 265 w1_buf[0] = W1_F29_FUNC_WRITE_COND_SEARCH_REG; 266 w1_buf[1] = W1_F29_REG_CONTROL_AND_STATUS; 267 w1_buf[2] = 0; 268 w1_buf[3] = *buf; 269 270 w1_write_block(sl->master, w1_buf, 4); 271 if (w1_reset_resume_command(sl->master)) 272 goto error; 273 274 w1_buf[0] = W1_F29_FUNC_READ_PIO_REGS; 275 w1_buf[1] = W1_F29_REG_CONTROL_AND_STATUS; 276 w1_buf[2] = 0; 277 278 w1_write_block(sl->master, w1_buf, 3); 279 if (w1_read_8(sl->master) == *buf) { 280 /* success! */ 281 mutex_unlock(&sl->master->bus_mutex); 282 return 1; 283 } 284 } 285 error: 286 mutex_unlock(&sl->master->bus_mutex); 287 288 return -EIO; 289 } 290 291 /* 292 * This is a special sequence we must do to ensure the P0 output is not stuck 293 * in test mode. This is described in rev 2 of the ds2408's datasheet 294 * (http://datasheets.maximintegrated.com/en/ds/DS2408.pdf) under 295 * "APPLICATION INFORMATION/Power-up timing". 296 */ 297 static int w1_f29_disable_test_mode(struct w1_slave *sl) 298 { 299 int res; 300 u8 magic[10] = {0x96, }; 301 u64 rn = le64_to_cpu(*((u64*)&sl->reg_num)); 302 303 memcpy(&magic[1], &rn, 8); 304 magic[9] = 0x3C; 305 306 mutex_lock(&sl->master->bus_mutex); 307 308 res = w1_reset_bus(sl->master); 309 if (res) 310 goto out; 311 w1_write_block(sl->master, magic, ARRAY_SIZE(magic)); 312 313 res = w1_reset_bus(sl->master); 314 out: 315 mutex_unlock(&sl->master->bus_mutex); 316 return res; 317 } 318 319 static BIN_ATTR_RO(state, 1); 320 static BIN_ATTR_RW(output, 1); 321 static BIN_ATTR_RW(activity, 1); 322 static BIN_ATTR_RO(cond_search_mask, 1); 323 static BIN_ATTR_RO(cond_search_polarity, 1); 324 static BIN_ATTR_RW(status_control, 1); 325 326 static struct bin_attribute *w1_f29_bin_attrs[] = { 327 &bin_attr_state, 328 &bin_attr_output, 329 &bin_attr_activity, 330 &bin_attr_cond_search_mask, 331 &bin_attr_cond_search_polarity, 332 &bin_attr_status_control, 333 NULL, 334 }; 335 336 static const struct attribute_group w1_f29_group = { 337 .bin_attrs = w1_f29_bin_attrs, 338 }; 339 340 static const struct attribute_group *w1_f29_groups[] = { 341 &w1_f29_group, 342 NULL, 343 }; 344 345 static struct w1_family_ops w1_f29_fops = { 346 .add_slave = w1_f29_disable_test_mode, 347 .groups = w1_f29_groups, 348 }; 349 350 static struct w1_family w1_family_29 = { 351 .fid = W1_FAMILY_DS2408, 352 .fops = &w1_f29_fops, 353 }; 354 355 static int __init w1_f29_init(void) 356 { 357 return w1_register_family(&w1_family_29); 358 } 359 360 static void __exit w1_f29_exit(void) 361 { 362 w1_unregister_family(&w1_family_29); 363 } 364 365 module_init(w1_f29_init); 366 module_exit(w1_f29_exit); 367