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 w1_f29_read_state( 76 struct file *filp, struct kobject *kobj, 77 struct bin_attribute *bin_attr, 78 char *buf, loff_t off, size_t count) 79 { 80 dev_dbg(&kobj_to_w1_slave(kobj)->dev, 81 "Reading %s kobj: %p, off: %0#10x, count: %zu, buff addr: %p", 82 bin_attr->attr.name, kobj, (unsigned int)off, count, buf); 83 if (count != 1 || off != 0) 84 return -EFAULT; 85 return _read_reg(kobj_to_w1_slave(kobj), W1_F29_REG_LOGIG_STATE, buf); 86 } 87 88 static ssize_t w1_f29_read_output( 89 struct file *filp, struct kobject *kobj, 90 struct bin_attribute *bin_attr, 91 char *buf, loff_t off, size_t count) 92 { 93 dev_dbg(&kobj_to_w1_slave(kobj)->dev, 94 "Reading %s kobj: %p, off: %0#10x, count: %zu, buff addr: %p", 95 bin_attr->attr.name, kobj, (unsigned int)off, count, buf); 96 if (count != 1 || off != 0) 97 return -EFAULT; 98 return _read_reg(kobj_to_w1_slave(kobj), 99 W1_F29_REG_OUTPUT_LATCH_STATE, buf); 100 } 101 102 static ssize_t w1_f29_read_activity( 103 struct file *filp, struct kobject *kobj, 104 struct bin_attribute *bin_attr, 105 char *buf, loff_t off, size_t count) 106 { 107 dev_dbg(&kobj_to_w1_slave(kobj)->dev, 108 "Reading %s kobj: %p, off: %0#10x, count: %zu, buff addr: %p", 109 bin_attr->attr.name, kobj, (unsigned int)off, count, buf); 110 if (count != 1 || off != 0) 111 return -EFAULT; 112 return _read_reg(kobj_to_w1_slave(kobj), 113 W1_F29_REG_ACTIVITY_LATCH_STATE, buf); 114 } 115 116 static ssize_t w1_f29_read_cond_search_mask( 117 struct file *filp, struct kobject *kobj, 118 struct bin_attribute *bin_attr, 119 char *buf, loff_t off, size_t count) 120 { 121 dev_dbg(&kobj_to_w1_slave(kobj)->dev, 122 "Reading %s kobj: %p, off: %0#10x, count: %zu, buff addr: %p", 123 bin_attr->attr.name, kobj, (unsigned int)off, count, buf); 124 if (count != 1 || off != 0) 125 return -EFAULT; 126 return _read_reg(kobj_to_w1_slave(kobj), 127 W1_F29_REG_COND_SEARCH_SELECT_MASK, buf); 128 } 129 130 static ssize_t w1_f29_read_cond_search_polarity( 131 struct file *filp, struct kobject *kobj, 132 struct bin_attribute *bin_attr, 133 char *buf, loff_t off, size_t count) 134 { 135 if (count != 1 || off != 0) 136 return -EFAULT; 137 return _read_reg(kobj_to_w1_slave(kobj), 138 W1_F29_REG_COND_SEARCH_POL_SELECT, buf); 139 } 140 141 static ssize_t w1_f29_read_status_control( 142 struct file *filp, struct kobject *kobj, 143 struct bin_attribute *bin_attr, 144 char *buf, loff_t off, size_t count) 145 { 146 if (count != 1 || off != 0) 147 return -EFAULT; 148 return _read_reg(kobj_to_w1_slave(kobj), 149 W1_F29_REG_CONTROL_AND_STATUS, buf); 150 } 151 152 153 154 155 static ssize_t w1_f29_write_output( 156 struct file *filp, struct kobject *kobj, 157 struct bin_attribute *bin_attr, 158 char *buf, loff_t off, size_t count) 159 { 160 struct w1_slave *sl = kobj_to_w1_slave(kobj); 161 u8 w1_buf[3]; 162 u8 readBack; 163 unsigned int retries = W1_F29_RETRIES; 164 165 if (count != 1 || off != 0) 166 return -EFAULT; 167 168 dev_dbg(&sl->dev, "locking mutex for write_output"); 169 mutex_lock(&sl->master->bus_mutex); 170 dev_dbg(&sl->dev, "mutex locked"); 171 172 if (w1_reset_select_slave(sl)) 173 goto error; 174 175 while (retries--) { 176 w1_buf[0] = W1_F29_FUNC_CHANN_ACCESS_WRITE; 177 w1_buf[1] = *buf; 178 w1_buf[2] = ~(*buf); 179 w1_write_block(sl->master, w1_buf, 3); 180 181 readBack = w1_read_8(sl->master); 182 183 if (readBack != W1_F29_SUCCESS_CONFIRM_BYTE) { 184 if (w1_reset_resume_command(sl->master)) 185 goto error; 186 /* try again, the slave is ready for a command */ 187 continue; 188 } 189 190 #ifdef CONFIG_W1_SLAVE_DS2408_READBACK 191 /* here the master could read another byte which 192 would be the PIO reg (the actual pin logic state) 193 since in this driver we don't know which pins are 194 in and outs, there's no value to read the state and 195 compare. with (*buf) so end this command abruptly: */ 196 if (w1_reset_resume_command(sl->master)) 197 goto error; 198 199 /* go read back the output latches */ 200 /* (the direct effect of the write above) */ 201 w1_buf[0] = W1_F29_FUNC_READ_PIO_REGS; 202 w1_buf[1] = W1_F29_REG_OUTPUT_LATCH_STATE; 203 w1_buf[2] = 0; 204 w1_write_block(sl->master, w1_buf, 3); 205 /* read the result of the READ_PIO_REGS command */ 206 if (w1_read_8(sl->master) == *buf) 207 #endif 208 { 209 /* success! */ 210 mutex_unlock(&sl->master->bus_mutex); 211 dev_dbg(&sl->dev, 212 "mutex unlocked, retries:%d", retries); 213 return 1; 214 } 215 } 216 error: 217 mutex_unlock(&sl->master->bus_mutex); 218 dev_dbg(&sl->dev, "mutex unlocked in error, retries:%d", retries); 219 220 return -EIO; 221 } 222 223 224 /** 225 * Writing to the activity file resets the activity latches. 226 */ 227 static ssize_t w1_f29_write_activity( 228 struct file *filp, struct kobject *kobj, 229 struct bin_attribute *bin_attr, 230 char *buf, loff_t off, size_t count) 231 { 232 struct w1_slave *sl = kobj_to_w1_slave(kobj); 233 unsigned int retries = W1_F29_RETRIES; 234 235 if (count != 1 || off != 0) 236 return -EFAULT; 237 238 mutex_lock(&sl->master->bus_mutex); 239 240 if (w1_reset_select_slave(sl)) 241 goto error; 242 243 while (retries--) { 244 w1_write_8(sl->master, W1_F29_FUNC_RESET_ACTIVITY_LATCHES); 245 if (w1_read_8(sl->master) == W1_F29_SUCCESS_CONFIRM_BYTE) { 246 mutex_unlock(&sl->master->bus_mutex); 247 return 1; 248 } 249 if (w1_reset_resume_command(sl->master)) 250 goto error; 251 } 252 253 error: 254 mutex_unlock(&sl->master->bus_mutex); 255 return -EIO; 256 } 257 258 static ssize_t w1_f29_write_status_control( 259 struct file *filp, 260 struct kobject *kobj, 261 struct bin_attribute *bin_attr, 262 char *buf, 263 loff_t off, 264 size_t count) 265 { 266 struct w1_slave *sl = kobj_to_w1_slave(kobj); 267 u8 w1_buf[4]; 268 unsigned int retries = W1_F29_RETRIES; 269 270 if (count != 1 || off != 0) 271 return -EFAULT; 272 273 mutex_lock(&sl->master->bus_mutex); 274 275 if (w1_reset_select_slave(sl)) 276 goto error; 277 278 while (retries--) { 279 w1_buf[0] = W1_F29_FUNC_WRITE_COND_SEARCH_REG; 280 w1_buf[1] = W1_F29_REG_CONTROL_AND_STATUS; 281 w1_buf[2] = 0; 282 w1_buf[3] = *buf; 283 284 w1_write_block(sl->master, w1_buf, 4); 285 if (w1_reset_resume_command(sl->master)) 286 goto error; 287 288 w1_buf[0] = W1_F29_FUNC_READ_PIO_REGS; 289 w1_buf[1] = W1_F29_REG_CONTROL_AND_STATUS; 290 w1_buf[2] = 0; 291 292 w1_write_block(sl->master, w1_buf, 3); 293 if (w1_read_8(sl->master) == *buf) { 294 /* success! */ 295 mutex_unlock(&sl->master->bus_mutex); 296 return 1; 297 } 298 } 299 error: 300 mutex_unlock(&sl->master->bus_mutex); 301 302 return -EIO; 303 } 304 305 /* 306 * This is a special sequence we must do to ensure the P0 output is not stuck 307 * in test mode. This is described in rev 2 of the ds2408's datasheet 308 * (http://datasheets.maximintegrated.com/en/ds/DS2408.pdf) under 309 * "APPLICATION INFORMATION/Power-up timing". 310 */ 311 static int w1_f29_disable_test_mode(struct w1_slave *sl) 312 { 313 int res; 314 u8 magic[10] = {0x96, }; 315 u64 rn = le64_to_cpu(*((u64*)&sl->reg_num)); 316 317 memcpy(&magic[1], &rn, 8); 318 magic[9] = 0x3C; 319 320 mutex_lock(&sl->master->bus_mutex); 321 322 res = w1_reset_bus(sl->master); 323 if (res) 324 goto out; 325 w1_write_block(sl->master, magic, ARRAY_SIZE(magic)); 326 327 res = w1_reset_bus(sl->master); 328 out: 329 mutex_unlock(&sl->master->bus_mutex); 330 return res; 331 } 332 333 static struct bin_attribute w1_f29_sysfs_bin_files[] = { 334 { 335 .attr = { 336 .name = "state", 337 .mode = S_IRUGO, 338 }, 339 .size = 1, 340 .read = w1_f29_read_state, 341 }, 342 { 343 .attr = { 344 .name = "output", 345 .mode = S_IRUGO | S_IWUSR | S_IWGRP, 346 }, 347 .size = 1, 348 .read = w1_f29_read_output, 349 .write = w1_f29_write_output, 350 }, 351 { 352 .attr = { 353 .name = "activity", 354 .mode = S_IRUGO, 355 }, 356 .size = 1, 357 .read = w1_f29_read_activity, 358 .write = w1_f29_write_activity, 359 }, 360 { 361 .attr = { 362 .name = "cond_search_mask", 363 .mode = S_IRUGO, 364 }, 365 .size = 1, 366 .read = w1_f29_read_cond_search_mask, 367 }, 368 { 369 .attr = { 370 .name = "cond_search_polarity", 371 .mode = S_IRUGO, 372 }, 373 .size = 1, 374 .read = w1_f29_read_cond_search_polarity, 375 }, 376 { 377 .attr = { 378 .name = "status_control", 379 .mode = S_IRUGO | S_IWUSR | S_IWGRP, 380 }, 381 .size = 1, 382 .read = w1_f29_read_status_control, 383 .write = w1_f29_write_status_control, 384 } 385 }; 386 387 static int w1_f29_add_slave(struct w1_slave *sl) 388 { 389 int err = 0; 390 int i; 391 392 err = w1_f29_disable_test_mode(sl); 393 if (err) 394 return err; 395 396 for (i = 0; i < ARRAY_SIZE(w1_f29_sysfs_bin_files) && !err; ++i) 397 err = sysfs_create_bin_file( 398 &sl->dev.kobj, 399 &(w1_f29_sysfs_bin_files[i])); 400 if (err) 401 while (--i >= 0) 402 sysfs_remove_bin_file(&sl->dev.kobj, 403 &(w1_f29_sysfs_bin_files[i])); 404 return err; 405 } 406 407 static void w1_f29_remove_slave(struct w1_slave *sl) 408 { 409 int i; 410 for (i = ARRAY_SIZE(w1_f29_sysfs_bin_files) - 1; i >= 0; --i) 411 sysfs_remove_bin_file(&sl->dev.kobj, 412 &(w1_f29_sysfs_bin_files[i])); 413 } 414 415 static struct w1_family_ops w1_f29_fops = { 416 .add_slave = w1_f29_add_slave, 417 .remove_slave = w1_f29_remove_slave, 418 }; 419 420 static struct w1_family w1_family_29 = { 421 .fid = W1_FAMILY_DS2408, 422 .fops = &w1_f29_fops, 423 }; 424 425 static int __init w1_f29_init(void) 426 { 427 return w1_register_family(&w1_family_29); 428 } 429 430 static void __exit w1_f29_exit(void) 431 { 432 w1_unregister_family(&w1_family_29); 433 } 434 435 module_init(w1_f29_init); 436 module_exit(w1_f29_exit); 437