mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-22 01:48:52 +09:00
![Simon Glass](/assets/img/avatar_default.png)
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>
246 lines
5.4 KiB
C
246 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,
|
|
};
|