1/* 2 * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net> 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License as published by 6 * the Free Software Foundation; either version 2 of the License, or 7 * (at your option) any later version. 8 * 9 * This program is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 */ 14 15#ifndef __LINUX_W1_H 16#define __LINUX_W1_H 17 18#include <linux/device.h> 19 20/** 21 * struct w1_reg_num - broken out slave device id 22 * 23 * @family: identifies the type of device 24 * @id: along with family is the unique device id 25 * @crc: checksum of the other bytes 26 */ 27struct w1_reg_num { 28#if defined(__LITTLE_ENDIAN_BITFIELD) 29 __u64 family:8, 30 id:48, 31 crc:8; 32#elif defined(__BIG_ENDIAN_BITFIELD) 33 __u64 crc:8, 34 id:48, 35 family:8; 36#else 37#error "Please fix <asm/byteorder.h>" 38#endif 39}; 40 41#ifdef __KERNEL__ 42 43#define W1_MAXNAMELEN 32 44 45#define W1_SEARCH 0xF0 46#define W1_ALARM_SEARCH 0xEC 47#define W1_CONVERT_TEMP 0x44 48#define W1_SKIP_ROM 0xCC 49#define W1_COPY_SCRATCHPAD 0x48 50#define W1_WRITE_SCRATCHPAD 0x4E 51#define W1_READ_SCRATCHPAD 0xBE 52#define W1_READ_ROM 0x33 53#define W1_READ_PSUPPLY 0xB4 54#define W1_MATCH_ROM 0x55 55#define W1_RESUME_CMD 0xA5 56 57/** 58 * struct w1_slave - holds a single slave device on the bus 59 * 60 * @owner: Points to the one wire "wire" kernel module. 61 * @name: Device id is ascii. 62 * @w1_slave_entry: data for the linked list 63 * @reg_num: the slave id in binary 64 * @refcnt: reference count, delete when 0 65 * @flags: bit flags for W1_SLAVE_ACTIVE W1_SLAVE_DETACH 66 * @ttl: decrement per search this slave isn't found, deatch at 0 67 * @master: bus which this slave is on 68 * @family: module for device family type 69 * @family_data: pointer for use by the family module 70 * @dev: kernel device identifier 71 * @hwmon: pointer to hwmon device 72 * 73 */ 74struct w1_slave { 75 struct module *owner; 76 unsigned char name[W1_MAXNAMELEN]; 77 struct list_head w1_slave_entry; 78 struct w1_reg_num reg_num; 79 atomic_t refcnt; 80 int ttl; 81 unsigned long flags; 82 83 struct w1_master *master; 84 struct w1_family *family; 85 void *family_data; 86 struct device dev; 87 struct device *hwmon; 88}; 89 90typedef void (*w1_slave_found_callback)(struct w1_master *, u64); 91 92/** 93 * struct w1_bus_master - operations available on a bus master 94 * 95 * @data: the first parameter in all the functions below 96 * 97 * @read_bit: Sample the line level @return the level read (0 or 1) 98 * 99 * @write_bit: Sets the line level 100 * 101 * @touch_bit: the lowest-level function for devices that really support the 102 * 1-wire protocol. 103 * touch_bit(0) = write-0 cycle 104 * touch_bit(1) = write-1 / read cycle 105 * @return the bit read (0 or 1) 106 * 107 * @read_byte: Reads a bytes. Same as 8 touch_bit(1) calls. 108 * @return the byte read 109 * 110 * @write_byte: Writes a byte. Same as 8 touch_bit(x) calls. 111 * 112 * @read_block: Same as a series of read_byte() calls 113 * @return the number of bytes read 114 * 115 * @write_block: Same as a series of write_byte() calls 116 * 117 * @triplet: Combines two reads and a smart write for ROM searches 118 * @return bit0=Id bit1=comp_id bit2=dir_taken 119 * 120 * @reset_bus: long write-0 with a read for the presence pulse detection 121 * @return -1=Error, 0=Device present, 1=No device present 122 * 123 * @set_pullup: Put out a strong pull-up pulse of the specified duration. 124 * @return -1=Error, 0=completed 125 * 126 * @search: Really nice hardware can handles the different types of ROM search 127 * w1_master* is passed to the slave found callback. 128 * u8 is search_type, W1_SEARCH or W1_ALARM_SEARCH 129 * 130 * Note: read_bit and write_bit are very low level functions and should only 131 * be used with hardware that doesn't really support 1-wire operations, 132 * like a parallel/serial port. 133 * Either define read_bit and write_bit OR define, at minimum, touch_bit and 134 * reset_bus. 135 * 136 */ 137struct w1_bus_master { 138 void *data; 139 140 u8 (*read_bit)(void *); 141 142 void (*write_bit)(void *, u8); 143 144 u8 (*touch_bit)(void *, u8); 145 146 u8 (*read_byte)(void *); 147 148 void (*write_byte)(void *, u8); 149 150 u8 (*read_block)(void *, u8 *, int); 151 152 void (*write_block)(void *, const u8 *, int); 153 154 u8 (*triplet)(void *, u8); 155 156 u8 (*reset_bus)(void *); 157 158 u8 (*set_pullup)(void *, int); 159 160 void (*search)(void *, struct w1_master *, 161 u8, w1_slave_found_callback); 162}; 163 164/** 165 * enum w1_master_flags - bitfields used in w1_master.flags 166 * @W1_ABORT_SEARCH: abort searching early on shutdown 167 * @W1_WARN_MAX_COUNT: limit warning when the maximum count is reached 168 */ 169enum w1_master_flags { 170 W1_ABORT_SEARCH = 0, 171 W1_WARN_MAX_COUNT = 1, 172}; 173 174/** 175 * struct w1_master - one per bus master 176 * @w1_master_entry: master linked list 177 * @owner: module owner 178 * @name: dynamically allocate bus name 179 * @list_mutex: protect slist and async_list 180 * @slist: linked list of slaves 181 * @async_list: linked list of netlink commands to execute 182 * @max_slave_count: maximum number of slaves to search for at a time 183 * @slave_count: current number of slaves known 184 * @attempts: number of searches ran 185 * @slave_ttl: number of searches before a slave is timed out 186 * @initialized: prevent init/removal race conditions 187 * @id: w1 bus number 188 * @search_count: number of automatic searches to run, -1 unlimited 189 * @search_id: allows continuing a search 190 * @refcnt: reference count 191 * @priv: private data storage 192 * @enable_pullup: allows a strong pullup 193 * @pullup_duration: time for the next strong pullup 194 * @flags: one of w1_master_flags 195 * @thread: thread for bus search and netlink commands 196 * @mutex: protect most of w1_master 197 * @bus_mutex: pretect concurrent bus access 198 * @driver: sysfs driver 199 * @dev: sysfs device 200 * @bus_master: io operations available 201 * @seq: sequence number used for netlink broadcasts 202 */ 203struct w1_master { 204 struct list_head w1_master_entry; 205 struct module *owner; 206 unsigned char name[W1_MAXNAMELEN]; 207 /* list_mutex protects just slist and async_list so slaves can be 208 * searched for and async commands added while the master has 209 * w1_master.mutex locked and is operating on the bus. 210 * lock order w1_mlock, w1_master.mutex, w1_master.list_mutex 211 */ 212 struct mutex list_mutex; 213 struct list_head slist; 214 struct list_head async_list; 215 int max_slave_count, slave_count; 216 unsigned long attempts; 217 int slave_ttl; 218 int initialized; 219 u32 id; 220 int search_count; 221 /* id to start searching on, to continue a search or 0 to restart */ 222 u64 search_id; 223 224 atomic_t refcnt; 225 226 void *priv; 227 228 /** 5V strong pullup enabled flag, 1 enabled, zero disabled. */ 229 int enable_pullup; 230 /** 5V strong pullup duration in milliseconds, zero disabled. */ 231 int pullup_duration; 232 233 long flags; 234 235 struct task_struct *thread; 236 struct mutex mutex; 237 struct mutex bus_mutex; 238 239 struct device_driver *driver; 240 struct device dev; 241 242 struct w1_bus_master *bus_master; 243 244 u32 seq; 245}; 246 247int w1_add_master_device(struct w1_bus_master *master); 248void w1_remove_master_device(struct w1_bus_master *master); 249 250/** 251 * struct w1_family_ops - operations for a family type 252 * @add_slave: add_slave 253 * @remove_slave: remove_slave 254 * @groups: sysfs group 255 * @chip_info: pointer to struct hwmon_chip_info 256 */ 257struct w1_family_ops { 258 int (*add_slave)(struct w1_slave *sl); 259 void (*remove_slave)(struct w1_slave *sl); 260 const struct attribute_group **groups; 261 const struct hwmon_chip_info *chip_info; 262}; 263 264/** 265 * struct w1_family - reference counted family structure. 266 * @family_entry: family linked list 267 * @fid: 8 bit family identifier 268 * @fops: operations for this family 269 * @refcnt: reference counter 270 */ 271struct w1_family { 272 struct list_head family_entry; 273 u8 fid; 274 275 struct w1_family_ops *fops; 276 277 atomic_t refcnt; 278}; 279 280int w1_register_family(struct w1_family *family); 281void w1_unregister_family(struct w1_family *family); 282 283/** 284 * module_w1_driver() - Helper macro for registering a 1-Wire families 285 * @__w1_family: w1_family struct 286 * 287 * Helper macro for 1-Wire families which do not do anything special in module 288 * init/exit. This eliminates a lot of boilerplate. Each module may only 289 * use this macro once, and calling it replaces module_init() and module_exit() 290 */ 291#define module_w1_family(__w1_family) \ 292 module_driver(__w1_family, w1_register_family, \ 293 w1_unregister_family) 294 295u8 w1_triplet(struct w1_master *dev, int bdir); 296u8 w1_touch_bit(struct w1_master *dev, int bit); 297void w1_write_8(struct w1_master *, u8); 298u8 w1_read_8(struct w1_master *); 299int w1_reset_bus(struct w1_master *); 300u8 w1_calc_crc8(u8 *, int); 301void w1_write_block(struct w1_master *, const u8 *, int); 302void w1_touch_block(struct w1_master *, u8 *, int); 303u8 w1_read_block(struct w1_master *, u8 *, int); 304int w1_reset_select_slave(struct w1_slave *sl); 305int w1_reset_resume_command(struct w1_master *); 306void w1_next_pullup(struct w1_master *, int); 307 308static inline struct w1_slave* dev_to_w1_slave(struct device *dev) 309{ 310 return container_of(dev, struct w1_slave, dev); 311} 312 313static inline struct w1_slave* kobj_to_w1_slave(struct kobject *kobj) 314{ 315 return dev_to_w1_slave(container_of(kobj, struct device, kobj)); 316} 317 318static inline struct w1_master* dev_to_w1_master(struct device *dev) 319{ 320 return container_of(dev, struct w1_master, dev); 321} 322 323#endif /* __KERNEL__ */ 324 325#endif /* __LINUX_W1_H */ 326