2017-04-12 17:01:31 +02:00
|
|
|
/*
|
|
|
|
* This file is part of the coreboot project.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2005 Yinghai Lu <yinghailu@gmail.com>
|
|
|
|
* Copyright (C) 2009 coresystems GmbH
|
|
|
|
* Copyright (C) 2013 Vladimir Serbinenko
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; version 2 of the License.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <arch/io.h>
|
2017-08-20 20:36:08 +02:00
|
|
|
#include <console/console.h>
|
2017-04-12 17:01:31 +02:00
|
|
|
#include <device/smbus_def.h>
|
2017-08-04 14:28:50 +02:00
|
|
|
#include <stdlib.h>
|
2017-04-12 17:01:31 +02:00
|
|
|
#include "smbus.h"
|
|
|
|
|
|
|
|
|
2017-08-20 20:36:08 +02:00
|
|
|
#if IS_ENABLED(CONFIG_DEBUG_SMBUS)
|
|
|
|
#define dprintk(args...) printk(BIOS_DEBUG, ##args)
|
|
|
|
#else
|
|
|
|
#define dprintk(args...) do {} while (0)
|
|
|
|
#endif
|
|
|
|
|
2017-04-12 17:01:31 +02:00
|
|
|
/* I801 command constants */
|
|
|
|
#define I801_QUICK (0 << 2)
|
|
|
|
#define I801_BYTE (1 << 2)
|
|
|
|
#define I801_BYTE_DATA (2 << 2)
|
|
|
|
#define I801_WORD_DATA (3 << 2)
|
|
|
|
#define I801_BLOCK_DATA (5 << 2)
|
|
|
|
#define I801_I2C_BLOCK_DATA (6 << 2) /* ICH5 and later */
|
|
|
|
|
|
|
|
/* I801 Host Control register bits */
|
|
|
|
#define SMBHSTCNT_INTREN (1 << 0)
|
|
|
|
#define SMBHSTCNT_KILL (1 << 1)
|
|
|
|
#define SMBHSTCNT_LAST_BYTE (1 << 5)
|
|
|
|
#define SMBHSTCNT_START (1 << 6)
|
|
|
|
#define SMBHSTCNT_PEC_EN (1 << 7) /* ICH3 and later */
|
|
|
|
|
|
|
|
/* I801 Hosts Status register bits */
|
|
|
|
#define SMBHSTSTS_BYTE_DONE (1 << 7)
|
|
|
|
#define SMBHSTSTS_INUSE_STS (1 << 6)
|
|
|
|
#define SMBHSTSTS_SMBALERT_STS (1 << 5)
|
|
|
|
#define SMBHSTSTS_FAILED (1 << 4)
|
|
|
|
#define SMBHSTSTS_BUS_ERR (1 << 3)
|
|
|
|
#define SMBHSTSTS_DEV_ERR (1 << 2)
|
|
|
|
#define SMBHSTSTS_INTR (1 << 1)
|
|
|
|
#define SMBHSTSTS_HOST_BUSY (1 << 0)
|
|
|
|
|
2017-08-20 20:36:11 +02:00
|
|
|
/* For SMBXMITADD register. */
|
|
|
|
#define XMIT_WRITE(dev) (((dev) << 1) | 0)
|
|
|
|
#define XMIT_READ(dev) (((dev) << 1) | 1)
|
|
|
|
|
2017-04-12 17:01:31 +02:00
|
|
|
#define SMBUS_TIMEOUT (10 * 1000 * 100)
|
2018-06-09 11:59:00 +02:00
|
|
|
#define SMBUS_BLOCK_MAXLEN 32
|
2017-04-12 17:01:31 +02:00
|
|
|
|
|
|
|
static void smbus_delay(void)
|
|
|
|
{
|
|
|
|
inb(0x80);
|
|
|
|
}
|
|
|
|
|
2017-08-20 20:36:18 +02:00
|
|
|
static int host_completed(u8 status)
|
|
|
|
{
|
|
|
|
if (status & SMBHSTSTS_HOST_BUSY)
|
|
|
|
return 0;
|
|
|
|
status &= ~(SMBHSTSTS_SMBALERT_STS | SMBHSTSTS_INUSE_STS);
|
|
|
|
return status != 0;
|
|
|
|
}
|
|
|
|
|
2017-08-20 20:36:11 +02:00
|
|
|
static int recover_master(int smbus_base, int ret)
|
2017-04-12 17:01:31 +02:00
|
|
|
{
|
2017-08-20 20:36:11 +02:00
|
|
|
/* TODO: Depending of the failure, drive KILL transaction
|
|
|
|
* or force soft reset on SMBus master controller.
|
|
|
|
*/
|
|
|
|
printk(BIOS_ERR, "SMBus: Fatal master timeout (%d)\n", ret);
|
|
|
|
return ret;
|
2017-04-12 17:01:31 +02:00
|
|
|
}
|
|
|
|
|
2017-08-20 20:36:18 +02:00
|
|
|
static int cb_err_from_stat(u8 status)
|
|
|
|
{
|
|
|
|
/* Ignore the "In Use" status... */
|
|
|
|
status &= ~(SMBHSTSTS_SMBALERT_STS | SMBHSTSTS_INUSE_STS);
|
|
|
|
|
|
|
|
if (status == SMBHSTSTS_INTR)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return SMBUS_ERROR;
|
|
|
|
}
|
|
|
|
|
2017-08-20 20:36:11 +02:00
|
|
|
static int setup_command(unsigned int smbus_base, u8 ctrl, u8 xmitadd)
|
2017-04-12 17:01:31 +02:00
|
|
|
{
|
|
|
|
unsigned int loops = SMBUS_TIMEOUT;
|
2017-08-20 20:36:11 +02:00
|
|
|
u8 host_busy;
|
|
|
|
|
2017-04-12 17:01:31 +02:00
|
|
|
do {
|
|
|
|
smbus_delay();
|
2017-08-20 20:36:11 +02:00
|
|
|
host_busy = inb(smbus_base + SMBHSTSTAT) & SMBHSTSTS_HOST_BUSY;
|
|
|
|
} while (--loops && host_busy);
|
|
|
|
|
|
|
|
if (loops == 0)
|
|
|
|
return recover_master(smbus_base,
|
|
|
|
SMBUS_WAIT_UNTIL_READY_TIMEOUT);
|
|
|
|
|
|
|
|
/* Clear any lingering errors, so the transaction will run. */
|
|
|
|
outb(inb(smbus_base + SMBHSTSTAT), smbus_base + SMBHSTSTAT);
|
|
|
|
|
|
|
|
/* Set up transaction */
|
|
|
|
/* Disable interrupts */
|
|
|
|
outb(ctrl, (smbus_base + SMBHSTCTL));
|
|
|
|
|
|
|
|
/* Set the device I'm talking to. */
|
|
|
|
outb(xmitadd, smbus_base + SMBXMITADD);
|
|
|
|
|
|
|
|
return 0;
|
2017-04-12 17:01:31 +02:00
|
|
|
}
|
|
|
|
|
2017-08-20 20:36:15 +02:00
|
|
|
static int execute_command(unsigned int smbus_base)
|
2017-04-12 17:01:31 +02:00
|
|
|
{
|
2017-08-20 20:36:15 +02:00
|
|
|
unsigned int loops = SMBUS_TIMEOUT;
|
|
|
|
u8 status;
|
|
|
|
|
|
|
|
/* Start the command. */
|
|
|
|
outb((inb(smbus_base + SMBHSTCTL) | SMBHSTCNT_START),
|
|
|
|
smbus_base + SMBHSTCTL);
|
|
|
|
|
|
|
|
/* Poll for it to start. */
|
2017-04-12 17:01:31 +02:00
|
|
|
do {
|
|
|
|
smbus_delay();
|
2017-08-20 20:36:15 +02:00
|
|
|
|
|
|
|
/* If we poll too slow, we could miss HOST_BUSY flag
|
|
|
|
* set and detect INTR or x_ERR flags instead here.
|
|
|
|
*/
|
|
|
|
status = inb(smbus_base + SMBHSTSTAT);
|
|
|
|
status &= ~(SMBHSTSTS_SMBALERT_STS | SMBHSTSTS_INUSE_STS);
|
|
|
|
} while (--loops && status == 0);
|
|
|
|
|
|
|
|
if (loops == 0)
|
|
|
|
return recover_master(smbus_base,
|
|
|
|
SMBUS_WAIT_UNTIL_ACTIVE_TIMEOUT);
|
|
|
|
|
|
|
|
return 0;
|
2017-04-12 17:01:31 +02:00
|
|
|
}
|
|
|
|
|
2017-08-20 20:36:18 +02:00
|
|
|
static int complete_command(unsigned int smbus_base)
|
2017-08-20 20:36:11 +02:00
|
|
|
{
|
|
|
|
unsigned int loops = SMBUS_TIMEOUT;
|
2017-08-20 20:36:18 +02:00
|
|
|
u8 status;
|
|
|
|
|
2017-08-20 20:36:11 +02:00
|
|
|
do {
|
|
|
|
smbus_delay();
|
2017-08-20 20:36:18 +02:00
|
|
|
status = inb(smbus_base + SMBHSTSTAT);
|
|
|
|
} while (--loops && !host_completed(status));
|
|
|
|
|
|
|
|
if (loops == 0)
|
|
|
|
return recover_master(smbus_base,
|
|
|
|
SMBUS_WAIT_UNTIL_DONE_TIMEOUT);
|
|
|
|
|
|
|
|
return cb_err_from_stat(status);
|
2017-08-20 20:36:11 +02:00
|
|
|
}
|
|
|
|
|
2017-04-12 17:01:31 +02:00
|
|
|
int do_smbus_read_byte(unsigned int smbus_base, u8 device,
|
|
|
|
unsigned int address)
|
|
|
|
{
|
2017-08-20 20:36:11 +02:00
|
|
|
int ret;
|
2017-08-20 20:36:18 +02:00
|
|
|
u8 byte;
|
2017-04-12 17:01:31 +02:00
|
|
|
|
2017-08-20 20:36:11 +02:00
|
|
|
/* Set up for a byte data read. */
|
|
|
|
ret = setup_command(smbus_base, I801_BYTE_DATA, XMIT_READ(device));
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2017-04-12 17:01:31 +02:00
|
|
|
/* Set the command/address... */
|
2017-08-20 20:36:11 +02:00
|
|
|
outb(address, smbus_base + SMBHSTCMD);
|
2017-04-12 17:01:31 +02:00
|
|
|
|
|
|
|
/* Clear the data byte... */
|
|
|
|
outb(0, smbus_base + SMBHSTDAT0);
|
|
|
|
|
|
|
|
/* Start the command */
|
2017-08-20 20:36:15 +02:00
|
|
|
ret = execute_command(smbus_base);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2017-04-12 17:01:31 +02:00
|
|
|
|
|
|
|
/* Poll for transaction completion */
|
2017-08-20 20:36:18 +02:00
|
|
|
ret = complete_command(smbus_base);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2017-04-12 17:01:31 +02:00
|
|
|
|
|
|
|
/* Read results of transaction */
|
|
|
|
byte = inb(smbus_base + SMBHSTDAT0);
|
|
|
|
return byte;
|
|
|
|
}
|
|
|
|
|
|
|
|
int do_smbus_write_byte(unsigned int smbus_base, u8 device,
|
|
|
|
unsigned int address, unsigned int data)
|
|
|
|
{
|
2017-08-20 20:36:11 +02:00
|
|
|
int ret;
|
2017-04-12 17:01:31 +02:00
|
|
|
|
2017-08-20 20:36:11 +02:00
|
|
|
/* Set up for a byte data write. */
|
|
|
|
ret = setup_command(smbus_base, I801_BYTE_DATA, XMIT_WRITE(device));
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2017-04-12 17:01:31 +02:00
|
|
|
|
|
|
|
/* Set the command/address... */
|
2017-08-20 20:36:11 +02:00
|
|
|
outb(address, smbus_base + SMBHSTCMD);
|
2017-04-12 17:01:31 +02:00
|
|
|
|
2017-08-20 20:36:11 +02:00
|
|
|
/* Set the data byte... */
|
2017-04-12 17:01:31 +02:00
|
|
|
outb(data, smbus_base + SMBHSTDAT0);
|
|
|
|
|
|
|
|
/* Start the command */
|
2017-08-20 20:36:15 +02:00
|
|
|
ret = execute_command(smbus_base);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2017-04-12 17:01:31 +02:00
|
|
|
|
|
|
|
/* Poll for transaction completion */
|
2017-08-20 20:36:18 +02:00
|
|
|
return complete_command(smbus_base);
|
2017-04-12 17:01:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int do_smbus_block_read(unsigned int smbus_base, u8 device, u8 cmd,
|
2017-08-04 14:28:50 +02:00
|
|
|
unsigned int max_bytes, u8 *buf)
|
2017-04-12 17:01:31 +02:00
|
|
|
{
|
|
|
|
u8 status;
|
2017-08-20 20:36:11 +02:00
|
|
|
int ret, slave_bytes;
|
2017-04-12 17:01:31 +02:00
|
|
|
int bytes_read = 0;
|
|
|
|
unsigned int loops = SMBUS_TIMEOUT;
|
|
|
|
|
2017-08-20 22:48:23 +02:00
|
|
|
max_bytes = MIN(SMBUS_BLOCK_MAXLEN, max_bytes);
|
2017-08-04 14:28:50 +02:00
|
|
|
|
2017-08-20 20:36:11 +02:00
|
|
|
/* Set up for a block data read. */
|
|
|
|
ret = setup_command(smbus_base, I801_BLOCK_DATA, XMIT_READ(device));
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2017-04-12 17:01:31 +02:00
|
|
|
/* Set the command/address... */
|
2017-08-20 20:36:11 +02:00
|
|
|
outb(cmd, smbus_base + SMBHSTCMD);
|
2017-04-12 17:01:31 +02:00
|
|
|
|
2017-08-04 14:28:50 +02:00
|
|
|
/* Reset number of bytes to transfer so we notice later it
|
|
|
|
* was really updated with the transaction. */
|
|
|
|
outb(0, smbus_base + SMBHSTDAT0);
|
|
|
|
|
2017-04-12 17:01:31 +02:00
|
|
|
/* Start the command */
|
2017-08-20 20:36:15 +02:00
|
|
|
ret = execute_command(smbus_base);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2017-04-12 17:01:31 +02:00
|
|
|
|
|
|
|
/* Poll for transaction completion */
|
|
|
|
do {
|
|
|
|
status = inb(smbus_base + SMBHSTSTAT);
|
|
|
|
|
|
|
|
if (status & SMBHSTSTS_BYTE_DONE) { /* Byte done */
|
2017-08-04 14:28:50 +02:00
|
|
|
|
|
|
|
if (bytes_read < max_bytes) {
|
2017-08-20 22:48:23 +02:00
|
|
|
*buf++ = inb(smbus_base + SMBBLKDAT);
|
2017-08-04 14:28:50 +02:00
|
|
|
bytes_read++;
|
2017-04-12 17:01:31 +02:00
|
|
|
}
|
2017-08-04 14:28:50 +02:00
|
|
|
|
|
|
|
/* Engine internally completes the transaction
|
|
|
|
* and clears HOST_BUSY flag once the byte count
|
|
|
|
* from slave is reached.
|
|
|
|
*/
|
2017-08-20 20:36:18 +02:00
|
|
|
outb(SMBHSTSTS_BYTE_DONE, smbus_base + SMBHSTSTAT);
|
2017-04-12 17:01:31 +02:00
|
|
|
}
|
2017-08-20 20:36:18 +02:00
|
|
|
} while (--loops && !host_completed(status));
|
2017-04-12 17:01:31 +02:00
|
|
|
|
2017-09-09 19:45:47 +02:00
|
|
|
/* Post-check we received complete message. */
|
|
|
|
slave_bytes = inb(smbus_base + SMBHSTDAT0);
|
|
|
|
|
2017-08-20 20:36:08 +02:00
|
|
|
dprintk("%s: status = %02x, len = %d / %d, loops = %d\n",
|
|
|
|
__func__, status, bytes_read, slave_bytes, loops);
|
|
|
|
|
2017-08-20 20:36:18 +02:00
|
|
|
if (loops == 0)
|
|
|
|
return recover_master(smbus_base,
|
|
|
|
SMBUS_WAIT_UNTIL_DONE_TIMEOUT);
|
|
|
|
|
|
|
|
ret = cb_err_from_stat(status);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2017-08-04 14:28:50 +02:00
|
|
|
if (bytes_read < slave_bytes)
|
|
|
|
return SMBUS_ERROR;
|
|
|
|
|
2017-04-12 17:01:31 +02:00
|
|
|
return bytes_read;
|
|
|
|
}
|
|
|
|
|
|
|
|
int do_smbus_block_write(unsigned int smbus_base, u8 device, u8 cmd,
|
2017-08-04 14:28:50 +02:00
|
|
|
const unsigned int bytes, const u8 *buf)
|
2017-04-12 17:01:31 +02:00
|
|
|
{
|
|
|
|
u8 status;
|
2017-08-20 20:36:11 +02:00
|
|
|
int ret, bytes_sent = 0;
|
2017-04-12 17:01:31 +02:00
|
|
|
unsigned int loops = SMBUS_TIMEOUT;
|
|
|
|
|
2017-08-20 22:48:23 +02:00
|
|
|
if (bytes > SMBUS_BLOCK_MAXLEN)
|
2017-08-04 14:28:50 +02:00
|
|
|
return SMBUS_ERROR;
|
|
|
|
|
2017-08-20 20:36:11 +02:00
|
|
|
/* Set up for a block data write. */
|
|
|
|
ret = setup_command(smbus_base, I801_BLOCK_DATA, XMIT_WRITE(device));
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2017-04-12 17:01:31 +02:00
|
|
|
|
|
|
|
/* Set the command/address... */
|
2017-08-20 20:36:11 +02:00
|
|
|
outb(cmd, smbus_base + SMBHSTCMD);
|
2017-04-12 17:01:31 +02:00
|
|
|
|
2017-08-20 20:36:11 +02:00
|
|
|
/* Set number of bytes to transfer. */
|
2017-04-12 17:01:31 +02:00
|
|
|
outb(bytes, smbus_base + SMBHSTDAT0);
|
|
|
|
|
2017-08-04 14:28:50 +02:00
|
|
|
/* Send first byte from buffer, bytes_sent increments after
|
|
|
|
* hardware acknowledges it.
|
|
|
|
*/
|
2017-04-12 17:01:31 +02:00
|
|
|
outb(*buf++, smbus_base + SMBBLKDAT);
|
|
|
|
|
|
|
|
/* Start the command */
|
2017-08-20 20:36:15 +02:00
|
|
|
ret = execute_command(smbus_base);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2017-04-12 17:01:31 +02:00
|
|
|
|
|
|
|
/* Poll for transaction completion */
|
|
|
|
do {
|
|
|
|
status = inb(smbus_base + SMBHSTSTAT);
|
|
|
|
|
|
|
|
if (status & SMBHSTSTS_BYTE_DONE) {
|
2017-08-04 14:28:50 +02:00
|
|
|
bytes_sent++;
|
|
|
|
if (bytes_sent < bytes)
|
|
|
|
outb(*buf++, smbus_base + SMBBLKDAT);
|
|
|
|
|
|
|
|
/* Engine internally completes the transaction
|
|
|
|
* and clears HOST_BUSY flag once the byte count
|
|
|
|
* has been reached.
|
|
|
|
*/
|
2017-08-20 20:36:18 +02:00
|
|
|
outb(SMBHSTSTS_BYTE_DONE, smbus_base + SMBHSTSTAT);
|
2017-04-12 17:01:31 +02:00
|
|
|
}
|
2017-08-20 20:36:18 +02:00
|
|
|
} while (--loops && !host_completed(status));
|
2017-04-12 17:01:31 +02:00
|
|
|
|
2017-08-20 20:36:08 +02:00
|
|
|
dprintk("%s: status = %02x, len = %d / %d, loops = %d\n",
|
|
|
|
__func__, status, bytes_sent, bytes, loops);
|
|
|
|
|
2017-08-20 20:36:18 +02:00
|
|
|
if (loops == 0)
|
|
|
|
return recover_master(smbus_base,
|
|
|
|
SMBUS_WAIT_UNTIL_DONE_TIMEOUT);
|
|
|
|
|
|
|
|
ret = cb_err_from_stat(status);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2017-08-20 22:48:23 +02:00
|
|
|
if (bytes_sent < bytes)
|
|
|
|
return SMBUS_ERROR;
|
|
|
|
|
2017-08-04 14:28:50 +02:00
|
|
|
return bytes_sent;
|
2017-04-12 17:01:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Only since ICH5 */
|
|
|
|
int do_i2c_block_read(unsigned int smbus_base, u8 device,
|
2017-08-20 20:36:03 +02:00
|
|
|
unsigned int offset, const unsigned int bytes, u8 *buf)
|
2017-04-12 17:01:31 +02:00
|
|
|
{
|
|
|
|
u8 status;
|
2017-08-20 20:36:11 +02:00
|
|
|
int ret, bytes_read = 0;
|
2017-04-12 17:01:31 +02:00
|
|
|
unsigned int loops = SMBUS_TIMEOUT;
|
|
|
|
|
2017-08-20 20:36:11 +02:00
|
|
|
/* Set up for a i2c block data read.
|
|
|
|
*
|
|
|
|
* FIXME: Address parameter changes to XMIT_READ(device) with
|
|
|
|
* some revision of PCH. Presumably hardware revisions that
|
|
|
|
* do not have i2c block write support internally set LSB.
|
|
|
|
*/
|
|
|
|
ret = setup_command(smbus_base, I801_I2C_BLOCK_DATA,
|
|
|
|
XMIT_WRITE(device));
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2017-04-12 17:01:31 +02:00
|
|
|
|
|
|
|
/* device offset */
|
|
|
|
outb(offset, smbus_base + SMBHSTDAT1);
|
|
|
|
|
|
|
|
/* Start the command */
|
2017-08-20 20:36:15 +02:00
|
|
|
ret = execute_command(smbus_base);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2017-04-12 17:01:31 +02:00
|
|
|
|
|
|
|
/* Poll for transaction completion */
|
|
|
|
do {
|
|
|
|
status = inb(smbus_base + SMBHSTSTAT);
|
|
|
|
|
|
|
|
if (status & SMBHSTSTS_BYTE_DONE) {
|
2017-08-20 20:36:03 +02:00
|
|
|
|
|
|
|
if (bytes_read < bytes) {
|
|
|
|
*buf++ = inb(smbus_base + SMBBLKDAT);
|
|
|
|
bytes_read++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bytes_read + 1 >= bytes) {
|
2017-04-12 17:01:31 +02:00
|
|
|
/* indicate that next byte is the last one */
|
|
|
|
outb(inb(smbus_base + SMBHSTCTL)
|
|
|
|
| SMBHSTCNT_LAST_BYTE,
|
|
|
|
smbus_base + SMBHSTCTL);
|
|
|
|
}
|
2017-08-20 20:36:03 +02:00
|
|
|
|
2017-08-20 20:36:18 +02:00
|
|
|
outb(SMBHSTSTS_BYTE_DONE, smbus_base + SMBHSTSTAT);
|
2017-04-12 17:01:31 +02:00
|
|
|
}
|
2017-08-20 20:36:18 +02:00
|
|
|
} while (--loops && !host_completed(status));
|
2017-04-12 17:01:31 +02:00
|
|
|
|
2017-08-20 20:36:08 +02:00
|
|
|
dprintk("%s: status = %02x, len = %d / %d, loops = %d\n",
|
|
|
|
__func__, status, bytes_read, bytes, loops);
|
|
|
|
|
2017-08-20 20:36:18 +02:00
|
|
|
if (loops == 0)
|
|
|
|
return recover_master(smbus_base,
|
|
|
|
SMBUS_WAIT_UNTIL_DONE_TIMEOUT);
|
|
|
|
|
|
|
|
ret = cb_err_from_stat(status);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2017-08-20 20:36:03 +02:00
|
|
|
if (bytes_read < bytes)
|
|
|
|
return SMBUS_ERROR;
|
|
|
|
|
2017-04-12 17:01:31 +02:00
|
|
|
return bytes_read;
|
|
|
|
}
|