linux/drivers/w1/w1.h
<<
>>
Prefs
   1/*
   2 *      w1.h
   3 *
   4 * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
   5 *
   6 *
   7 * This program is free software; you can redistribute it and/or modify
   8 * it under the terms of the GNU General Public License as published by
   9 * the Free Software Foundation; either version 2 of the License, or
  10 * (at your option) any later version.
  11 *
  12 * This program is distributed in the hope that it will be useful,
  13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 * GNU General Public License for more details.
  16 *
  17 * You should have received a copy of the GNU General Public License
  18 * along with this program; if not, write to the Free Software
  19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20 */
  21
  22#ifndef __W1_H
  23#define __W1_H
  24
  25struct w1_reg_num
  26{
  27#if defined(__LITTLE_ENDIAN_BITFIELD)
  28        __u64   family:8,
  29                id:48,
  30                crc:8;
  31#elif defined(__BIG_ENDIAN_BITFIELD)
  32        __u64   crc:8,
  33                id:48,
  34                family:8;
  35#else
  36#error "Please fix <asm/byteorder.h>"
  37#endif
  38};
  39
  40#ifdef __KERNEL__
  41
  42#include <linux/completion.h>
  43#include <linux/device.h>
  44#include <linux/mutex.h>
  45
  46#include "w1_family.h"
  47
  48#define W1_MAXNAMELEN           32
  49
  50#define W1_SEARCH               0xF0
  51#define W1_ALARM_SEARCH         0xEC
  52#define W1_CONVERT_TEMP         0x44
  53#define W1_SKIP_ROM             0xCC
  54#define W1_READ_SCRATCHPAD      0xBE
  55#define W1_READ_ROM             0x33
  56#define W1_READ_PSUPPLY         0xB4
  57#define W1_MATCH_ROM            0x55
  58#define W1_RESUME_CMD           0xA5
  59
  60#define W1_SLAVE_ACTIVE         0
  61
  62struct w1_slave
  63{
  64        struct module           *owner;
  65        unsigned char           name[W1_MAXNAMELEN];
  66        struct list_head        w1_slave_entry;
  67        struct w1_reg_num       reg_num;
  68        atomic_t                refcnt;
  69        u8                      rom[9];
  70        u32                     flags;
  71        int                     ttl;
  72
  73        struct w1_master        *master;
  74        struct w1_family        *family;
  75        void                    *family_data;
  76        struct device           dev;
  77        struct completion       released;
  78};
  79
  80typedef void (*w1_slave_found_callback)(struct w1_master *, u64);
  81
  82
  83/**
  84 * Note: read_bit and write_bit are very low level functions and should only
  85 * be used with hardware that doesn't really support 1-wire operations,
  86 * like a parallel/serial port.
  87 * Either define read_bit and write_bit OR define, at minimum, touch_bit and
  88 * reset_bus.
  89 */
  90struct w1_bus_master
  91{
  92        /** the first parameter in all the functions below */
  93        void            *data;
  94
  95        /**
  96         * Sample the line level
  97         * @return the level read (0 or 1)
  98         */
  99        u8              (*read_bit)(void *);
 100
 101        /** Sets the line level */
 102        void            (*write_bit)(void *, u8);
 103
 104        /**
 105         * touch_bit is the lowest-level function for devices that really
 106         * support the 1-wire protocol.
 107         * touch_bit(0) = write-0 cycle
 108         * touch_bit(1) = write-1 / read cycle
 109         * @return the bit read (0 or 1)
 110         */
 111        u8              (*touch_bit)(void *, u8);
 112
 113        /**
 114         * Reads a bytes. Same as 8 touch_bit(1) calls.
 115         * @return the byte read
 116         */
 117        u8              (*read_byte)(void *);
 118
 119        /**
 120         * Writes a byte. Same as 8 touch_bit(x) calls.
 121         */
 122        void            (*write_byte)(void *, u8);
 123
 124        /**
 125         * Same as a series of read_byte() calls
 126         * @return the number of bytes read
 127         */
 128        u8              (*read_block)(void *, u8 *, int);
 129
 130        /** Same as a series of write_byte() calls */
 131        void            (*write_block)(void *, const u8 *, int);
 132
 133        /**
 134         * Combines two reads and a smart write for ROM searches
 135         * @return bit0=Id bit1=comp_id bit2=dir_taken
 136         */
 137        u8              (*triplet)(void *, u8);
 138
 139        /**
 140         * long write-0 with a read for the presence pulse detection
 141         * @return -1=Error, 0=Device present, 1=No device present
 142         */
 143        u8              (*reset_bus)(void *);
 144
 145        /**
 146         * Put out a strong pull-up pulse of the specified duration.
 147         * @return -1=Error, 0=completed
 148         */
 149        u8              (*set_pullup)(void *, int);
 150
 151        /** Really nice hardware can handles the different types of ROM search
 152         *  w1_master* is passed to the slave found callback.
 153         */
 154        void            (*search)(void *, struct w1_master *,
 155                u8, w1_slave_found_callback);
 156};
 157
 158struct w1_master
 159{
 160        struct list_head        w1_master_entry;
 161        struct module           *owner;
 162        unsigned char           name[W1_MAXNAMELEN];
 163        struct list_head        slist;
 164        int                     max_slave_count, slave_count;
 165        unsigned long           attempts;
 166        int                     slave_ttl;
 167        int                     initialized;
 168        u32                     id;
 169        int                     search_count;
 170
 171        atomic_t                refcnt;
 172
 173        void                    *priv;
 174        int                     priv_size;
 175
 176        /** 5V strong pullup enabled flag, 1 enabled, zero disabled. */
 177        int                     enable_pullup;
 178        /** 5V strong pullup duration in milliseconds, zero disabled. */
 179        int                     pullup_duration;
 180
 181        struct task_struct      *thread;
 182        struct mutex            mutex;
 183        struct mutex            bus_mutex;
 184
 185        struct device_driver    *driver;
 186        struct device           dev;
 187
 188        struct w1_bus_master    *bus_master;
 189
 190        u32                     seq;
 191};
 192
 193int w1_create_master_attributes(struct w1_master *);
 194void w1_destroy_master_attributes(struct w1_master *master);
 195void w1_search(struct w1_master *dev, u8 search_type, w1_slave_found_callback cb);
 196void w1_search_devices(struct w1_master *dev, u8 search_type, w1_slave_found_callback cb);
 197struct w1_slave *w1_search_slave(struct w1_reg_num *id);
 198void w1_slave_found(struct w1_master *dev, u64 rn);
 199void w1_search_process_cb(struct w1_master *dev, u8 search_type,
 200        w1_slave_found_callback cb);
 201struct w1_master *w1_search_master_id(u32 id);
 202
 203/* Disconnect and reconnect devices in the given family.  Used for finding
 204 * unclaimed devices after a family has been registered or releasing devices
 205 * after a family has been unregistered.  Set attach to 1 when a new family
 206 * has just been registered, to 0 when it has been unregistered.
 207 */
 208void w1_reconnect_slaves(struct w1_family *f, int attach);
 209void w1_slave_detach(struct w1_slave *sl);
 210
 211u8 w1_triplet(struct w1_master *dev, int bdir);
 212void w1_write_8(struct w1_master *, u8);
 213u8 w1_read_8(struct w1_master *);
 214int w1_reset_bus(struct w1_master *);
 215u8 w1_calc_crc8(u8 *, int);
 216void w1_write_block(struct w1_master *, const u8 *, int);
 217void w1_touch_block(struct w1_master *, u8 *, int);
 218u8 w1_read_block(struct w1_master *, u8 *, int);
 219int w1_reset_select_slave(struct w1_slave *sl);
 220int w1_reset_resume_command(struct w1_master *);
 221void w1_next_pullup(struct w1_master *, int);
 222
 223static inline struct w1_slave* dev_to_w1_slave(struct device *dev)
 224{
 225        return container_of(dev, struct w1_slave, dev);
 226}
 227
 228static inline struct w1_slave* kobj_to_w1_slave(struct kobject *kobj)
 229{
 230        return dev_to_w1_slave(container_of(kobj, struct device, kobj));
 231}
 232
 233static inline struct w1_master* dev_to_w1_master(struct device *dev)
 234{
 235        return container_of(dev, struct w1_master, dev);
 236}
 237
 238extern struct device_driver w1_master_driver;
 239extern struct device w1_master_device;
 240extern int w1_max_slave_count;
 241extern int w1_max_slave_ttl;
 242extern struct list_head w1_masters;
 243extern struct mutex w1_mlock;
 244
 245extern int w1_process(void *);
 246
 247#endif /* __KERNEL__ */
 248
 249#endif /* __W1_H */
 250
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.