u-boot/drivers/w1-eeprom/ds2502.c
Simon Glass 336d4615f8 dm: core: Create a new header file for 'compat' features
At present dm/device.h includes the linux-compatible features. This
requires including linux/compat.h which in turn includes a lot of headers.
One of these is malloc.h which we thus end up including in every file in
U-Boot. Apart from the inefficiency of this, it is problematic for sandbox
which needs to use the system malloc() in some files.

Move the compatibility features into a separate header file.

Signed-off-by: Simon Glass <sjg@chromium.org>
2020-02-05 19:33:46 -07:00

245 lines
5.4 KiB
C

// SPDX-License-Identifier: GPL-2.0+
/*
* Driver for DS-2502 One wire "Add only Memory".
*
* The chip has 4 pages of 32 bytes.
* In addition it has 8 out of band status bytes that are used, by software,
* as page redirection bytes by an algorithm described in the data sheet.
* This is useful since data cannot be erased once written but it can be
* "patched" up to four times by switching pages.
*
* So, when a read request is entirely in the first page automatically
* apply the page redirection bytes (which allows the device to be seen as
* a 32 byte PROM, writable 4 times).
*
* If the read request is outside of or larger than the first page then read
* the raw data (which allows the device to be seen as a 128 byte PROM,
* writable once).
*
* Copyright (c) 2018 Flowbird
* Martin Fuzzey <martin.fuzzey@flowbird.group>
*/
#include <common.h>
#include <dm.h>
#include <dm/device_compat.h>
#include <linux/err.h>
#include <w1-eeprom.h>
#include <w1.h>
#define DS2502_PAGE_SIZE 32
#define DS2502_PAGE_COUNT 4
#define DS2502_STATUS_SIZE 8
#define DS2502_CMD_READ_STATUS 0xAA
#define DS2502_CMD_READ_GEN_CRC 0xC3
/* u-boot crc8() is CCITT CRC8, we need x^8 + x^5 + x^4 + 1 LSB first */
static unsigned int ds2502_crc8(const u8 *buf, int len)
{
static const u8 poly = 0x8C; /* (1 + x^4 + x^5) + x^8 */
u8 crc = 0;
int i;
for (i = 0; i < len; i++) {
u8 data = buf[i];
int j;
for (j = 0; j < 8; j++) {
u8 mix = (crc ^ data) & 1;
crc >>= 1;
if (mix)
crc ^= poly;
data >>= 1;
}
}
return crc;
}
static int ds2502_read(struct udevice *dev, u8 cmd,
int bytes_in_page, int pos,
u8 *buf, int bytes_for_user)
{
int retry;
int ret = 0;
for (retry = 0; retry < 3; retry++) {
u8 pagebuf[DS2502_PAGE_SIZE + 1]; /* 1 byte for CRC8 */
u8 crc;
int i;
ret = w1_reset_select(dev);
if (ret)
return ret;
/* send read to end of page and generate CRC command */
pagebuf[0] = cmd;
pagebuf[1] = pos & 0xff;
pagebuf[2] = pos >> 8;
crc = ds2502_crc8(pagebuf, 3);
for (i = 0; i < 3; i++)
w1_write_byte(dev, pagebuf[i]);
/* Check command CRC */
ret = w1_read_byte(dev);
if (ret < 0) {
dev_dbg(dev, "Error %d reading command CRC\n", ret);
continue;
}
if (ret != crc) {
dev_dbg(dev,
"bad CRC8 for cmd %02x got=%02X exp=%02X\n",
cmd, ret, crc);
ret = -EIO;
continue;
}
/* read data and check CRC */
ret = w1_read_buf(dev, pagebuf, bytes_in_page + 1);
if (ret < 0) {
dev_dbg(dev, "Error %d reading data\n", ret);
continue;
}
crc = ds2502_crc8(pagebuf, bytes_in_page);
if (crc == pagebuf[bytes_in_page]) {
memcpy(buf, pagebuf, bytes_for_user);
ret = 0;
break;
}
dev_dbg(dev, "Bad CRC8 got=%02X exp=%02X pos=%04X\n",
pagebuf[bytes_in_page], crc, pos);
ret = -EIO;
}
return ret;
}
static inline int ds2502_read_status_bytes(struct udevice *dev, u8 *buf)
{
return ds2502_read(dev, DS2502_CMD_READ_STATUS,
DS2502_STATUS_SIZE, 0,
buf, DS2502_STATUS_SIZE);
}
/*
* Status bytes (from index 1) contain 1's complement page indirection
* So for N writes:
* N=1: ff ff ff ff ff ff ff 00
* N=2: ff fe ff ff ff ff ff 00
* N=3: ff fe fd ff ff ff ff 00
* N=4: ff fe fd fc ff ff ff 00
*/
static int ds2502_indirect_page(struct udevice *dev, u8 *status, int page)
{
int page_seen = 0;
do {
u8 sb = status[page + 1];
if (sb == 0xff)
break;
page = ~sb & 0xff;
if (page >= DS2502_PAGE_COUNT) {
dev_err(dev,
"Illegal page redirection status byte %02x\n",
sb);
return -EINVAL;
}
if (page_seen & (1 << page)) {
dev_err(dev, "Infinite loop in page redirection\n");
return -EINVAL;
}
page_seen |= (1 << page);
} while (1);
return page;
}
static int ds2502_read_buf(struct udevice *dev, unsigned int offset,
u8 *buf, unsigned int count)
{
unsigned int min_page = offset / DS2502_PAGE_SIZE;
unsigned int max_page = (offset + count - 1) / DS2502_PAGE_SIZE;
int xfered = 0;
u8 status_bytes[DS2502_STATUS_SIZE];
int i;
int ret;
if (min_page >= DS2502_PAGE_COUNT || max_page >= DS2502_PAGE_COUNT)
return -EINVAL;
if (min_page == 0 && max_page == 0) {
ret = ds2502_read_status_bytes(dev, status_bytes);
if (ret)
return ret;
} else {
/* Dummy one to one page redirection */
memset(status_bytes, 0xff, sizeof(status_bytes));
}
for (i = min_page; i <= max_page; i++) {
int page;
int pos;
int bytes_in_page;
int bytes_for_user;
page = ds2502_indirect_page(dev, status_bytes, i);
if (page < 0)
return page;
dev_dbg(dev, "page logical %d => physical %d\n", i, page);
pos = page * DS2502_PAGE_SIZE;
if (i == min_page)
pos += offset % DS2502_PAGE_SIZE;
bytes_in_page = DS2502_PAGE_SIZE - (pos % DS2502_PAGE_SIZE);
if (i == max_page)
bytes_for_user = count - xfered;
else
bytes_for_user = bytes_in_page;
ret = ds2502_read(dev, DS2502_CMD_READ_GEN_CRC,
bytes_in_page, pos,
&buf[xfered], bytes_for_user);
if (ret < 0)
return ret;
xfered += bytes_for_user;
}
return 0;
}
static int ds2502_probe(struct udevice *dev)
{
struct w1_device *w1;
w1 = dev_get_parent_platdata(dev);
w1->id = 0;
return 0;
}
static const struct w1_eeprom_ops ds2502_ops = {
.read_buf = ds2502_read_buf,
};
static const struct udevice_id ds2502_id[] = {
{ .compatible = "maxim,ds2502", .data = W1_FAMILY_DS2502 },
{ },
};
U_BOOT_DRIVER(ds2502) = {
.name = "ds2502",
.id = UCLASS_W1_EEPROM,
.of_match = ds2502_id,
.ops = &ds2502_ops,
.probe = ds2502_probe,
};