Djam/u-boot
1
0
Fork 0
mirror of https://github.com/u-boot/u-boot.git synced 2025-04-19 11:24:42 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
u-boot/drivers/misc/atsha204a-i2c.c
Michał Barnaś 2a31d71d83 misc: atsha204a: fix wakeup function 
The ATSHA204A chip requires SDA line to go low for at least 60us to
wake up the chip. Previous implementation did not meet this requirement
due to the NAK received on bus and not sending the zeroes.
The function to ignore the NAK and send bytes regardless is not
supported in the u-boot making it impossible to wake up the chip
this way.
Instead, the bus speed, if needed, is set to lowest value and the
message is sent to the address 0x0. This way, the address of zero
makes the SDA line go low for about 80us, meeting the required time
to wake up the chip. The zero length packet is not sent by the i2c,
so the one byte is sent to the transfer function, but only the address
is sent anyway.
After sending the zero address, the bus speed is restored to the
previous value if it was slowed down to wake up the chip.

Signed-off-by: Michał Barnaś <barnas@google.com>
2024-03-05 08:08:26 -05:00

331 lines
7 KiB
C
Raw Blame History

/*
* I2C Driver for Atmel ATSHA204 over I2C
*
* Copyright (C) 2014 Josh Datko, Cryptotronix, jbd@cryptotronix.com
* 2016 Tomas Hlavacek, CZ.NIC, tmshlvck@gmail.com
* 2017 Marek Behún, CZ.NIC, kabel@kernel.org
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*/
#include <common.h>
#include <dm.h>
#include <i2c.h>
#include <errno.h>
#include <atsha204a-i2c.h>
#include <log.h>
#include <asm/global_data.h>
#include <linux/delay.h>
#include <linux/bitrev.h>
#include <u-boot/crc.h>
#define ATSHA204A_TWHI_US 2500
#define ATSHA204A_TRANSACTION_TIMEOUT 100000
#define ATSHA204A_TRANSACTION_RETRY 5
#define ATSHA204A_EXECTIME 5000
DECLARE_GLOBAL_DATA_PTR;
static inline u16 atsha204a_crc16(const u8 *buffer, size_t len)
{
return bitrev16(crc16(0, buffer, len));
}
static int atsha204a_ping_bus(struct udevice *dev)
{
struct udevice *bus = dev_get_parent(dev);
struct i2c_msg msg;
int speed;
int res;
u8 val = 0;
speed = dm_i2c_get_bus_speed(bus);
if (speed != I2C_SPEED_STANDARD_RATE) {
int rv;
rv = dm_i2c_set_bus_speed(bus, I2C_SPEED_STANDARD_RATE);
if (rv)
debug("Couldn't change the I2C bus speed\n");
}
/*
* The I2C drivers don't support sending messages when NAK is received.
* This chip requires wake up low signal on SDA for >= 60us.
* To achieve this, we slow the bus to 100kHz and send an empty
* message to address 0. This will hold the SDA line low for the
* required time to wake up the chip.
*/
msg.addr = 0;
msg.flags = I2C_M_STOP;
msg.len = sizeof(val);
msg.buf = &val;
res = dm_i2c_xfer(dev, &msg, 1);
if (speed != I2C_SPEED_STANDARD_RATE) {
int rv;
rv = dm_i2c_set_bus_speed(bus, speed);
if (rv)
debug("Couldn't restore the I2C bus speed\n");
}
return res;
}
static int atsha204a_send(struct udevice *dev, const u8 *buf, u8 len)
{
fdt_addr_t *priv = dev_get_priv(dev);
struct i2c_msg msg;
msg.addr = *priv;
msg.flags = I2C_M_STOP;
msg.len = len;
msg.buf = (u8 *) buf;
return dm_i2c_xfer(dev, &msg, 1);
}
static int atsha204a_recv(struct udevice *dev, u8 *buf, u8 len)
{
fdt_addr_t *priv = dev_get_priv(dev);
struct i2c_msg msg;
msg.addr = *priv;
msg.flags = I2C_M_RD | I2C_M_STOP;
msg.len = len;
msg.buf = (u8 *) buf;
return dm_i2c_xfer(dev, &msg, 1);
}
static int atsha204a_recv_resp(struct udevice *dev,
struct atsha204a_resp *resp)
{
int res;
u16 resp_crc, computed_crc;
u8 *p = (u8 *) resp;
res = atsha204a_recv(dev, p, 4);
if (res)
return res;
if (resp->length > 4) {
if (resp->length > sizeof(*resp))
return -EMSGSIZE;
res = atsha204a_recv(dev, p + 4, resp->length - 4);
if (res)
return res;
}
resp_crc = (u16) p[resp->length - 2]
| (((u16) p[resp->length - 1]) << 8);
computed_crc = atsha204a_crc16(p, resp->length - 2);
if (resp_crc != computed_crc) {
debug("Invalid checksum in ATSHA204A response\n");
return -EBADMSG;
}
return 0;
}
int atsha204a_wakeup(struct udevice *dev)
{
struct atsha204a_resp resp;
int res;
debug("Waking up ATSHA204A\n");
/*
* The device ignores any levels or transitions on the SCL pin
* when the device is idle, asleep or during waking up.
* Don't check for error when waking up the device.
*/
atsha204a_ping_bus(dev);
udelay(ATSHA204A_TWHI_US);
res = atsha204a_recv_resp(dev, &resp);
if (res) {
debug("failed on receiving response, ending\n");
return res;
}
if (resp.code != ATSHA204A_STATUS_AFTER_WAKE) {
debug("failed (response code = %02x), ending\n", resp.code);
return -EBADMSG;
}
debug("success\n");
return 0;
}
int atsha204a_idle(struct udevice *dev)
{
int res;
u8 req = ATSHA204A_FUNC_IDLE;
res = atsha204a_send(dev, &req, 1);
if (res)
debug("Failed putting ATSHA204A idle\n");
return res;
}
int atsha204a_sleep(struct udevice *dev)
{
int res;
u8 req = ATSHA204A_FUNC_SLEEP;
res = atsha204a_send(dev, &req, 1);
if (res)
debug("Failed putting ATSHA204A to sleep\n");
return res;
}
static int atsha204a_transaction(struct udevice *dev, struct atsha204a_req *req,
struct atsha204a_resp *resp)
{
int res, timeout = ATSHA204A_TRANSACTION_TIMEOUT;
res = atsha204a_send(dev, (u8 *) req, req->length + 1);
if (res) {
debug("ATSHA204A transaction send failed\n");
return -EBUSY;
}
do {
udelay(ATSHA204A_EXECTIME);
res = atsha204a_recv_resp(dev, resp);
if (!res || res == -EMSGSIZE || res == -EBADMSG)
break;
debug("ATSHA204A transaction polling for response "
"(timeout = %d)\n", timeout);
timeout -= ATSHA204A_EXECTIME;
} while (timeout > 0);
if (timeout <= 0) {
debug("ATSHA204A transaction timed out\n");
return -ETIMEDOUT;
}
return res;
}
static void atsha204a_req_crc32(struct atsha204a_req *req)
{
u8 *p = (u8 *) req;
u16 computed_crc;
u16 *crc_ptr = (u16 *) &p[req->length - 1];
/* The buffer to crc16 starts at byte 1, not 0 */
computed_crc = atsha204a_crc16(p + 1, req->length - 2);
*crc_ptr = cpu_to_le16(computed_crc);
}
int atsha204a_read(struct udevice *dev, enum atsha204a_zone zone, bool read32,
u16 addr, u8 *buffer)
{
int res, retry = ATSHA204A_TRANSACTION_RETRY;
struct atsha204a_req req;
struct atsha204a_resp resp;
req.function = ATSHA204A_FUNC_COMMAND;
req.length = 7;
req.command = ATSHA204A_CMD_READ;
req.param1 = (u8) zone;
if (read32)
req.param1 |= 0x80;
req.param2 = cpu_to_le16(addr);
atsha204a_req_crc32(&req);
do {
res = atsha204a_transaction(dev, &req, &resp);
if (!res)
break;
debug("ATSHA204A read retry (%d)\n", retry);
retry--;
atsha204a_wakeup(dev);
} while (retry >= 0);
if (res) {
debug("ATSHA204A read failed\n");
return res;
}
if (resp.length != (read32 ? 32 : 4) + 3) {
debug("ATSHA204A read bad response length (%d)\n",
resp.length);
return -EBADMSG;
}
memcpy(buffer, ((u8 *) &resp) + 1, read32 ? 32 : 4);
return 0;
}
int atsha204a_get_random(struct udevice *dev, u8 *buffer, size_t max)
{
int res;
struct atsha204a_req req;
struct atsha204a_resp resp;
req.function = ATSHA204A_FUNC_COMMAND;
req.length = 7;
req.command = ATSHA204A_CMD_RANDOM;
req.param1 = 1;
req.param2 = 0;
/* We do not have to compute the checksum dynamically */
req.data[0] = 0x27;
req.data[1] = 0x47;
res = atsha204a_transaction(dev, &req, &resp);
if (res) {
debug("ATSHA204A random transaction failed\n");
return res;
}
memcpy(buffer, ((u8 *) &resp) + 1, max >= 32 ? 32 : max);
return 0;
}
static int atsha204a_of_to_plat(struct udevice *dev)
{
fdt_addr_t *priv = dev_get_priv(dev);
fdt_addr_t addr;
addr = dev_read_addr(dev);
if (addr == FDT_ADDR_T_NONE) {
debug("Can't get ATSHA204A I2C base address\n");
return -ENXIO;
}
*priv = addr;
return 0;
}
static const struct udevice_id atsha204a_ids[] = {
{ .compatible = "atmel,atsha204" },
{ .compatible = "atmel,atsha204a" },
{ }
};
U_BOOT_DRIVER(atsha204) = {
.name = "atsha204",
.id = UCLASS_MISC,
.of_match = atsha204a_ids,
.of_to_plat = atsha204a_of_to_plat,
.priv_auto = sizeof(fdt_addr_t),
};
Reference in a new issue View git blame Copy permalink