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 int w1_bq2022_add_slave(struct w1_slave *sl)
{
char cmd[4];
int retries = 5;
bq2022_battery_info battery_info;
if (!sl) {
pr_err("%s: No w1 device\n", __func__);
return -1;
}
retry:
/* Initialization, master's mutex should be hold */
if (!(retries--)) {
pr_err("%s: fatal error\n", __func__);
return -1;
}
if (w1_reset_bus(sl->master)) {
pr_warn("%s: reset bus failed, just retry!\n", __func__);
goto retry;
}
/* rom comm byte + read comm byte + addr 2 bytes */
cmd[0] = BQ2022_COMMAND_SKIP_SERIALIZATION_ROM;
cmd[1] = BQ2022_COMMAND_READ_MEMORY_FIELD_CRC;
cmd[2] = 0x0;
cmd[3] = 0x0;
/* send command */
w1_write_block(sl->master, cmd, 4);
/* crc verified for read comm byte and addr 2 bytes*/
if (w1_read_8(sl->master) != w1_calc_crc8(&cmd[1], 3)) {
pr_err("%s: com crc err\n", __func__);
goto retry;
}
/* read the whole memory, 1024-bit */
w1_read_block(sl->master, (char*) &battery_info, sizeof(battery_info));
/* crc verified for data */
if (w1_read_8(sl->master) != w1_calc_crc8((char*) &battery_info, sizeof(battery_info))) {
pr_err("%s: w1_bq2022 data crc err\n", __func__);
goto retry;
}
if (battery_info.magic != BQ2022_BATTERY_INFO_MAGIC) {
pr_err("%s: invalid battery info magic\n", __func__);
return -1;
}
pr_hexdump(&battery_info, sizeof(battery_info));
w1_bq2022_battery_info_id = battery_info.data1 | battery_info.data2 << 8;
w1_bq2022_print_battery();
return 0;
}
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 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;
}
/**
* Resets the bus and then selects the slave by sending either a skip rom
* or a rom match.
* The w1 master lock must be held.
*
* @param sl the slave to select
* @return 0=success, anything else=error
*/
int w1_reset_overdrive_select_slave(struct w1_slave *sl)
{
if (w1_reset_bus(sl->master))
return -1;
w1_write_8(sl->master, W1_OVSKIP_ROM);
return 0;
}
/*
* Writes to the scratchpad and reads it back for verification.
* Then copies the scratchpad to EEPROM.
* The data must be aligned at W1_F2D_SCRATCH_SIZE bytes and
* must be W1_F2D_SCRATCH_SIZE bytes long.
* The master must be locked.
*
* @param sl The slave structure
* @param addr Address for the write
* @param len length must be <= (W1_F2D_PAGE_SIZE - (addr & W1_F2D_PAGE_MASK))
* @param data The data to write
* @return 0=Success -1=failure
*/
static int ds2431_write(struct w1_device *dev, int addr, int len, const u8 *data)
{
struct w1_bus *bus = dev->bus;
int tries = W1_F2D_READ_RETRIES;
u8 wrbuf[4];
u8 rdbuf[W1_F2D_SCRATCH_SIZE + 3];
u8 es = (addr + len - 1) % W1_F2D_SCRATCH_SIZE;
retry:
/* Write the data to the scratchpad */
if (w1_reset_select_slave(dev))
return -1;
wrbuf[0] = W1_F2D_WRITE_SCRATCH;
wrbuf[1] = addr & 0xff;
wrbuf[2] = addr >> 8;
w1_write_block(bus, wrbuf, 3);
w1_write_block(bus, data, len);
/* Read the scratchpad and verify */
if (w1_reset_select_slave(dev))
return -1;
w1_write_8(bus, W1_F2D_READ_SCRATCH);
w1_read_block(bus, rdbuf, len + 3);
/* Compare what was read against the data written */
if ((rdbuf[0] != wrbuf[1]) || (rdbuf[1] != wrbuf[2]) ||
(rdbuf[2] != es) || (memcmp(data, &rdbuf[3], len) != 0)) {
if (--tries)
goto retry;
dev_err(&dev->dev,
"could not write to eeprom, scratchpad compare failed %d times\n",
W1_F2D_READ_RETRIES);
return -1;
}
/* Copy the scratchpad to EEPROM */
if (w1_reset_select_slave(dev))
return -1;
wrbuf[0] = W1_F2D_COPY_SCRATCH;
wrbuf[3] = es;
w1_write_block(bus, wrbuf, 4);
/* Sleep for tprog ms to wait for the write to complete */
mdelay(W1_F2D_TPROG_MS);
/* Reset the bus to wake up the EEPROM */
w1_reset_bus(bus);
return 0;
}
/**
* w1_reset_resume_command() - resume instead of another match ROM
* @dev: the master device
*
* When the workflow with a slave amongst many requires several
* successive commands a reset between each, this function is similar
* to doing a reset then a match ROM for the last matched ROM. The
* advantage being that the matched ROM step is skipped in favor of the
* resume command. The slave must support the command of course.
*
* If the bus has only one slave, traditionnaly the match ROM is skipped
* and a "SKIP ROM" is done for efficiency. On multi-slave busses, this
* doesn't work of course, but the resume command is the next best thing.
*
* The w1 master lock must be held.
*/
int w1_reset_resume_command(struct w1_master *dev)
{
if (w1_reset_bus(dev))
return -1;
/* This will make only the last matched slave perform a skip ROM. */
w1_write_8(dev, W1_RESUME_CMD);
return 0;
}
int w1_reset_resume_command(struct w1_master *dev)
{
if (w1_reset_bus(dev))
return -1;
/* */
w1_write_8(dev, W1_RESUME_CMD);
return 0;
}
static int w1_bq2022_read(void)
{
struct w1_slave *sl = bq2022_slave;
char cmd[4];
u8 crc, calc_crc;
int retries = 5;
if (!sl) {
pr_err("No w1 device\n");
return -1;
}
retry:
/* Initialization, master's mutex should be hold */
if (!(retries--)) {
pr_err("w1_bq2022_read fatal error\n");
return -1;
}
if (w1_reset_bus(sl->master)) {
pr_warn("reset bus failed, just retry!\n");
goto retry;
}
/* rom comm byte + read comm byte + addr 2 bytes */
cmd[0] = HDQ_CMD_SKIP_ROM;
cmd[1] = HDQ_CMD_READ_FIELD;
cmd[2] = 0x0;
cmd[3] = 0x0;
/* send command */
w1_write_block(sl->master, cmd, 4);
/* crc verified for read comm byte and addr 2 bytes*/
crc = w1_read_8(sl->master);
calc_crc = w1_calc_crc8(&cmd[1], 3);
if (calc_crc != crc) {
pr_err("com crc err\n");
goto retry;
}
/* read the whole memory, 1024-bit */
w1_read_block(sl->master, batt_crypt_info, 128);
/* crc verified for data */
crc = w1_read_8(sl->master);
calc_crc = w1_calc_crc8(batt_crypt_info, 128);
if (calc_crc != crc) {
pr_err("w1_bq2022 data crc err\n");
goto retry;
}
return 0;
}
/*
* This is a special sequence we must do to ensure the P0 output is not stuck
* in test mode. This is described in rev 2 of the ds2408's datasheet
* (http://datasheets.maximintegrated.com/en/ds/DS2408.pdf) under
* "APPLICATION INFORMATION/Power-up timing".
*/
static int w1_f29_disable_test_mode(struct w1_slave *sl)
{
int res;
u8 magic[10] = {0x96, };
u64 rn = le64_to_cpu(*((u64*)&sl->reg_num));
memcpy(&magic[1], &rn, 8);
magic[9] = 0x3C;
mutex_lock(&sl->master->bus_mutex);
res = w1_reset_bus(sl->master);
if (res)
goto out;
w1_write_block(sl->master, magic, ARRAY_SIZE(magic));
res = w1_reset_bus(sl->master);
out:
mutex_unlock(&sl->master->bus_mutex);
return res;
}
static enum w1_ds2502_state w1_ds2502_detect(struct w1_slave *sl)
{
enum w1_ds2502_state next_state = STATE_DETECT;
CDBG("%s: Enter\n", __func__);
if (w1_reset_bus(sl->master) == 0)
next_state = STATE_IDENTIFY;
else
pr_err("%s: w1_reset_bus failed", __func__);
return next_state;
}
/**
* Resets the bus and then selects the slave by sending either a skip rom
* or a rom match.
* The w1 master lock must be held.
*
* @param sl the slave to select
* @return 0=success, anything else=error
*/
int w1_reset_select_slave(struct w1_slave *sl)
{
if (w1_reset_bus(sl->master))
return -1;
if (sl->master->slave_count == 1)
w1_write_8(sl->master, W1_SKIP_ROM);
else {
u8 match[9] = {W1_MATCH_ROM, };
memcpy(&match[1], (u8 *)&sl->reg_num, 8);
w1_write_block(sl->master, match, 9);
}
return 0;
}
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;
}