forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
218 lines
4.2 KiB
218 lines
4.2 KiB
// SPDX-License-Identifier: GPL-2.0-or-later |
|
/* |
|
* w1_ds2405.c |
|
* |
|
* Copyright (c) 2017 Maciej S. Szmigiero <[email protected]> |
|
* Based on w1_therm.c copyright (c) 2004 Evgeniy Polyakov <[email protected]> |
|
*/ |
|
|
|
#include <linux/device.h> |
|
#include <linux/kernel.h> |
|
#include <linux/module.h> |
|
#include <linux/moduleparam.h> |
|
#include <linux/mutex.h> |
|
#include <linux/string.h> |
|
#include <linux/types.h> |
|
|
|
#include <linux/w1.h> |
|
|
|
#define W1_FAMILY_DS2405 0x05 |
|
|
|
MODULE_LICENSE("GPL"); |
|
MODULE_AUTHOR("Maciej S. Szmigiero <[email protected]>"); |
|
MODULE_DESCRIPTION("Driver for 1-wire Dallas DS2405 PIO."); |
|
MODULE_ALIAS("w1-family-" __stringify(W1_FAMILY_DS2405)); |
|
|
|
static int w1_ds2405_select(struct w1_slave *sl, bool only_active) |
|
{ |
|
struct w1_master *dev = sl->master; |
|
|
|
u64 dev_addr = le64_to_cpu(*(u64 *)&sl->reg_num); |
|
unsigned int bit_ctr; |
|
|
|
if (w1_reset_bus(dev) != 0) |
|
return 0; |
|
|
|
/* |
|
* We cannot use a normal Match ROM command |
|
* since doing so would toggle PIO state |
|
*/ |
|
w1_write_8(dev, only_active ? W1_ALARM_SEARCH : W1_SEARCH); |
|
|
|
for (bit_ctr = 0; bit_ctr < 64; bit_ctr++) { |
|
int bit2send = !!(dev_addr & BIT(bit_ctr)); |
|
u8 ret; |
|
|
|
ret = w1_triplet(dev, bit2send); |
|
|
|
if ((ret & (BIT(0) | BIT(1))) == |
|
(BIT(0) | BIT(1))) /* no devices found */ |
|
return 0; |
|
|
|
if (!!(ret & BIT(2)) != bit2send) |
|
/* wrong direction taken - no such device */ |
|
return 0; |
|
} |
|
|
|
return 1; |
|
} |
|
|
|
static int w1_ds2405_read_pio(struct w1_slave *sl) |
|
{ |
|
if (w1_ds2405_select(sl, true)) |
|
return 0; /* "active" means PIO is low */ |
|
|
|
if (w1_ds2405_select(sl, false)) |
|
return 1; |
|
|
|
return -ENODEV; |
|
} |
|
|
|
static ssize_t state_show(struct device *device, |
|
struct device_attribute *attr, char *buf) |
|
{ |
|
struct w1_slave *sl = dev_to_w1_slave(device); |
|
struct w1_master *dev = sl->master; |
|
|
|
int ret; |
|
ssize_t f_retval; |
|
u8 state; |
|
|
|
ret = mutex_lock_interruptible(&dev->bus_mutex); |
|
if (ret) |
|
return ret; |
|
|
|
if (!w1_ds2405_select(sl, false)) { |
|
f_retval = -ENODEV; |
|
goto out_unlock; |
|
} |
|
|
|
state = w1_read_8(dev); |
|
if (state != 0 && |
|
state != 0xff) { |
|
dev_err(device, "non-consistent state %x\n", state); |
|
f_retval = -EIO; |
|
goto out_unlock; |
|
} |
|
|
|
*buf = state ? '1' : '0'; |
|
f_retval = 1; |
|
|
|
out_unlock: |
|
w1_reset_bus(dev); |
|
mutex_unlock(&dev->bus_mutex); |
|
|
|
return f_retval; |
|
} |
|
|
|
static ssize_t output_show(struct device *device, |
|
struct device_attribute *attr, char *buf) |
|
{ |
|
struct w1_slave *sl = dev_to_w1_slave(device); |
|
struct w1_master *dev = sl->master; |
|
|
|
int ret; |
|
ssize_t f_retval; |
|
|
|
ret = mutex_lock_interruptible(&dev->bus_mutex); |
|
if (ret) |
|
return ret; |
|
|
|
ret = w1_ds2405_read_pio(sl); |
|
if (ret < 0) { |
|
f_retval = ret; |
|
goto out_unlock; |
|
} |
|
|
|
*buf = ret ? '1' : '0'; |
|
f_retval = 1; |
|
|
|
out_unlock: |
|
w1_reset_bus(dev); |
|
mutex_unlock(&dev->bus_mutex); |
|
|
|
return f_retval; |
|
} |
|
|
|
static ssize_t output_store(struct device *device, |
|
struct device_attribute *attr, |
|
const char *buf, size_t count) |
|
{ |
|
struct w1_slave *sl = dev_to_w1_slave(device); |
|
struct w1_master *dev = sl->master; |
|
|
|
int ret, current_pio; |
|
unsigned int val; |
|
ssize_t f_retval; |
|
|
|
if (count < 1) |
|
return -EINVAL; |
|
|
|
if (sscanf(buf, " %u%n", &val, &ret) < 1) |
|
return -EINVAL; |
|
|
|
if (val != 0 && val != 1) |
|
return -EINVAL; |
|
|
|
f_retval = ret; |
|
|
|
ret = mutex_lock_interruptible(&dev->bus_mutex); |
|
if (ret) |
|
return ret; |
|
|
|
current_pio = w1_ds2405_read_pio(sl); |
|
if (current_pio < 0) { |
|
f_retval = current_pio; |
|
goto out_unlock; |
|
} |
|
|
|
if (current_pio == val) |
|
goto out_unlock; |
|
|
|
if (w1_reset_bus(dev) != 0) { |
|
f_retval = -ENODEV; |
|
goto out_unlock; |
|
} |
|
|
|
/* |
|
* can't use w1_reset_select_slave() here since it uses Skip ROM if |
|
* there is only one device on bus |
|
*/ |
|
do { |
|
u64 dev_addr = le64_to_cpu(*(u64 *)&sl->reg_num); |
|
u8 cmd[9]; |
|
|
|
cmd[0] = W1_MATCH_ROM; |
|
memcpy(&cmd[1], &dev_addr, sizeof(dev_addr)); |
|
|
|
w1_write_block(dev, cmd, sizeof(cmd)); |
|
} while (0); |
|
|
|
out_unlock: |
|
w1_reset_bus(dev); |
|
mutex_unlock(&dev->bus_mutex); |
|
|
|
return f_retval; |
|
} |
|
|
|
static DEVICE_ATTR_RO(state); |
|
static DEVICE_ATTR_RW(output); |
|
|
|
static struct attribute *w1_ds2405_attrs[] = { |
|
&dev_attr_state.attr, |
|
&dev_attr_output.attr, |
|
NULL |
|
}; |
|
|
|
ATTRIBUTE_GROUPS(w1_ds2405); |
|
|
|
static const struct w1_family_ops w1_ds2405_fops = { |
|
.groups = w1_ds2405_groups |
|
}; |
|
|
|
static struct w1_family w1_family_ds2405 = { |
|
.fid = W1_FAMILY_DS2405, |
|
.fops = &w1_ds2405_fops |
|
}; |
|
|
|
module_w1_family(w1_family_ds2405);
|
|
|