w1.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 Roman Tataurov <diytronic@yandex.ru>
 * Copyright (c) 2022 Thomas Stranger
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_DRIVERS_W1_H_
#define ZEPHYR_INCLUDE_DRIVERS_W1_H_
 
#include <zephyr/types.h>
#include <zephyr/device.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/crc.h>
#include <zephyr/sys/byteorder.h>
 
#ifdef __cplusplus
extern "C" {
#endif


 
/*
 * Count the number of slaves expected on the bus.
 * This can be used to decide if the bus has a multidrop topology or
 * only a single slave is present.
 * There is a comma after each ordinal (including the last)
 * Hence FOR_EACH adds "+1" once too often which has to be subtracted in the end.
 */
#define F1(x) 1
#define W1_SLAVE_COUNT(node_id) \
                (FOR_EACH(F1, (+), DT_SUPPORTS_DEP_ORDS(node_id)) - 1)
#define W1_INST_SLAVE_COUNT(inst)  \
                (W1_SLAVE_COUNT(DT_DRV_INST(inst)))


enum w1_settings_type {
        W1_SETTING_SPEED,
        W1_SETTING_STRONG_PULLUP,

        W1_SETINGS_TYPE_COUNT,
};


struct w1_master_config {
        uint16_t slave_count;
};

struct w1_master_data {
        struct k_mutex bus_lock;
};

typedef int (*w1_reset_bus_t)(const struct device *dev);

typedef int (*w1_read_bit_t)(const struct device *dev);

typedef int (*w1_write_bit_t)(const struct device *dev, bool bit);

typedef int (*w1_read_byte_t)(const struct device *dev);

typedef int (*w1_write_byte_t)(const struct device *dev, const uint8_t byte);

typedef int (*w1_read_block_t)(const struct device *dev, uint8_t *buffer,
                               size_t len);

typedef int (*w1_write_block_t)(const struct device *dev, const uint8_t *buffer,
                                size_t len);

typedef size_t (*w1_get_slave_count_t)(const struct device *dev);

typedef int (*w1_configure_t)(const struct device *dev,
                              enum w1_settings_type type, uint32_t value);

typedef int (*w1_change_bus_lock_t)(const struct device *dev, bool lock);

__subsystem struct w1_driver_api {
        w1_reset_bus_t reset_bus;
        w1_read_bit_t read_bit;
        w1_write_bit_t write_bit;
        w1_read_byte_t read_byte;
        w1_write_byte_t write_byte;
        w1_read_block_t read_block;
        w1_write_block_t write_block;
        w1_configure_t configure;
        w1_change_bus_lock_t change_bus_lock;
};


__syscall int w1_change_bus_lock(const struct device *dev, bool lock);
 
static inline int z_impl_w1_change_bus_lock(const struct device *dev, bool lock)
{
        struct w1_master_data *ctrl_data = (struct w1_master_data *)dev->data;
        const struct w1_driver_api *api = DEVICE_API_GET(w1, dev);
 
        if (api->change_bus_lock) {
                return api->change_bus_lock(dev, lock);
        }
 
        if (lock) {
                return k_mutex_lock(&ctrl_data->bus_lock, K_FOREVER);
        } else {
                return k_mutex_unlock(&ctrl_data->bus_lock);
        }
}

static inline int w1_lock_bus(const struct device *dev)
{
        return w1_change_bus_lock(dev, true);
}

static inline int w1_unlock_bus(const struct device *dev)
{
        return w1_change_bus_lock(dev, false);
}


__syscall int w1_reset_bus(const struct device *dev);
 
static inline int z_impl_w1_reset_bus(const struct device *dev)
{
        return DEVICE_API_GET(w1, dev)->reset_bus(dev);
}

__syscall int w1_read_bit(const struct device *dev);
 
static inline int z_impl_w1_read_bit(const struct device *dev)
{
        return DEVICE_API_GET(w1, dev)->read_bit(dev);
}

__syscall int w1_write_bit(const struct device *dev, const bool bit);
 
static inline int z_impl_w1_write_bit(const struct device *dev, bool bit)
{
        return DEVICE_API_GET(w1, dev)->write_bit(dev, bit);
}

__syscall int w1_read_byte(const struct device *dev);
 
static inline int z_impl_w1_read_byte(const struct device *dev)
{
        return DEVICE_API_GET(w1, dev)->read_byte(dev);
}

__syscall int w1_write_byte(const struct device *dev, uint8_t byte);
 
static inline int z_impl_w1_write_byte(const struct device *dev, uint8_t byte)
{
        return DEVICE_API_GET(w1, dev)->write_byte(dev, byte);
}

__syscall int w1_read_block(const struct device *dev, uint8_t *buffer, size_t len);

__syscall int w1_write_block(const struct device *dev,
                             const uint8_t *buffer, size_t len);

__syscall size_t w1_get_slave_count(const struct device *dev);
 
static inline size_t z_impl_w1_get_slave_count(const struct device *dev)
{
        const struct w1_master_config *ctrl_cfg =
                (const struct w1_master_config *)dev->config;
 
        return ctrl_cfg->slave_count;
}

__syscall int w1_configure(const struct device *dev,
                           enum w1_settings_type type, uint32_t value);
 
static inline int z_impl_w1_configure(const struct device *dev,
                                      enum w1_settings_type type, uint32_t value)
{
        return DEVICE_API_GET(w1, dev)->configure(dev, type, value);
}




#define W1_CMD_SKIP_ROM                 0xCC

#define W1_CMD_MATCH_ROM                0x55

#define W1_CMD_RESUME                   0xA5

#define W1_CMD_READ_ROM                 0x33

#define W1_CMD_SEARCH_ROM               0xF0

#define W1_CMD_SEARCH_ALARM             0xEC

#define W1_CMD_OVERDRIVE_SKIP_ROM       0x3C

#define W1_CMD_OVERDRIVE_MATCH_ROM      0x69



#define W1_CRC8_SEED            0x00
#define W1_CRC8_POLYNOMIAL      0x8C
#define W1_CRC16_SEED           0x0000
#define W1_CRC16_POLYNOMIAL     0xa001


#define W1_SEARCH_ALL_FAMILIES          0x00

#define W1_ROM_INIT_ZERO                                        \
        {                                                       \
                .family = 0, .serial = { 0 }, .crc = 0,         \
        }

struct w1_rom {
        uint8_t family;
        uint8_t serial[6];
        uint8_t crc;
};

struct w1_slave_config {
        struct w1_rom rom;
        uint32_t overdrive : 1;
        uint32_t res : 31;
};

typedef void (*w1_search_callback_t)(struct w1_rom rom, void *user_data);

int w1_read_rom(const struct device *dev, struct w1_rom *rom);

int w1_match_rom(const struct device *dev, const struct w1_slave_config *config);

int w1_resume_command(const struct device *dev);

int w1_skip_rom(const struct device *dev, const struct w1_slave_config *config);

int w1_reset_select(const struct device *dev, const struct w1_slave_config *config);

int w1_write_read(const struct device *dev, const struct w1_slave_config *config,
                  const uint8_t *write_buf, size_t write_len,
                  uint8_t *read_buf, size_t read_len);

__syscall int w1_search_bus(const struct device *dev, uint8_t command,
                            uint8_t family, w1_search_callback_t callback,
                            void *user_data);

static inline int w1_search_rom(const struct device *dev,
                                w1_search_callback_t callback, void *user_data)
{
        return w1_search_bus(dev, W1_CMD_SEARCH_ROM, W1_SEARCH_ALL_FAMILIES,
                             callback, user_data);
}

static inline int w1_search_alarm(const struct device *dev,
                                  w1_search_callback_t callback, void *user_data)
{
        return w1_search_bus(dev, W1_CMD_SEARCH_ALARM, W1_SEARCH_ALL_FAMILIES,
                             callback, user_data);
}

static inline uint64_t w1_rom_to_uint64(const struct w1_rom *rom)
{
        return sys_get_be64((uint8_t *)rom);
}

static inline void w1_uint64_to_rom(const uint64_t rom64, struct w1_rom *rom)
{
        sys_put_be64(rom64, (uint8_t *)rom);
}

static inline uint8_t w1_crc8(const uint8_t *src, size_t len)
{
        return crc8(src, len, W1_CRC8_POLYNOMIAL, W1_CRC8_SEED, true);
}

static inline uint16_t w1_crc16(const uint16_t seed, const uint8_t *src,
                                const size_t len)
{
        return crc16_reflect(W1_CRC16_POLYNOMIAL, seed, src, len);
}

 
#ifdef __cplusplus
}
#endif

#include <zephyr/syscalls/w1.h>
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_W1_H_ */