asgardius/android_kernel_samsung_heroqlte
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
android_kernel_samsung_hero.../drivers/bif/bif-core.c
HackerOO7 2bd1731e0a init: OSRC G9300ZCU2APF7
2016-08-17 16:41:52 +08:00

3841 lines
100 KiB
C
Raw Blame History

/* Copyright (c) 2013, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* 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.
*/
#define pr_fmt(fmt) "%s: " fmt, __func__
#include <linux/bitrev.h>
#include <linux/crc-ccitt.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/of.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/workqueue.h>
#include <linux/bif/consumer.h>
#include <linux/bif/driver.h>
/**
* struct bif_ctrl_dev - holds controller device specific information
* @list: Doubly-linked list parameter linking to other
* BIF controllers registered in the system
* @desc: Description structure for this BIF controller
* @mutex: Mutex lock that is used to ensure mutual
* exclusion between transactions performed on the
* BIF bus for this controller
* @ctrl_dev: Device pointer to the BIF controller device
* @driver_data: Private data used by the BIF controller
* @selected_sdev: Slave device that is currently selected on
* the BIF bus of this controller
* @bus_change_notifier: Head of a notifier list containing notifier
* blocks that are notified when the battery
* presence changes
* @enter_irq_mode_work: Work task that is scheduled after a transaction
* completes when there are consumers that are
* actively monitoring BIF slave interrupts
* @irq_count: This is a count of the total number of BIF slave
* interrupts that are currently being monitored
* for the BIF slaves connected to this BIF
* controller
* @irq_mode_delay_jiffies: Number of jiffies to wait before scheduling the
* enter IRQ mode task. Using a larger value
* helps to improve the performance of BIF
* consumers that perform many BIF transactions.
* Using a smaller value reduces the latency of
* BIF slave interrupts.
* @battery_present: Cached value of the battery presence. This is
* used to filter out spurious presence update
* calls when the battery presence state has not
* changed.
*/
struct bif_ctrl_dev {
struct list_head list;
struct bif_ctrl_desc *desc;
struct mutex mutex;
struct device *ctrl_dev;
void *driver_data;
struct bif_slave_dev *selected_sdev;
struct blocking_notifier_head bus_change_notifier;
struct delayed_work enter_irq_mode_work;
int irq_count;
int irq_mode_delay_jiffies;
bool battery_present;
};
/**
* struct bif_ctrl - handle used by BIF consumers for bus oriented BIF
* operations
* @bdev: Pointer to BIF controller device
* @exclusive_lock: Flag which indicates that the BIF consumer responsible
* for this handle has locked the BIF bus of this
* controller. BIF transactions from other consumers are
* blocked until the bus is unlocked.
*/
struct bif_ctrl {
struct bif_ctrl_dev *bdev;
bool exclusive_lock;
};
/**
* struct bif_slave_dev - holds BIF slave device information
* @list: Doubly-linked list parameter linking to other
* BIF slaves that have been enumerated
* @bdev: Pointer to the BIF controller device that this
* slave is physically connected to
* @slave_addr: 8-bit BIF DEV_ADR assigned to this slave
* @unique_id: 80-bit BIF unique ID of the slave
* @unique_id_bits_known: Number of bits of the UID that are currently
* known. This number starts is incremented during
* a UID search and must end at 80 if the slave
* responds to the search properly.
* @present: Boolean value showing if this slave is
* physically present in the system at a given
* point in time. The value is set to false if the
* battery pack containing the slave is
* disconnected.
* @l1_data: BIF DDB L1 data of the slave as read from the
* slave's memory
* @function_directory: Pointer to the BIF DDB L2 function directory
* list as read from the slave's memory
* @protocol_function: Pointer to constant protocol function data as
* well as software state information if the slave
* has a protocol function
* @slave_ctrl_function: Pointer to constant slave control function data
* as well as software state information if the
* slave has a slave control function
* @nvm_function: Pointer to constant non-volatile memory function
* data as well as software state information if
* the slave has a non-volatile memory function
*
* bif_slave_dev objects are stored indefinitely after enumeration in order to
* speed up battery reinsertion. Only a UID check is needed after inserting a
* battery assuming it has been enumerated before.
*
* unique_id bytes are stored such that unique_id[0] = MSB and
* unique_id[BIF_UNIQUE_ID_BYTE_LENGTH - 1] = LSB
*/
struct bif_slave_dev {
struct list_head list;
struct bif_ctrl_dev *bdev;
u8 slave_addr;
u8 unique_id[BIF_UNIQUE_ID_BYTE_LENGTH];
int unique_id_bits_known;
bool present;
struct bif_ddb_l1_data l1_data;
struct bif_ddb_l2_data *function_directory;
struct bif_protocol_function *protocol_function;
struct bif_slave_control_function *slave_ctrl_function;
struct bif_nvm_function *nvm_function;
};
/**
* struct bif_slave - handle used by BIF consumers for slave oriented BIF
* operations
* @ctrl: Consumer BIF controller handle data
* @sdev: Pointer to BIF slave device
*/
struct bif_slave {
struct bif_ctrl ctrl;
struct bif_slave_dev *sdev;
};
/* Number of times to retry a full BIF transaction before returning an error. */
#define BIF_TRANSACTION_RETRY_COUNT 5
static DEFINE_MUTEX(bif_ctrl_list_mutex);
static LIST_HEAD(bif_ctrl_list);
static DEFINE_MUTEX(bif_sdev_list_mutex);
static LIST_HEAD(bif_sdev_list);
static u8 next_dev_addr = 0x02;
#define DEBUG_PRINT_BUFFER_SIZE 256
static void fill_string(char *str, size_t str_len, u8 *buf, int buf_len)
{
int pos = 0;
int i;
for (i = 0; i < buf_len; i++) {
pos += scnprintf(str + pos, str_len - pos, "0x%02X", buf[i]);
if (i < buf_len - 1)
pos += scnprintf(str + pos, str_len - pos, ", ");
}
}
static void bif_print_slave_data(struct bif_slave_dev *sdev)
{
char str[DEBUG_PRINT_BUFFER_SIZE];
u8 *uid;
int i, j;
struct bif_object *object;
if (sdev->unique_id_bits_known != BIF_UNIQUE_ID_BIT_LENGTH)
return;
uid = sdev->unique_id;
pr_debug("BIF slave: 0x%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X\n",
uid[0], uid[1], uid[2], uid[3], uid[4], uid[5], uid[6],
uid[7], uid[8], uid[9]);
pr_debug(" present=%d, dev_adr=0x%02X\n", sdev->present,
sdev->slave_addr);
pr_debug(" revision=0x%02X, level=0x%02X, device class=0x%04X\n",
sdev->l1_data.revision, sdev->l1_data.level,
sdev->l1_data.device_class);
pr_debug(" manufacturer ID=0x%04X, product ID=0x%04X\n",
sdev->l1_data.manufacturer_id, sdev->l1_data.product_id);
pr_debug(" function directory length=%d\n", sdev->l1_data.length);
for (i = 0; i < sdev->l1_data.length / 4; i++) {
pr_debug(" Function %d: type=0x%02X, version=0x%02X, pointer=0x%04X\n",
i, sdev->function_directory[i].function_type,
sdev->function_directory[i].function_version,
sdev->function_directory[i].function_pointer);
}
if (sdev->nvm_function) {
pr_debug(" NVM function: pointer=0x%04X, task=%d, wr_buf_size=%d, nvm_base=0x%04X, nvm_size=%d, nvm_lock_offset=%d\n",
sdev->nvm_function->nvm_pointer,
sdev->nvm_function->slave_control_channel,
(sdev->nvm_function->write_buffer_size
? sdev->nvm_function->write_buffer_size : 0),
sdev->nvm_function->nvm_base_address,
sdev->nvm_function->nvm_size,
sdev->nvm_function->nvm_lock_offset);
if (sdev->nvm_function->object_count)
pr_debug(" NVM objects:\n");
i = 0;
list_for_each_entry(object, &sdev->nvm_function->object_list,
list) {
pr_debug(" Object %d - addr=0x%04X, data len=%d, type=0x%02X, version=0x%02X, manufacturer ID=0x%04X, crc=0x%04X\n",
i, object->addr, object->length - 8,
object->type, object->version,
object->manufacturer_id, object->crc);
for (j = 0; j < DIV_ROUND_UP(object->length - 8, 16);
j++) {
fill_string(str, DEBUG_PRINT_BUFFER_SIZE,
object->data + j * 16,
min(16, object->length - 8 - (j * 16)));
pr_debug(" data(0x%04X): %s\n", j * 16,
str);
}
i++;
}
}
}
static void bif_print_slaves(void)
{
struct bif_slave_dev *sdev;
mutex_lock(&bif_sdev_list_mutex);
list_for_each_entry(sdev, &bif_sdev_list, list) {
/* Skip slaves without fully known UIDs. */
if (sdev->unique_id_bits_known != BIF_UNIQUE_ID_BIT_LENGTH)
continue;
bif_print_slave_data(sdev);
}
mutex_unlock(&bif_sdev_list_mutex);
}
static struct bif_slave_dev *bif_add_slave(struct bif_ctrl_dev *bdev)
{
struct bif_slave_dev *sdev;
sdev = kzalloc(sizeof(struct bif_slave_dev), GFP_KERNEL);
if (sdev == NULL) {
pr_err("Memory allocation failed for bif_slave_dev\n");
return ERR_PTR(-ENOMEM);
}
sdev->bdev = bdev;
INIT_LIST_HEAD(&sdev->list);
list_add_tail(&sdev->list, &bif_sdev_list);
return sdev;
}
static void bif_remove_slave(struct bif_slave_dev *sdev)
{
list_del(&sdev->list);
if (sdev->bdev->selected_sdev == sdev)
sdev->bdev->selected_sdev = NULL;
if (sdev->slave_ctrl_function)
kfree(sdev->slave_ctrl_function->irq_notifier_list);
kfree(sdev->slave_ctrl_function);
kfree(sdev->protocol_function);
kfree(sdev->function_directory);
kfree(sdev);
}
/* This function assumes that the uid array is all 0 to start with. */
static void set_uid_bit(u8 uid[BIF_UNIQUE_ID_BYTE_LENGTH], unsigned int bit,
unsigned int value)
{
u8 mask;
if (bit >= BIF_UNIQUE_ID_BIT_LENGTH)
return;
mask = 1 << (7 - (bit % 8));
uid[bit / 8] &= ~mask;
uid[bit / 8] |= value << (7 - (bit % 8));
}
static unsigned int get_uid_bit(u8 uid[BIF_UNIQUE_ID_BYTE_LENGTH],
unsigned int bit)
{
if (bit >= BIF_UNIQUE_ID_BIT_LENGTH)
return 0;
return (uid[bit / 8] & (1 << (7 - (bit % 8)))) ? 1 : 0;
}
static void bif_enter_irq_mode_work(struct work_struct *work)
{
struct delayed_work *dwork = to_delayed_work(work);
struct bif_ctrl_dev *bdev
= container_of(dwork, struct bif_ctrl_dev, enter_irq_mode_work);
int rc, i;
mutex_lock(&bdev->mutex);
for (i = 0; i < BIF_TRANSACTION_RETRY_COUNT; i++) {
rc = bdev->desc->ops->set_bus_state(bdev,
BIF_BUS_STATE_INTERRUPT);
if (rc == 0)
break;
}
mutex_unlock(&bdev->mutex);
/* Reschedule the task if the transaction failed. */
if (rc) {
pr_err("Could not set BIF bus to interrupt mode, rc=%d\n", rc);
schedule_delayed_work(&bdev->enter_irq_mode_work,
bdev->irq_mode_delay_jiffies);
}
}
static void bif_cancel_irq_mode_work(struct bif_ctrl_dev *bdev)
{
cancel_delayed_work(&bdev->enter_irq_mode_work);
}
static void bif_schedule_irq_mode_work(struct bif_ctrl_dev *bdev)
{
if (bdev->irq_count > 0 &&
bdev->desc->ops->get_bus_state(bdev) != BIF_BUS_STATE_INTERRUPT)
schedule_delayed_work(&bdev->enter_irq_mode_work,
bdev->irq_mode_delay_jiffies);
}
static int _bif_select_slave_no_retry(struct bif_slave_dev *sdev)
{
struct bif_ctrl_dev *bdev = sdev->bdev;
int rc = 0;
int i;
/* Check if the slave is already selected. */
if (sdev->bdev->selected_sdev == sdev)
return 0;
if (sdev->slave_addr) {
/* Select using DEV_ADR. */
rc = bdev->desc->ops->bus_transaction(bdev, BIF_TRANS_SDA,
sdev->slave_addr);
if (!rc)
sdev->bdev->selected_sdev = sdev;
} else if (sdev->unique_id_bits_known == BIF_UNIQUE_ID_BIT_LENGTH) {
/* Select using full UID. */
for (i = 0; i < BIF_UNIQUE_ID_BYTE_LENGTH - 1; i++) {
rc = bdev->desc->ops->bus_transaction(bdev,
BIF_TRANS_EDA, sdev->unique_id[i]);
if (rc)
goto out;
}
rc = bdev->desc->ops->bus_transaction(bdev, BIF_TRANS_SDA,
sdev->unique_id[BIF_UNIQUE_ID_BYTE_LENGTH - 1]);
if (rc)
goto out;
} else {
pr_err("Cannot select slave because it has neither UID nor DEV_ADR.\n");
return -EINVAL;
}
sdev->bdev->selected_sdev = sdev;
return 0;
out:
pr_err("bus_transaction failed, rc=%d\n", rc);
return rc;
}
static int bif_select_slave(struct bif_slave_dev *sdev)
{
int rc = -EPERM;
int i;
for (i = 0; i < BIF_TRANSACTION_RETRY_COUNT; i++) {
rc = _bif_select_slave_no_retry(sdev);
if (rc == 0)
break;
/* Force slave reselection. */
sdev->bdev->selected_sdev = NULL;
}
return rc;
}
/*
* Returns 1 if slave is selected, 0 if slave is not selected, or errno if
* error.
*/
static int bif_is_slave_selected(struct bif_ctrl_dev *bdev)
{
int rc = -EPERM;
int tack, i;
for (i = 0; i < BIF_TRANSACTION_RETRY_COUNT; i++) {
/* Attempt a transaction query. */
rc = bdev->desc->ops->bus_transaction_read(bdev, BIF_TRANS_BC,
BIF_CMD_TQ, &tack);
if (rc == 0 || rc == -ETIMEDOUT)
break;
}
if (rc == 0)
rc = 1;
else if (rc == -ETIMEDOUT)
rc = 0;
else
pr_err("BIF bus_transaction_read failed, rc=%d\n", rc);
return rc;
}
/* Read from a specified number of consecutive registers. */
static int _bif_slave_read_no_retry(struct bif_slave_dev *sdev, u16 addr,
u8 *buf, int len)
{
struct bif_ctrl_dev *bdev = sdev->bdev;
int rc = 0;
int i, response;
rc = bif_select_slave(sdev);
if (rc)
return rc;
if (bdev->desc->ops->read_slave_registers) {
/*
* Use low level slave register read implementation in order to
* receive the benefits of BIF burst reads.
*/
rc = bdev->desc->ops->read_slave_registers(bdev, addr, buf,
len);
if (rc)
pr_debug("read_slave_registers failed, rc=%d\n", rc);
else
return rc;
/*
* Fall back on individual transactions if high level register
* read failed.
*/
}
for (i = 0; i < len; i++) {
rc = bdev->desc->ops->bus_transaction(bdev, BIF_TRANS_ERA,
addr >> 8);
if (rc) {
pr_err("bus_transaction failed, rc=%d\n", rc);
return rc;
}
rc = bdev->desc->ops->bus_transaction_read(bdev, BIF_TRANS_RRA,
addr & 0xFF, &response);
if (rc) {
pr_err("bus_transaction_read failed, rc=%d\n", rc);
return rc;
}
if (!(response & BIF_SLAVE_RD_ACK)) {
pr_err("BIF register read error=0x%02X\n",
response & BIF_SLAVE_RD_ERR);
return -EIO;
}
buf[i] = response & BIF_SLAVE_RD_DATA;
addr++;
}
return rc;
}
/*
* Read from a specified number of consecutive registers. Retry the transaction
* several times in case of communcation failures.
*/
static int _bif_slave_read(struct bif_slave_dev *sdev, u16 addr, u8 *buf,
int len)
{
int rc = -EPERM;
int i;
for (i = 0; i < BIF_TRANSACTION_RETRY_COUNT; i++) {
rc = _bif_slave_read_no_retry(sdev, addr, buf, len);
if (rc == 0)
break;
/* Force slave reselection. */
sdev->bdev->selected_sdev = NULL;
}
return rc;
}
/* Write to a specified number of consecutive registers. */
static int _bif_slave_write_no_retry(struct bif_slave_dev *sdev, u16 addr,
u8 *buf, int len)
{
struct bif_ctrl_dev *bdev = sdev->bdev;
int rc = 0;
int i;
rc = bif_select_slave(sdev);
if (rc)
return rc;
if (bdev->desc->ops->write_slave_registers) {
/*
* Use low level slave register write implementation in order to
* receive the benefits of BIF burst writes.
*/
rc = bdev->desc->ops->write_slave_registers(bdev, addr, buf,
len);
if (rc)
pr_debug("write_slave_registers failed, rc=%d\n", rc);
else
return rc;
/*
* Fall back on individual transactions if high level register
* write failed.
*/
}
rc = bdev->desc->ops->bus_transaction(bdev, BIF_TRANS_ERA, addr >> 8);
if (rc)
goto out;
rc = bdev->desc->ops->bus_transaction(bdev, BIF_TRANS_WRA, addr & 0xFF);
if (rc)
goto out;
for (i = 0; i < len; i++) {
rc = bdev->desc->ops->bus_transaction(bdev, BIF_TRANS_WD,
buf[i]);
if (rc)
goto out;
}
return 0;
out:
pr_err("bus_transaction failed, rc=%d\n", rc);
return rc;
}
/*
* Write to a specified number of consecutive registers. Retry the transaction
* several times in case of communcation failures.
*/
static int _bif_slave_write(struct bif_slave_dev *sdev, u16 addr, u8 *buf,
int len)
{
int rc = -EPERM;
int i;
for (i = 0; i < BIF_TRANSACTION_RETRY_COUNT; i++) {
rc = _bif_slave_write_no_retry(sdev, addr, buf, len);
if (rc == 0)
break;
/* Force slave reselection. */
sdev->bdev->selected_sdev = NULL;
}
return rc;
}
/* Perform a read-modify-write sequence on a single BIF slave register. */
static int _bif_slave_masked_write(struct bif_slave_dev *sdev, u16 addr, u8 val,
u8 mask)
{
int rc;
u8 reg;
rc = _bif_slave_read(sdev, addr, &reg, 1);
if (rc)
return rc;
reg = (reg & ~mask) | (val & mask);
return _bif_slave_write(sdev, addr, &reg, 1);
}
static int _bif_check_task(struct bif_slave_dev *sdev, unsigned int task)
{
if (IS_ERR_OR_NULL(sdev)) {
pr_err("Invalid slave device handle=%ld\n", PTR_ERR(sdev));
return -EINVAL;
} else if (!sdev->bdev) {
pr_err("BIF controller has been removed\n");
return -ENXIO;
} else if (!sdev->slave_ctrl_function
|| sdev->slave_ctrl_function->task_count == 0) {
pr_err("BIF slave does not support slave control\n");
return -ENODEV;
} else if (task >= sdev->slave_ctrl_function->task_count) {
pr_err("Requested task: %u greater than max: %u for this slave\n",
task, sdev->slave_ctrl_function->task_count);
return -EINVAL;
}
return 0;
}
static int _bif_task_is_busy(struct bif_slave_dev *sdev, unsigned int task)
{
int rc;
u16 addr;
u8 reg = 0;
rc = _bif_check_task(sdev, task);
if (rc) {
pr_err("Invalid slave device or task, rc=%d\n", rc);
return rc;
}
/* Check the task busy state. */
addr = SLAVE_CTRL_FUNC_TASK_BUSY_ADDR(
sdev->slave_ctrl_function->slave_ctrl_pointer, task);
rc = _bif_slave_read(sdev, addr, &reg, 1);
if (rc) {
pr_err("BIF slave register read failed, rc=%d\n", rc);
return rc;
}
return (reg & BIT(task % SLAVE_CTRL_TASKS_PER_SET)) ? 1 : 0;
}
static int _bif_enable_auto_task(struct bif_slave_dev *sdev, unsigned int task)
{
int rc;
u16 addr;
u8 mask;
rc = _bif_check_task(sdev, task);
if (rc) {
pr_err("Invalid slave device or task, rc=%d\n", rc);
return rc;
}
/* Enable the auto task within the slave */
mask = BIT(task % SLAVE_CTRL_TASKS_PER_SET);
addr = SLAVE_CTRL_FUNC_TASK_AUTO_TRIGGER_ADDR(
sdev->slave_ctrl_function->slave_ctrl_pointer, task);
if (task / SLAVE_CTRL_TASKS_PER_SET == 0) {
/* Set global auto task enable. */
mask |= BIT(0);
}
rc = _bif_slave_masked_write(sdev, addr, 0xFF, mask);
if (rc) {
pr_err("BIF slave register masked write failed, rc=%d\n", rc);
return rc;
}
/* Set global auto task enable if task not in set 0. */
if (task / SLAVE_CTRL_TASKS_PER_SET != 0) {
addr = SLAVE_CTRL_FUNC_TASK_AUTO_TRIGGER_ADDR(
sdev->slave_ctrl_function->slave_ctrl_pointer, 0);
rc = _bif_slave_masked_write(sdev, addr, 0xFF, BIT(0));
if (rc) {
pr_err("BIF slave register masked write failed, rc=%d\n",
rc);
return rc;
}
}
return rc;
}
static int _bif_disable_auto_task(struct bif_slave_dev *sdev, unsigned int task)
{
int rc;
u16 addr;
u8 mask;
rc = _bif_check_task(sdev, task);
if (rc) {
pr_err("Invalid slave or task, rc=%d\n", rc);
return rc;
}
/* Disable the auto task within the slave */
mask = BIT(task % SLAVE_CTRL_TASKS_PER_SET);
addr = SLAVE_CTRL_FUNC_TASK_AUTO_TRIGGER_ADDR(
sdev->slave_ctrl_function->slave_ctrl_pointer, task);
rc = _bif_slave_masked_write(sdev, addr, 0x00, mask);
if (rc) {
pr_err("BIF slave register masked write failed, rc=%d\n", rc);
return rc;
}
return rc;
}
/*
* The MIPI-BIF spec does not define a maximum time in which an NVM write must
* complete. The following delay and recheck count therefore represent
* arbitrary but reasonable values.
*/
#define NVM_WRITE_POLL_DELAY_MS 20
#define NVM_WRITE_MAX_POLL_COUNT 50
static int _bif_slave_nvm_raw_write(struct bif_slave_dev *sdev, u16 offset,
u8 *buf, int len)
{
int rc = 0;
int write_len, poll_count, rc2;
u8 write_buf[3];
if (!sdev->nvm_function) {
pr_err("BIF slave has no NVM function\n");
return -ENODEV;
} else if (offset + len > sdev->nvm_function->nvm_size) {
pr_err("write offset + len = %d > NVM size = %d\n",
offset + len, sdev->nvm_function->nvm_size);
return -EINVAL;
} else if (offset < sdev->nvm_function->nvm_lock_offset) {
pr_err("write offset = %d < first writable offset = %d\n",
offset, sdev->nvm_function->nvm_lock_offset);
return -EINVAL;
}
rc = _bif_enable_auto_task(sdev,
sdev->nvm_function->slave_control_channel);
if (rc) {
pr_err("Failed to enable NVM auto task, rc=%d\n", rc);
return rc;
}
while (len > 0) {
write_len = sdev->nvm_function->write_buffer_size;
if (write_len == 0)
write_len = 256;
write_len = min(write_len, len);
write_buf[0] = offset >> 8;
write_buf[1] = offset;
write_buf[2] = (write_len == 256) ? 0 : write_len;
/* Write offset and size registers. */
rc = _bif_slave_write(sdev, sdev->nvm_function->nvm_pointer + 6,
write_buf, 3);
if (rc) {
pr_err("BIF slave write failed, rc=%d\n", rc);
goto done;
}
/* Write to NVM write buffer registers. */
rc = _bif_slave_write(sdev, sdev->nvm_function->nvm_pointer + 9,
buf, write_len);
if (rc) {
pr_err("BIF slave write failed, rc=%d\n", rc);
goto done;
}
/*
* Wait for completion of the NVM write which was auto-triggered
* by the register write of the last byte in the NVM write
* buffer.
*/
poll_count = NVM_WRITE_MAX_POLL_COUNT;
do {
msleep(NVM_WRITE_POLL_DELAY_MS);
rc = _bif_task_is_busy(sdev,
sdev->nvm_function->slave_control_channel);
poll_count--;
} while (rc > 0 && poll_count > 0);
if (rc < 0) {
pr_err("Failed to check task state, rc=%d", rc);
goto done;
} else if (rc > 0) {
pr_err("BIF slave NVM write not completed after %d ms\n",
NVM_WRITE_POLL_DELAY_MS * NVM_WRITE_MAX_POLL_COUNT);
rc = -ETIMEDOUT;
goto done;
}
len -= write_len;
offset += write_len;
buf += write_len;
}
done:
rc2 = _bif_disable_auto_task(sdev,
sdev->nvm_function->slave_control_channel);
if (rc2) {
pr_err("Failed to disable NVM auto task, rc=%d\n", rc2);
return rc2;
}
return rc;
}
/* Takes a mutex if this consumer is not an exclusive bus user. */
static void bif_ctrl_lock(struct bif_ctrl *ctrl)
{
if (!ctrl->exclusive_lock) {
mutex_lock(&ctrl->bdev->mutex);
bif_cancel_irq_mode_work(ctrl->bdev);
}
}
/* Releases a mutex if this consumer is not an exclusive bus user. */
static void bif_ctrl_unlock(struct bif_ctrl *ctrl)
{
if (!ctrl->exclusive_lock) {
bif_schedule_irq_mode_work(ctrl->bdev);
mutex_unlock(&ctrl->bdev->mutex);
}
}
static void bif_slave_ctrl_lock(struct bif_slave *slave)
{
bif_ctrl_lock(&slave->ctrl);
}
static void bif_slave_ctrl_unlock(struct bif_slave *slave)
{
bif_ctrl_unlock(&slave->ctrl);
}
/**
* bif_crc_ccitt() - calculate the CRC-CCITT CRC value of the data specified
* @buffer: Data to calculate the CRC of
* @len: Length of the data buffer in bytes
*
* MIPI-BIF specifies the usage of CRC-CCITT for BIF data objects. This
* function performs the CRC calculation while taking into account the bit
* ordering used by BIF.
*/
u16 bif_crc_ccitt(const u8 *buffer, unsigned int len)
{
u16 crc = 0xFFFF;
while (len--) {
crc = crc_ccitt_byte(crc, bitrev8(*buffer));
buffer++;
}
return bitrev16(crc);
}
EXPORT_SYMBOL(bif_crc_ccitt);
static u16 bif_object_crc_ccitt(const struct bif_object *object)
{
u16 crc = 0xFFFF;
int i;
crc = crc_ccitt_byte(crc, bitrev8(object->type));
crc = crc_ccitt_byte(crc, bitrev8(object->version));
crc = crc_ccitt_byte(crc, bitrev8(object->manufacturer_id >> 8));
crc = crc_ccitt_byte(crc, bitrev8(object->manufacturer_id));
crc = crc_ccitt_byte(crc, bitrev8(object->length >> 8));
crc = crc_ccitt_byte(crc, bitrev8(object->length));
for (i = 0; i < object->length - 8; i++)
crc = crc_ccitt_byte(crc, bitrev8(object->data[i]));
return bitrev16(crc);
}
static int bif_check_task(struct bif_slave *slave, unsigned int task)
{
if (IS_ERR_OR_NULL(slave)) {
pr_err("Invalid slave pointer=%ld\n", PTR_ERR(slave));
return -EINVAL;
}
return _bif_check_task(slave->sdev, task);
}
/**
* bif_request_irq() - request a BIF slave IRQ by slave task number
* @slave: BIF slave handle
* @task: BIF task number of the IRQ inside of the slave. This
* corresponds to the slave control channel specified for a given
* BIF function inside of the slave.
* @nb: Notifier block to call when the IRQ fires
*
* This function registers a notifier block to call when the BIF slave interrupt
* is triggered and also enables the interrupt. The interrupt is enabled inside
* of the BIF slave's slave control function and also the BIF bus is put into
* interrupt mode.
*
* Returns 0 for success or errno if an error occurred.
*/
int bif_request_irq(struct bif_slave *slave, unsigned int task,
struct notifier_block *nb)
{
int rc;
u16 addr;
u8 reg, mask;
rc = bif_check_task(slave, task);
if (rc) {
pr_err("Invalid slave or task, rc=%d\n", rc);
return rc;
}
bif_slave_ctrl_lock(slave);
rc = blocking_notifier_chain_register(
&slave->sdev->slave_ctrl_function->irq_notifier_list[task], nb);
if (rc) {
pr_err("Notifier registration failed, rc=%d\n", rc);
goto done;
}
/* Enable the interrupt within the slave */
mask = BIT(task % SLAVE_CTRL_TASKS_PER_SET);
addr = SLAVE_CTRL_FUNC_IRQ_EN_ADDR(
slave->sdev->slave_ctrl_function->slave_ctrl_pointer, task);
if (task / SLAVE_CTRL_TASKS_PER_SET == 0) {
/* Set global interrupt enable. */
mask |= BIT(0);
}
rc = _bif_slave_read(slave->sdev, addr, &reg, 1);
if (rc) {
pr_err("BIF slave register read failed, rc=%d\n", rc);
goto notifier_unregister;
}
reg |= mask;
rc = _bif_slave_write(slave->sdev, addr, &reg, 1);
if (rc) {
pr_err("BIF slave register write failed, rc=%d\n", rc);
goto notifier_unregister;
}
/* Set global interrupt enable if task not in set 0. */
if (task / SLAVE_CTRL_TASKS_PER_SET != 0) {
mask = BIT(0);
addr = SLAVE_CTRL_FUNC_IRQ_EN_ADDR(
slave->sdev->slave_ctrl_function->slave_ctrl_pointer, 0);
rc = _bif_slave_read(slave->sdev, addr, &reg, 1);
if (rc) {
pr_err("BIF slave register read failed, rc=%d\n", rc);
goto notifier_unregister;
}
reg |= mask;
rc = _bif_slave_write(slave->sdev, addr, &reg, 1);
if (rc) {
pr_err("BIF slave register write failed, rc=%d\n", rc);
goto notifier_unregister;
}
}
rc = slave->sdev->bdev->desc->ops->set_bus_state(slave->sdev->bdev,
BIF_BUS_STATE_INTERRUPT);
if (rc) {
pr_err("Could not set BIF bus to interrupt mode, rc=%d\n", rc);
goto notifier_unregister;
}
slave->sdev->bdev->irq_count++;
done:
bif_slave_ctrl_unlock(slave);
return rc;
notifier_unregister:
blocking_notifier_chain_unregister(
&slave->sdev->slave_ctrl_function->irq_notifier_list[task],
nb);
bif_slave_ctrl_unlock(slave);
return rc;
}
EXPORT_SYMBOL(bif_request_irq);
/**
* bif_free_irq() - free a BIF slave IRQ by slave task number
* @slave: BIF slave handle
* @task: BIF task number of the IRQ inside of the slave. This
* corresponds to the slave control channel specified for a given
* BIF function inside of the slave.
* @nb: Notifier block previously registered with this interrupt
*
* This function unregisters a notifier block that was previously registered
* with bif_request_irq().
*
* Returns 0 for success or errno if an error occurred.
*/
int bif_free_irq(struct bif_slave *slave, unsigned int task,
struct notifier_block *nb)
{
int rc;
u16 addr;
u8 reg;
rc = bif_check_task(slave, task);
if (rc) {
pr_err("Invalid slave or task, rc=%d\n", rc);
return rc;
}
bif_slave_ctrl_lock(slave);
/* Disable the interrupt within the slave */
reg = BIT(task % SLAVE_CTRL_TASKS_PER_SET);
addr = SLAVE_CTRL_FUNC_IRQ_CLEAR_ADDR(
slave->sdev->slave_ctrl_function->slave_ctrl_pointer, task);
rc = _bif_slave_write(slave->sdev, addr, &reg, 1);
if (rc) {
pr_err("BIF slave register write failed, rc=%d\n", rc);
goto done;
}
rc = blocking_notifier_chain_unregister(
&slave->sdev->slave_ctrl_function->irq_notifier_list[task], nb);
if (rc) {
pr_err("Notifier unregistration failed, rc=%d\n", rc);
goto done;
}
slave->sdev->bdev->irq_count--;
if (slave->sdev->bdev->irq_count == 0) {
bif_cancel_irq_mode_work(slave->sdev->bdev);
} else if (slave->sdev->bdev->irq_count < 0) {
pr_err("Unbalanced IRQ free.\n");
rc = -EINVAL;
slave->sdev->bdev->irq_count = 0;
}
done:
bif_slave_ctrl_unlock(slave);
return rc;
}
EXPORT_SYMBOL(bif_free_irq);
/**
* bif_trigger_task() - trigger a task within a BIF slave
* @slave: BIF slave handle
* @task: BIF task inside of the slave to trigger. This corresponds to
* the slave control channel specified for a given BIF function
* inside of the slave.
*
* Returns 0 for success or errno if an error occurred.
*/
int bif_trigger_task(struct bif_slave *slave, unsigned int task)
{
int rc;
u16 addr;
u8 reg;
rc = bif_check_task(slave, task);
if (rc) {
pr_err("Invalid slave or task, rc=%d\n", rc);
return rc;
}
bif_slave_ctrl_lock(slave);
/* Trigger the task within the slave. */
reg = BIT(task % SLAVE_CTRL_TASKS_PER_SET);
addr = SLAVE_CTRL_FUNC_TASK_TRIGGER_ADDR(
slave->sdev->slave_ctrl_function->slave_ctrl_pointer, task);
rc = _bif_slave_write(slave->sdev, addr, &reg, 1);
if (rc) {
pr_err("BIF slave register write failed, rc=%d\n", rc);
goto done;
}
done:
bif_slave_ctrl_unlock(slave);
return rc;
}
EXPORT_SYMBOL(bif_trigger_task);
/**
* bif_enable_auto_task() - enable task auto triggering for the specified task
* @slave: BIF slave handle
* @task: BIF task inside of the slave to configure for automatic
* triggering. This corresponds to the slave control channel
* specified for a given BIF function inside of the slave.
*
* Returns 0 for success or errno if an error occurred.
*/
int bif_enable_auto_task(struct bif_slave *slave, unsigned int task)
{
int rc;
if (IS_ERR_OR_NULL(slave)) {
pr_err("Invalid slave pointer=%ld\n", PTR_ERR(slave));
return -EINVAL;
}
bif_slave_ctrl_lock(slave);
rc = _bif_enable_auto_task(slave->sdev, task);
bif_slave_ctrl_unlock(slave);
return rc;
}
EXPORT_SYMBOL(bif_enable_auto_task);
/**
* bif_disable_auto_task() - disable task auto triggering for the specified task
* @slave: BIF slave handle
* @task: BIF task inside of the slave to stop automatic triggering on.
* This corresponds to the slave control channel specified for a
* given BIF function inside of the slave.
*
* This function should be called after bif_enable_auto_task() in a paired
* fashion.
*
* Returns 0 for success or errno if an error occurred.
*/
int bif_disable_auto_task(struct bif_slave *slave, unsigned int task)
{
int rc;
if (IS_ERR_OR_NULL(slave)) {
pr_err("Invalid slave pointer=%ld\n", PTR_ERR(slave));
return -EINVAL;
}
bif_slave_ctrl_lock(slave);
rc = _bif_disable_auto_task(slave->sdev, task);
bif_slave_ctrl_unlock(slave);
return rc;
}
EXPORT_SYMBOL(bif_disable_auto_task);
/**
* bif_task_is_busy() - checks the state of a BIF slave task
* @slave: BIF slave handle
* @task: BIF task inside of the slave to trigger. This corresponds to
* the slave control channel specified for a given BIF function
* inside of the slave.
*
* Returns 1 if the task is busy, 0 if it is not busy, and errno on error.
*/
int bif_task_is_busy(struct bif_slave *slave, unsigned int task)
{
int rc;
if (IS_ERR_OR_NULL(slave)) {
pr_err("Invalid slave pointer=%ld\n", PTR_ERR(slave));
return -EINVAL;
}
bif_slave_ctrl_lock(slave);
rc = _bif_task_is_busy(slave->sdev, task);
bif_slave_ctrl_unlock(slave);
return rc;
}
EXPORT_SYMBOL(bif_task_is_busy);
static int bif_slave_notify_irqs(struct bif_slave_dev *sdev, int set, u8 val)
{
int rc = 0;
int i, task;
for (i = 0; i < SLAVE_CTRL_TASKS_PER_SET; i++) {
if (val & (1 << i)) {
task = set * SLAVE_CTRL_TASKS_PER_SET + i;
rc = blocking_notifier_call_chain(
&sdev->slave_ctrl_function->irq_notifier_list[task],
task, sdev->bdev);
rc = notifier_to_errno(rc);
if (rc)
pr_err("Notification failed for task %d\n",
task);
}
}
return rc;
}
static int bif_slave_handle_irq(struct bif_slave_dev *sdev)
{
struct bif_ctrl_dev *bdev = sdev->bdev;
bool resp = false;
int rc = 0;
int i;
u16 addr;
u8 reg;
mutex_lock(&sdev->bdev->mutex);
bif_cancel_irq_mode_work(sdev->bdev);
rc = bif_select_slave(sdev);
if (rc) {
pr_err("Could not select slave, rc=%d\n", rc);
goto done;
}
/* Check overall slave interrupt status. */
rc = bdev->desc->ops->bus_transaction_query(bdev, BIF_TRANS_BC,
BIF_CMD_ISTS, &resp);
if (rc) {
pr_err("Could not query slave interrupt status, rc=%d\n", rc);
goto done;
}
if (resp) {
for (i = 0; i < sdev->slave_ctrl_function->task_count
/ SLAVE_CTRL_TASKS_PER_SET; i++) {
addr = sdev->slave_ctrl_function->slave_ctrl_pointer
+ 4 * i + 1;
rc = _bif_slave_read(sdev, addr, &reg, 1);
if (rc) {
pr_err("BIF slave register read failed, rc=%d\n",
rc);
goto done;
}
/* Ensure that interrupts are pending in the set. */
if (reg != 0x00) {
/*
* Release mutex before notifying consumers so
* that they can use the bus.
*/
mutex_unlock(&sdev->bdev->mutex);
rc = bif_slave_notify_irqs(sdev, i, reg);
if (rc) {
pr_err("BIF slave irq notification failed, rc=%d\n",
rc);
goto notification_failed;
}
mutex_lock(&sdev->bdev->mutex);
rc = bif_select_slave(sdev);
if (rc) {
pr_err("Could not select slave, rc=%d\n",
rc);
goto done;
}
/* Clear all interrupts in this set. */
rc = _bif_slave_write(sdev, addr, &reg, 1);
if (rc) {
pr_err("BIF slave register write failed, rc=%d\n",
rc);
goto done;
}
}
}
}
done:
bif_schedule_irq_mode_work(sdev->bdev);
mutex_unlock(&sdev->bdev->mutex);
notification_failed:
if (rc == 0)
rc = resp;
return rc;
}
/**
* bif_ctrl_notify_slave_irq() - notify the BIF framework that a slave interrupt
* was received by a BIF controller
* @bdev: BIF controller device pointer
*
* This function should only be called from a BIF controller driver.
*
* Returns 0 for success or errno if an error occurred.
*/
int bif_ctrl_notify_slave_irq(struct bif_ctrl_dev *bdev)
{
struct bif_slave_dev *sdev;
int rc = 0, handled = 0;
if (IS_ERR_OR_NULL(bdev))
return -EINVAL;
mutex_lock(&bif_sdev_list_mutex);
list_for_each_entry(sdev, &bif_sdev_list, list) {
if (sdev->bdev == bdev && sdev->present) {
rc = bif_slave_handle_irq(sdev);
if (rc < 0) {
pr_err("Could not handle BIF slave irq, rc=%d\n",
rc);
break;
}
handled += rc;
}
}
mutex_unlock(&bif_sdev_list_mutex);
if (handled == 0)
pr_info("Spurious BIF slave interrupt detected.\n");
if (rc > 0)
rc = 0;
return rc;
}
EXPORT_SYMBOL(bif_ctrl_notify_slave_irq);
/**
* bif_ctrl_notify_battery_changed() - notify the BIF framework that a battery
* pack has been inserted or removed
* @bdev: BIF controller device pointer
*
* This function should only be called from a BIF controller driver.
*
* Returns 0 for success or errno if an error occurred.
*/
int bif_ctrl_notify_battery_changed(struct bif_ctrl_dev *bdev)
{
int rc = 0;
int present;
if (IS_ERR_OR_NULL(bdev))
return -EINVAL;
if (bdev->desc->ops->get_battery_presence) {
present = bdev->desc->ops->get_battery_presence(bdev);
if (present < 0) {
pr_err("Could not determine battery presence, rc=%d\n",
rc);
return rc;
}
if (bdev->battery_present == !!present)
return 0;
bdev->battery_present = present;
rc = blocking_notifier_call_chain(&bdev->bus_change_notifier,
present ? BIF_BUS_EVENT_BATTERY_INSERTED
: BIF_BUS_EVENT_BATTERY_REMOVED, bdev);
if (rc)
pr_err("Call chain noification failed, rc=%d\n", rc);
}
return rc;
}
EXPORT_SYMBOL(bif_ctrl_notify_battery_changed);
/**
* bif_ctrl_signal_battery_changed() - notify the BIF framework that a battery
* pack has been inserted or removed
* @ctrl: BIF controller consumer handle
*
* This function should only be called by a BIF consumer driver on systems where
* the BIF controller driver is unable to determine when a battery is inserted
* or removed.
*
* Returns 0 for success or errno if an error occurred.
*/
int bif_ctrl_signal_battery_changed(struct bif_ctrl *ctrl)
{
if (IS_ERR_OR_NULL(ctrl))
return -EINVAL;
return bif_ctrl_notify_battery_changed(ctrl->bdev);
}
EXPORT_SYMBOL(bif_ctrl_signal_battery_changed);
/**
* bif_ctrl_notifier_register() - register a notifier block to be called when
* a battery pack is inserted or removed
* @ctrl: BIF controller consumer handle
*
* The value passed into the notifier when it is called is one of
* enum bif_bus_event.
*
* Returns 0 for success or errno if an error occurred.
*/
int bif_ctrl_notifier_register(struct bif_ctrl *ctrl, struct notifier_block *nb)
{
int rc;
if (IS_ERR_OR_NULL(ctrl))
return -EINVAL;
rc = blocking_notifier_chain_register(&ctrl->bdev->bus_change_notifier,
nb);
if (rc)
pr_err("Notifier registration failed, rc=%d\n", rc);
return rc;
}
EXPORT_SYMBOL(bif_ctrl_notifier_register);
/**
* bif_ctrl_notifier_unregister() - unregister a battery status change notifier
* block that was previously registered
* @ctrl: BIF controller consumer handle
*
* Returns 0 for success or errno if an error occurred.
*/
int bif_ctrl_notifier_unregister(struct bif_ctrl *ctrl,
struct notifier_block *nb)
{
int rc;
if (IS_ERR_OR_NULL(ctrl))
return -EINVAL;
rc =
blocking_notifier_chain_unregister(&ctrl->bdev->bus_change_notifier,
nb);
if (rc)
pr_err("Notifier unregistration failed, rc=%d\n", rc);
return rc;
}
EXPORT_SYMBOL(bif_ctrl_notifier_unregister);
/**
* bif_get_bus_handle() - returns the BIF controller consumer handle associated
* with a BIF slave handle
* @slave: BIF slave handle
*
* Note, bif_ctrl_put() should never be called for the pointer output by
* bif_get_bus_handle().
*/
struct bif_ctrl *bif_get_bus_handle(struct bif_slave *slave)
{
if (IS_ERR_OR_NULL(slave))
return ERR_PTR(-EINVAL);
return &slave->ctrl;
}
EXPORT_SYMBOL(bif_get_bus_handle);
/**
* bif_ctrl_count() - returns the number of registered BIF controllers
*/
int bif_ctrl_count(void)
{
struct bif_ctrl_dev *bdev;
int count = 0;
mutex_lock(&bif_ctrl_list_mutex);
list_for_each_entry(bdev, &bif_ctrl_list, list) {
count++;
}
mutex_unlock(&bif_ctrl_list_mutex);
return count;
}
EXPORT_SYMBOL(bif_ctrl_count);
/**
* bif_ctrl_get_by_id() - get a handle for the id'th BIF controller registered
* in the system
* @id: Arbitrary number associated with the BIF bus in the system
*
* id must be in the range [0, bif_ctrl_count() - 1]. This function should only
* need to be called by a BIF consumer that is unable to link to a given BIF
* controller via a device tree binding.
*
* Returns a BIF controller consumer handle if successful or an ERR_PTR if not.
*/
struct bif_ctrl *bif_ctrl_get_by_id(unsigned int id)
{
struct bif_ctrl_dev *bdev;
struct bif_ctrl_dev *bdev_found = NULL;
struct bif_ctrl *ctrl = ERR_PTR(-ENODEV);
mutex_lock(&bif_ctrl_list_mutex);
list_for_each_entry(bdev, &bif_ctrl_list, list) {
if (id == 0) {
bdev_found = bdev;
break;
}
id--;
}
mutex_unlock(&bif_ctrl_list_mutex);
if (bdev_found) {
ctrl = kzalloc(sizeof(*ctrl), GFP_KERNEL);
if (!ctrl) {
pr_err("Bus handle allocation failed\n");
ctrl = ERR_PTR(-ENOMEM);
} else {
ctrl->bdev = bdev_found;
}
}
return ctrl;
}
EXPORT_SYMBOL(bif_ctrl_get_by_id);
/**
* bif_ctrl_get() - get a handle for the BIF controller that is linked to the
* consumer device in the device tree
* @consumer_dev: Pointer to the consumer's device
*
* In order to use this function, the BIF consumer's device must specify the
* "qcom,bif-ctrl" property in its device tree node which points to a BIF
* controller device node.
*
* Returns a BIF controller consumer handle if successful or an ERR_PTR if not.
* If the BIF controller linked to the consumer device has not yet probed, then
* ERR_PTR(-EPROBE_DEFER) is returned.
*/
struct bif_ctrl *bif_ctrl_get(struct device *consumer_dev)
{
struct device_node *ctrl_node = NULL;
struct bif_ctrl_dev *bdev_found = NULL;
struct bif_ctrl *ctrl = ERR_PTR(-EPROBE_DEFER);
struct bif_ctrl_dev *bdev = NULL;
if (!consumer_dev || !consumer_dev->of_node) {
pr_err("Invalid device node\n");
return ERR_PTR(-EINVAL);
}
ctrl_node = of_parse_phandle(consumer_dev->of_node, "qcom,bif-ctrl", 0);
if (!ctrl_node) {
pr_err("Could not find qcom,bif-ctrl property in %s\n",
consumer_dev->of_node->full_name);
return ERR_PTR(-ENXIO);
}
mutex_lock(&bif_ctrl_list_mutex);
list_for_each_entry(bdev, &bif_ctrl_list, list) {
if (bdev->ctrl_dev && bdev->ctrl_dev->of_node == ctrl_node) {
bdev_found = bdev;
break;
}
}
mutex_unlock(&bif_ctrl_list_mutex);
if (bdev_found) {
ctrl = kzalloc(sizeof(*ctrl), GFP_KERNEL);
if (!ctrl) {
pr_err("Bus handle allocation failed\n");
ctrl = ERR_PTR(-ENOMEM);
} else {
ctrl->bdev = bdev_found;
}
}
return ctrl;
}
EXPORT_SYMBOL(bif_ctrl_get);
/**
* bif_ctrl_put() - frees a BIF controller handle
* @ctrl: BIF controller consumer handle
*/
void bif_ctrl_put(struct bif_ctrl *ctrl)
{
if (!IS_ERR_OR_NULL(ctrl) && ctrl->exclusive_lock)
mutex_unlock(&ctrl->bdev->mutex);
kfree(ctrl);
}
EXPORT_SYMBOL(bif_ctrl_put);
static bool bif_slave_object_match(const struct bif_object *object,
const struct bif_match_criteria *criteria)
{
return (object->type == criteria->obj_type)
&& (object->version == criteria->obj_version
|| !(criteria->match_mask & BIF_MATCH_OBJ_VERSION))
&& (object->manufacturer_id == criteria->obj_manufacturer_id
|| !(criteria->match_mask & BIF_MATCH_OBJ_MANUFACTURER_ID));
}
/*
* Returns true if all parameters are matched, otherwise false.
* function_type and function_version mean that their exists some function in
* the slave which has the specified type and subtype. ctrl == NULL is treated
* as a wildcard.
*/
static bool bif_slave_match(struct bif_ctrl *ctrl,
struct bif_slave_dev *sdev, const struct bif_match_criteria *criteria)
{
int i, type, version;
struct bif_object *object;
bool function_found = false;
bool object_found = false;
if (ctrl && (ctrl->bdev != sdev->bdev))
return false;
if (!sdev->present
&& (!(criteria->match_mask & BIF_MATCH_IGNORE_PRESENCE)
|| ((criteria->match_mask & BIF_MATCH_IGNORE_PRESENCE)
&& !criteria->ignore_presence)))
return false;
if ((criteria->match_mask & BIF_MATCH_MANUFACTURER_ID)
&& sdev->l1_data.manufacturer_id != criteria->manufacturer_id)
return false;
if ((criteria->match_mask & BIF_MATCH_PRODUCT_ID)
&& sdev->l1_data.product_id != criteria->product_id)
return false;
if (criteria->match_mask & BIF_MATCH_FUNCTION_TYPE) {
if (!sdev->function_directory)
return false;
for (i = 0; i < sdev->l1_data.length / 4; i++) {
type = sdev->function_directory[i].function_type;
version = sdev->function_directory[i].function_version;
if (type == criteria->function_type &&
(version == criteria->function_version
|| !(criteria->match_mask
& BIF_MATCH_FUNCTION_VERSION))) {
function_found = true;
break;
}
}
if (!function_found)
return false;
}
if (criteria->match_mask & BIF_MATCH_OBJ_TYPE) {
if (!sdev->nvm_function)
return false;
bif_ctrl_lock(ctrl);
list_for_each_entry(object, &sdev->nvm_function->object_list,
list) {
if (bif_slave_object_match(object, criteria)) {
object_found = true;
break;
}
}
bif_ctrl_unlock(ctrl);
if (!object_found)
return false;
}
return true;
}
/**
* bif_slave_match_count() - returns the number of slaves associated with the
* specified BIF controller which fit the matching
* criteria
* @ctrl: BIF controller consumer handle
* @match_criteria: Matching criteria used to filter slaves
*/
int bif_slave_match_count(struct bif_ctrl *ctrl,
const struct bif_match_criteria *match_criteria)
{
struct bif_slave_dev *sdev;
int count = 0;
mutex_lock(&bif_sdev_list_mutex);
list_for_each_entry(sdev, &bif_sdev_list, list) {
if (bif_slave_match(ctrl, sdev, match_criteria))
count++;
}
mutex_unlock(&bif_sdev_list_mutex);
return count;
}
EXPORT_SYMBOL(bif_slave_match_count);
/**
* bif_slave_match_get() - get a slave handle for the id'th slave associated
* with the specified BIF controller which fits the
* matching criteria
* @ctrl: BIF controller consumer handle
* @id: Index into the set of matching slaves
* @match_criteria: Matching criteria used to filter slaves
*
* id must be in the range [0, bif_slave_match_count(ctrl, match_criteria) - 1].
*
* Returns a BIF slave handle if successful or an ERR_PTR if not.
*/
struct bif_slave *bif_slave_match_get(struct bif_ctrl *ctrl,
unsigned int id, const struct bif_match_criteria *match_criteria)
{
struct bif_slave_dev *sdev;
struct bif_slave *slave = ERR_PTR(-ENODEV);
struct bif_slave_dev *sdev_found = NULL;
int count = 0;
mutex_lock(&bif_sdev_list_mutex);
list_for_each_entry(sdev, &bif_sdev_list, list) {
if (bif_slave_match(ctrl, sdev, match_criteria))
count++;
if (count == id + 1) {
sdev_found = sdev;
break;
}
}
mutex_unlock(&bif_sdev_list_mutex);
if (sdev_found) {
slave = kzalloc(sizeof(*slave), GFP_KERNEL);
if (!slave) {
pr_err("Slave allocation failed\n");
slave = ERR_PTR(-ENOMEM);
} else {
slave->sdev = sdev_found;
slave->ctrl.bdev = sdev_found->bdev;
}
}
return slave;
}
EXPORT_SYMBOL(bif_slave_match_get);
/**
* bif_slave_put() - frees a BIF slave handle
* @slave: BIF slave handle
*/
void bif_slave_put(struct bif_slave *slave)
{
if (!IS_ERR_OR_NULL(slave) && slave->ctrl.exclusive_lock)
mutex_unlock(&slave->sdev->bdev->mutex);
kfree(slave);
}
EXPORT_SYMBOL(bif_slave_put);
/**
* bif_slave_find_function() - get the function pointer and version of a
* BIF function if it is present on the specified slave
* @slave: BIF slave handle
* @function: BIF function to search for inside of the slave
* @version: If the function is found, then 'version' is set to the
* version value of the function
* @function_pointer: If the function is found, then 'function_pointer' is set
* to the BIF slave address of the function
*
* Returns 0 for success or errno if an error occurred. If the function is not
* found in the slave, then -ENODEV is returned.
*/
int bif_slave_find_function(struct bif_slave *slave, u8 function, u8 *version,
u16 *function_pointer)
{
int rc = -ENODEV;
struct bif_ddb_l2_data *func;
int i;
if (IS_ERR_OR_NULL(slave) || IS_ERR_OR_NULL(version)
|| IS_ERR_OR_NULL(function_pointer)) {
pr_err("Invalid pointer input.\n");
return -EINVAL;
}
func = slave->sdev->function_directory;
for (i = 0; i < slave->sdev->l1_data.length / 4; i++) {
if (function == func[i].function_type) {
*version = func[i].function_version;
*function_pointer = func[i].function_pointer;
rc = 0;
break;
}
}
return rc;
}
EXPORT_SYMBOL(bif_slave_find_function);
static bool bif_object_match(const struct bif_object *object,
const struct bif_obj_match_criteria *criteria)
{
return (object->type == criteria->type
|| !(criteria->match_mask & BIF_OBJ_MATCH_TYPE))
&& (object->version == criteria->version
|| !(criteria->match_mask & BIF_OBJ_MATCH_VERSION))
&& (object->manufacturer_id == criteria->manufacturer_id
|| !(criteria->match_mask & BIF_OBJ_MATCH_MANUFACTURER_ID));
}
/**
* bif_object_match_count() - returns the number of objects associated with the
* specified BIF slave which fit the matching criteria
* @slave: BIF slave handle
* @match_criteria: Matching criteria used to filter objects
*/
int bif_object_match_count(struct bif_slave *slave,
const struct bif_obj_match_criteria *match_criteria)
{
struct bif_object *object;
int count = 0;
if (IS_ERR_OR_NULL(slave) || IS_ERR_OR_NULL(match_criteria)) {
pr_err("Invalid pointer input.\n");
return -EINVAL;
}
if (!slave->sdev->nvm_function)
return 0;
bif_slave_ctrl_lock(slave);
list_for_each_entry(object, &slave->sdev->nvm_function->object_list,
list) {
if (bif_object_match(object, match_criteria))
count++;
}
bif_slave_ctrl_unlock(slave);
return count;
}
EXPORT_SYMBOL(bif_object_match_count);
/**
* bif_object_match_get() - get a BIF object handle for the id'th object found
* in the non-volatile memory of the specified BIF slave
* which fits the matching criteria
* @slave: BIF slave handle
* @id: Index into the set of matching objects
* @match_criteria: Matching criteria used to filter objects
*
* id must be in range [0, bif_object_match_count(slave, match_criteria) - 1].
*
* Returns a BIF object handle if successful or an ERR_PTR if not. This handle
* must be freed using bif_object_put() when it is no longer needed.
*/
struct bif_object *bif_object_match_get(struct bif_slave *slave,
unsigned int id, const struct bif_obj_match_criteria *match_criteria)
{
struct bif_object *object;
struct bif_object *object_found = NULL;
struct bif_object *object_consumer = ERR_PTR(-ENODEV);
int count = 0;
if (IS_ERR_OR_NULL(slave) || IS_ERR_OR_NULL(match_criteria)) {
pr_err("Invalid pointer input.\n");
return ERR_PTR(-EINVAL);
}
if (!slave->sdev->nvm_function)
return object_consumer;
bif_slave_ctrl_lock(slave);
list_for_each_entry(object, &slave->sdev->nvm_function->object_list,
list) {
if (bif_object_match(object, match_criteria))
count++;
if (count == id + 1) {
object_found = object;
break;
}
}
if (object_found) {
object_consumer = kmemdup(object_found,
sizeof(*object_consumer), GFP_KERNEL);
if (!object_consumer) {
pr_err("out of memory\n");
object_consumer = ERR_PTR(-ENOMEM);
goto done;
}
object_consumer->data = kmemdup(object_found->data,
object_found->length - 8, GFP_KERNEL);
if (!object_consumer->data) {
pr_err("out of memory\n");
kfree(object_consumer);
object_consumer = ERR_PTR(-ENOMEM);
goto done;
}
/*
* Use prev pointer in consumer struct to point to original
* struct in the internal linked list.
*/
object_consumer->list.prev = &object_found->list;
}
done:
bif_slave_ctrl_unlock(slave);
return object_consumer;
}
EXPORT_SYMBOL(bif_object_match_get);
/**
* bif_object_put() - frees the memory allocated for a BIF object pointer
* returned by bif_object_match_get()
* @object: BIF object to free
*/
void bif_object_put(struct bif_object *object)
{
if (object)
kfree(object->data);
kfree(object);
}
EXPORT_SYMBOL(bif_object_put);
/* Copies the contents of object into buf following MIPI-BIF formatting. */
static void bif_object_flatten(u8 *buf, const struct bif_object *object)
{
buf[0] = object->type;
buf[1] = object->version;
buf[2] = object->manufacturer_id >> 8;
buf[3] = object->manufacturer_id;
buf[4] = object->length >> 8;
buf[5] = object->length;
memcpy(&buf[6], object->data, object->length - 8);
buf[object->length - 2] = object->crc >> 8;
buf[object->length - 1] = object->crc;
}
/**
* bif_object_write() - writes a new BIF object at the end of the object list in
* the non-volatile memory of a slave
* @slave: BIF slave handle
* @type: Type of the object
* @version: Version of the object
* @manufacturer_id: Manufacturer ID number allocated by MIPI
* @data: Data contained in the object
* @data_len: Length of the data
*
* Returns 0 on success or errno on failure. This function will fail if the NVM
* lock points to an offset after the BIF object list terminator (0x00).
*/
int bif_object_write(struct bif_slave *slave, u8 type, u8 version,
u16 manufacturer_id, const u8 *data, int data_len)
{
struct bif_object *object;
struct bif_object *tail_object;
struct bif_nvm_function *nvm;
int rc;
int add_null = 0;
u16 offset = 0;
u8 *buf;
if (IS_ERR_OR_NULL(slave) || IS_ERR_OR_NULL(data)) {
pr_err("Invalid input pointer\n");
return -EINVAL;
}
nvm = slave->sdev->nvm_function;
if (!nvm) {
pr_err("BIF slave has no NVM function\n");
return -ENODEV;
}
bif_slave_ctrl_lock(slave);
if (nvm->object_count > 0) {
tail_object = list_entry(nvm->object_list.prev,
struct bif_object, list);
offset = tail_object->addr - nvm->nvm_base_address
+ tail_object->length;
}
if (offset < nvm->nvm_lock_offset) {
pr_err("Cannot write BIF object to NVM because the end of the object list is locked (end=%d < lock=%d)\n",
offset, nvm->nvm_lock_offset);
rc = -EPERM;
goto error_unlock;
} else if (offset + data_len + 8 > nvm->nvm_size) {
pr_err("Cannot write BIF object to NVM because there is not enough remaining space (size=%d > remaining=%d)\n",
data_len + 8, nvm->nvm_size - offset);
rc = -EINVAL;
goto error_unlock;
}
if (offset + data_len + 8 < nvm->nvm_size)
add_null = 1;
object = kzalloc(sizeof(*object), GFP_KERNEL);
if (!object) {
pr_err("kzalloc failed\n");
rc = -ENOMEM;
goto error_unlock;
}
object->data = kzalloc(data_len, GFP_KERNEL);
if (!object->data) {
pr_err("kzalloc failed\n");
rc = -ENOMEM;
goto free_object;
}
buf = kzalloc(data_len + 8 + add_null, GFP_KERNEL);
if (!buf) {
pr_err("kzalloc failed\n");
rc = -ENOMEM;
goto free_data;
}
object->type = type;
object->version = version;
object->manufacturer_id = manufacturer_id;
object->length = data_len + 8;
memcpy(object->data, data, data_len);
object->crc = bif_object_crc_ccitt(object);
object->addr = offset + nvm->nvm_base_address;
bif_object_flatten(buf, object);
if (add_null)
buf[object->length] = BIF_OBJ_END_OF_LIST;
rc = _bif_slave_nvm_raw_write(slave->sdev, offset, buf,
object->length + add_null);
if (rc < 0) {
pr_err("NVM write failed, rc=%d\n", rc);
kfree(buf);
goto free_data;
}
kfree(buf);
list_add_tail(&object->list, &nvm->object_list);
nvm->object_count++;
bif_slave_ctrl_unlock(slave);
return rc;
free_data:
kfree(object->data);
free_object:
kfree(object);
error_unlock:
bif_slave_ctrl_unlock(slave);
return rc;
}
EXPORT_SYMBOL(bif_object_write);
/*
* Returns a pointer to the internal object referenced by a consumer object
* if it exists. Returns NULL if the internal object cannot be found.
*/
static struct bif_object *bif_object_consumer_search(
struct bif_nvm_function *nvm, const struct bif_object *consumer_object)
{
struct bif_object *object = NULL;
struct bif_object *search_object;
/*
* Internal struct in object linked list is pointed to by consumer
* object list.prev.
*/
search_object = list_entry(consumer_object->list.prev,
struct bif_object, list);
list_for_each_entry(object, &nvm->object_list, list) {
if (object == search_object)
break;
}
if (object != search_object)
return NULL;
return object;
}
/**
* bif_object_overwrite() - overwrites an existing BIF object found in the
* non-volatile memory of a slave
* @slave: BIF slave handle
* @object: Existing object in the slave to overwrite
* @type: Type of the object
* @version: Version of the object
* @manufacturer_id: Manufacturer ID number allocated by MIPI
* @data: Data contained in the object
* @data_len: Length of the data
*
* Returns 0 on success or errno on failure. The data stored within 'object'
* is updated to the new values upon success. The new data written to the
* object must have exactly the same length as the old data (i.e.
* data_len == object->length - 8).
*
* This function will fail if the NVM lock points to an offset after the
* beginning of the existing BIF object.
*/
int bif_object_overwrite(struct bif_slave *slave,
struct bif_object *object, u8 type, u8 version,
u16 manufacturer_id, const u8 *data, int data_len)
{
struct bif_object *edit_object = NULL;
struct bif_nvm_function *nvm;
int rc;
u16 crc;
u8 *buf;
if (IS_ERR_OR_NULL(slave) || IS_ERR_OR_NULL(object)
|| IS_ERR_OR_NULL(data)) {
pr_err("Invalid input pointer\n");
return -EINVAL;
}
nvm = slave->sdev->nvm_function;
if (!nvm) {
pr_err("BIF slave has no NVM function\n");
return -ENODEV;
}
if (data_len + 8 != object->length) {
pr_err("New data length=%d is different from existing length=%d\n",
data_len, object->length - 8);
return -EINVAL;
}
bif_slave_ctrl_lock(slave);
edit_object = bif_object_consumer_search(nvm, object);
if (!edit_object) {
pr_err("BIF object not found within slave\n");
rc = -EINVAL;
goto error_unlock;
}
if (edit_object->addr - nvm->nvm_base_address < nvm->nvm_lock_offset) {
pr_err("Cannot overwrite BIF object in NVM because some portion of it is locked\n");
rc = -EPERM;
goto error_unlock;
}
buf = kzalloc(data_len + 8, GFP_KERNEL);
if (!buf) {
pr_err("kzalloc failed\n");
rc = -ENOMEM;
goto error_unlock;
}
buf[0] = type;
buf[1] = version;
buf[2] = manufacturer_id >> 8;
buf[3] = manufacturer_id;
buf[4] = (data_len + 8) >> 8;
buf[5] = data_len + 8;
memcpy(&buf[6], data, data_len);
crc = bif_crc_ccitt(buf, data_len + 6);
buf[data_len + 6] = crc >> 8;
buf[data_len + 7] = crc;
rc = _bif_slave_nvm_raw_write(slave->sdev,
object->addr - nvm->nvm_base_address, buf, data_len + 8);
if (rc < 0) {
pr_err("NVM write failed, rc=%d\n", rc);
kfree(buf);
goto error_unlock;
}
kfree(buf);
/* Update internal object struct. */
edit_object->type = type;
edit_object->version = version;
edit_object->manufacturer_id = manufacturer_id;
edit_object->length = data_len + 8;
memcpy(edit_object->data, data, data_len);
edit_object->crc = crc;
/* Update consumer object struct. */
object->type = type;
object->version = version;
object->manufacturer_id = manufacturer_id;
object->length = data_len + 8;
memcpy(object->data, data, data_len);
object->crc = crc;
error_unlock:
bif_slave_ctrl_unlock(slave);
return rc;
}
EXPORT_SYMBOL(bif_object_overwrite);
/**
* bif_object_delete() - deletes an existing BIF object found in the
* non-volatile memory of a slave. Objects found in the
* object list in the NVM of the slave are shifted forward
* in order to fill the hole left by the deleted object
* @slave: BIF slave handle
* @object: Existing object in the slave to delete
*
* Returns 0 on success or errno on failure. bif_object_put() must still be
* called after this function in order to free the memory in the consumer
* 'object' struct pointer.
*
* This function will fail if the NVM lock points to an offset after the
* beginning of the existing BIF object.
*/
int bif_object_delete(struct bif_slave *slave, const struct bif_object *object)
{
struct bif_object *del_object = NULL;
struct bif_object *tail_object;
struct bif_nvm_function *nvm;
bool found = false;
int pos = 0;
int rc;
u8 *buf;
if (IS_ERR_OR_NULL(slave) || IS_ERR_OR_NULL(object)) {
pr_err("Invalid input pointer\n");
return -EINVAL;
}
nvm = slave->sdev->nvm_function;
if (!nvm) {
pr_err("BIF slave has no NVM function\n");
return -ENODEV;
}
bif_slave_ctrl_lock(slave);
del_object = bif_object_consumer_search(nvm, object);
if (!del_object) {
pr_err("BIF object not found within slave\n");
rc = -EINVAL;
goto error_unlock;
}
if (del_object->addr - nvm->nvm_base_address < nvm->nvm_lock_offset) {
pr_err("Cannot delete BIF object in NVM because some portion of it is locked\n");
rc = -EPERM;
goto error_unlock;
}
buf = kmalloc(nvm->nvm_size, GFP_KERNEL);
if (!buf) {
pr_err("kzalloc failed\n");
rc = -ENOMEM;
goto error_unlock;
}
/*
* Copy the contents of objects after the one to be deleted into a flat
* array.
*/
list_for_each_entry(tail_object, &nvm->object_list, list) {
if (found) {
bif_object_flatten(&buf[pos], tail_object);
pos += tail_object->length;
} else if (tail_object == del_object) {
found = true;
}
}
/* Add the list terminator. */
buf[pos++] = BIF_OBJ_END_OF_LIST;
rc = _bif_slave_nvm_raw_write(slave->sdev,
del_object->addr - nvm->nvm_base_address, buf, pos);
if (rc < 0) {
pr_err("NVM write failed, rc=%d\n", rc);
kfree(buf);
goto error_unlock;
}
kfree(buf);
/* Update the addresses of the objects after the one to be deleted. */
found = false;
list_for_each_entry(tail_object, &nvm->object_list, list) {
if (found)
tail_object->addr -= del_object->length;
else if (tail_object == del_object)
found = true;
}
list_del(&del_object->list);
kfree(del_object->data);
kfree(del_object);
nvm->object_count--;
error_unlock:
bif_slave_ctrl_unlock(slave);
return rc;
}
EXPORT_SYMBOL(bif_object_delete);
/**
* bif_slave_read() - read contiguous memory values from a BIF slave
* @slave: BIF slave handle
* @addr: BIF slave address to begin reading at
* @buf: Buffer to fill with memory values
* @len: Number of byte to read
*
* Returns 0 for success or errno if an error occurred.
*/
int bif_slave_read(struct bif_slave *slave, u16 addr, u8 *buf, int len)
{
int rc;
if (IS_ERR_OR_NULL(slave) || IS_ERR_OR_NULL(buf)) {
pr_err("Invalid pointer input.\n");
return -EINVAL;
}
bif_slave_ctrl_lock(slave);
rc = _bif_slave_read(slave->sdev, addr, buf, len);
if (rc)
pr_err("BIF slave read failed, rc=%d\n", rc);
bif_slave_ctrl_unlock(slave);
return rc;
}
EXPORT_SYMBOL(bif_slave_read);
/**
* bif_slave_write() - write contiguous memory values to a BIF slave
* @slave: BIF slave handle
* @addr: BIF slave address to begin writing at
* @buf: Buffer containing values to write
* @len: Number of byte to write
*
* Returns 0 for success or errno if an error occurred.
*/
int bif_slave_write(struct bif_slave *slave, u16 addr, u8 *buf, int len)
{
int rc;
if (IS_ERR_OR_NULL(slave) || IS_ERR_OR_NULL(buf)) {
pr_err("Invalid pointer input.\n");
return -EINVAL;
}
bif_slave_ctrl_lock(slave);
rc = _bif_slave_write(slave->sdev, addr, buf, len);
if (rc)
pr_err("BIF slave write failed, rc=%d\n", rc);
bif_slave_ctrl_unlock(slave);
return rc;
}
EXPORT_SYMBOL(bif_slave_write);
/**
* bif_slave_nvm_raw_read() - read contiguous memory values from a BIF slave's
* non-volatile memory (NVM)
* @slave: BIF slave handle
* @offset: Offset from the beginning of BIF slave NVM to begin reading at
* @buf: Buffer to fill with memory values
* @len: Number of byte to read
*
* Returns 0 for success or errno if an error occurred.
*/
int bif_slave_nvm_raw_read(struct bif_slave *slave, u16 offset, u8 *buf,
int len)
{
if (IS_ERR_OR_NULL(slave)) {
pr_err("Invalid slave pointer=%ld\n", PTR_ERR(slave));
return -EINVAL;
} else if (IS_ERR_OR_NULL(buf)) {
pr_err("Invalid buffer pointer=%ld\n", PTR_ERR(buf));
return -EINVAL;
} else if (!slave->sdev->nvm_function) {
pr_err("BIF slave has no NVM function\n");
return -ENODEV;
} else if (offset + len > slave->sdev->nvm_function->nvm_size) {
pr_err("read offset + len = %d > NVM size = %d\n",
offset + len, slave->sdev->nvm_function->nvm_size);
return -EINVAL;
}
return bif_slave_read(slave,
slave->sdev->nvm_function->nvm_base_address + offset, buf, len);
}
EXPORT_SYMBOL(bif_slave_nvm_raw_read);
/**
* bif_slave_nvm_raw_write() - write contiguous memory values to a BIF slave's
* non-volatile memory (NVM)
* @slave: BIF slave handle
* @offset: Offset from the beginning of BIF slave NVM to begin writing at
* @buf: Buffer containing values to write
* @len: Number of byte to write
*
* Note that this function does *not* respect the MIPI-BIF object data
* formatting specification. It can cause corruption of the object data list
* stored in NVM if used improperly.
*
* Returns 0 for success or errno if an error occurred.
*/
int bif_slave_nvm_raw_write(struct bif_slave *slave, u16 offset, u8 *buf,
int len)
{
int rc;
if (IS_ERR_OR_NULL(slave)) {
pr_err("Invalid slave pointer=%ld\n", PTR_ERR(slave));
return -EINVAL;
} else if (IS_ERR_OR_NULL(buf)) {
pr_err("Invalid buffer pointer=%ld\n", PTR_ERR(buf));
return -EINVAL;
}
bif_slave_ctrl_lock(slave);
rc = _bif_slave_nvm_raw_write(slave->sdev, offset, buf, len);
bif_slave_ctrl_unlock(slave);
return rc;
}
EXPORT_SYMBOL(bif_slave_nvm_raw_write);
/**
* bif_slave_is_present() - check if a slave is currently physically present
* in the system
* @slave: BIF slave handle
*
* Returns 1 if the slave is present, 0 if the slave is not present, or errno
* if an error occurred.
*
* This function can be used by BIF consumer drivers to check if their slave
* handles are still meaningful after battery reinsertion.
*/
int bif_slave_is_present(struct bif_slave *slave)
{
if (IS_ERR_OR_NULL(slave)) {
pr_err("Invalid pointer input.\n");
return -EINVAL;
}
return slave->sdev->present;
}
EXPORT_SYMBOL(bif_slave_is_present);
/**
* bif_slave_is_selected() - check if a slave is currently selected on the BIF
* bus
* @slave: BIF slave handle
*
* Returns 1 if the slave is selected, 0 if the slave is not selected, or errno
* if an error occurred.
*
* This function should not be required under normal circumstances since the
* bif-core framework ensures that slaves are always selected when needed.
* It would be most useful when used as a helper in conjunction with
* bif_ctrl_bus_lock() and the raw transaction functions.
*/
int bif_slave_is_selected(struct bif_slave *slave)
{
int rc;
if (IS_ERR_OR_NULL(slave)) {
pr_err("Invalid pointer input.\n");
return -EINVAL;
}
if (slave->sdev->bdev->selected_sdev != slave->sdev)
return false;
bif_slave_ctrl_lock(slave);
rc = bif_is_slave_selected(slave->sdev->bdev);
bif_slave_ctrl_unlock(slave);
return rc;
}
EXPORT_SYMBOL(bif_slave_is_selected);
/**
* bif_slave_select() - select a slave on the BIF bus
* @slave: BIF slave handle
*
* Returns 0 on success or errno if an error occurred.
*
* This function should not be required under normal circumstances since the
* bif-core framework ensures that slaves are always selected when needed.
* It would be most useful when used as a helper in conjunction with
* bif_ctrl_bus_lock() and the raw transaction functions.
*/
int bif_slave_select(struct bif_slave *slave)
{
int rc;
if (IS_ERR_OR_NULL(slave)) {
pr_err("Invalid pointer input.\n");
return -EINVAL;
}
bif_slave_ctrl_lock(slave);
slave->sdev->bdev->selected_sdev = NULL;
rc = bif_select_slave(slave->sdev);
bif_slave_ctrl_unlock(slave);
return rc;
}
EXPORT_SYMBOL(bif_slave_select);
/**
* bif_ctrl_raw_transaction() - perform a raw BIF transaction on the bus which
* expects no slave response
* @ctrl: BIF controller consumer handle
* @transaction: BIF transaction to carry out. This should be one of the
* values in enum bif_transaction.
* @data: 8-bit data to use in the transaction. The meaning of
* this data depends upon the transaction that is to be
* performed.
*
* When performing a bus command (BC) transaction, values in enum
* bif_bus_command may be used for the data parameter. Additional manufacturer
* specific values may also be used in a BC transaction.
*
* Returns 0 on success or errno if an error occurred.
*
* This function should only need to be used when BIF transactions are required
* that are not handled by the bif-core directly.
*/
int bif_ctrl_raw_transaction(struct bif_ctrl *ctrl, int transaction, u8 data)
{
int rc;
if (IS_ERR_OR_NULL(ctrl)) {
pr_err("Invalid pointer input.\n");
return -EINVAL;
}
bif_ctrl_lock(ctrl);
rc = ctrl->bdev->desc->ops->bus_transaction(ctrl->bdev, transaction,
data);
if (rc)
pr_err("BIF bus transaction failed, rc=%d\n", rc);
bif_ctrl_unlock(ctrl);
return rc;
}
EXPORT_SYMBOL(bif_ctrl_raw_transaction);
/**
* bif_ctrl_raw_transaction_read() - perform a raw BIF transaction on the bus
* which expects an RD or TACK slave response word
* @ctrl: BIF controller consumer handle
* @transaction: BIF transaction to carry out. This should be one of the
* values in enum bif_transaction.
* @data: 8-bit data to use in the transaction. The meaning of
* this data depends upon the transaction that is to be
* performed.
* @response: Pointer to an integer which is filled with the 11-bit
* slave response word upon success. The 11-bit format is
* (MSB to LSB) BCF, ACK, EOT, D7-D0.
*
* When performing a bus command (BC) transaction, values in enum
* bif_bus_command may be used for the data parameter. Additional manufacturer
* specific values may also be used in a BC transaction.
*
* Returns 0 on success or errno if an error occurred.
*
* This function should only need to be used when BIF transactions are required
* that are not handled by the bif-core directly.
*/
int bif_ctrl_raw_transaction_read(struct bif_ctrl *ctrl, int transaction,
u8 data, int *response)
{
int rc;
if (IS_ERR_OR_NULL(ctrl) || IS_ERR_OR_NULL(response)) {
pr_err("Invalid pointer input.\n");
return -EINVAL;
}
bif_ctrl_lock(ctrl);
rc = ctrl->bdev->desc->ops->bus_transaction_read(ctrl->bdev,
transaction, data, response);
if (rc)
pr_err("BIF bus transaction failed, rc=%d\n", rc);
bif_ctrl_unlock(ctrl);
return rc;
}
EXPORT_SYMBOL(bif_ctrl_raw_transaction_read);
/**
* bif_ctrl_raw_transaction_query() - perform a raw BIF transaction on the bus
* which expects a BQ slave response
* @ctrl: BIF controller consumer handle
* @transaction: BIF transaction to carry out. This should be one of the
* values in enum bif_transaction.
* @data: 8-bit data to use in the transaction. The meaning of
* this data depends upon the transaction that is to be
* performed.
* @query_response: Pointer to boolean which is set to true if a BQ pulse
* is receieved, or false if no BQ pulse is received before
* timing out.
*
* When performing a bus command (BC) transaction, values in enum
* bif_bus_command may be used for the data parameter. Additional manufacturer
* specific values may also be used in a BC transaction.
*
* Returns 0 on success or errno if an error occurred.
*
* This function should only need to be used when BIF transactions are required
* that are not handled by the bif-core directly.
*/
int bif_ctrl_raw_transaction_query(struct bif_ctrl *ctrl, int transaction,
u8 data, bool *query_response)
{
int rc;
if (IS_ERR_OR_NULL(ctrl) || IS_ERR_OR_NULL(query_response)) {
pr_err("Invalid pointer input.\n");
return -EINVAL;
}
bif_ctrl_lock(ctrl);
rc = ctrl->bdev->desc->ops->bus_transaction_query(ctrl->bdev,
transaction, data, query_response);
if (rc)
pr_err("BIF bus transaction failed, rc=%d\n", rc);
bif_ctrl_unlock(ctrl);
return rc;
}
EXPORT_SYMBOL(bif_ctrl_raw_transaction_query);
/**
* bif_ctrl_bus_lock() - lock the BIF bus of a controller for exclusive access
* @ctrl: BIF controller consumer handle
*
* This function should only need to be called in circumstances where a BIF
* consumer is issuing special BIF bus commands that have strict ordering
* requirements.
*/
void bif_ctrl_bus_lock(struct bif_ctrl *ctrl)
{
if (IS_ERR_OR_NULL(ctrl)) {
pr_err("Invalid controller handle.\n");
return;
}
if (ctrl->exclusive_lock) {
pr_err("BIF bus exclusive lock already held\n");
return;
}
mutex_lock(&ctrl->bdev->mutex);
ctrl->exclusive_lock = true;
bif_cancel_irq_mode_work(ctrl->bdev);
}
EXPORT_SYMBOL(bif_ctrl_bus_lock);
/**
* bif_ctrl_bus_unlock() - lock the BIF bus of a controller that was previously
* locked for exclusive access
* @ctrl: BIF controller consumer handle
*
* This function must only be called after first calling bif_ctrl_bus_lock().
*/
void bif_ctrl_bus_unlock(struct bif_ctrl *ctrl)
{
if (IS_ERR_OR_NULL(ctrl)) {
pr_err("Invalid controller handle.\n");
return;
}
if (!ctrl->exclusive_lock) {
pr_err("BIF bus exclusive lock not already held\n");
return;
}
ctrl->exclusive_lock = false;
bif_schedule_irq_mode_work(ctrl->bdev);
mutex_unlock(&ctrl->bdev->mutex);
}
EXPORT_SYMBOL(bif_ctrl_bus_unlock);
/**
* bif_ctrl_measure_rid() - measure the battery pack Rid pull-down resistance
* in ohms
* @ctrl: BIF controller consumer handle
*
* Returns the resistance of the Rid resistor in ohms if successful or errno
* if an error occurred.
*/
int bif_ctrl_measure_rid(struct bif_ctrl *ctrl)
{
int rc;
if (IS_ERR_OR_NULL(ctrl)) {
pr_err("Invalid controller handle.\n");
return -ENODEV;
}
if (!ctrl->bdev->desc->ops->get_battery_rid) {
pr_err("Cannot measure Rid.\n");
return -ENXIO;
}
bif_ctrl_lock(ctrl);
rc = ctrl->bdev->desc->ops->get_battery_rid(ctrl->bdev);
if (rc < 0)
pr_err("Error during Rid measurement, rc=%d\n", rc);
bif_ctrl_unlock(ctrl);
return rc;
}
EXPORT_SYMBOL(bif_ctrl_measure_rid);
/**
* bif_ctrl_get_bus_period() - get the BIF bus period (tau_bif) in nanoseconds
* @ctrl: BIF controller consumer handle
*
* Returns the currently configured bus period in nanoseconds if successful or
* errno if an error occurred.
*/
int bif_ctrl_get_bus_period(struct bif_ctrl *ctrl)
{
int rc;
if (IS_ERR_OR_NULL(ctrl)) {
pr_err("Invalid controller handle.\n");
return -ENODEV;
}
if (!ctrl->bdev->desc->ops->get_bus_period) {
pr_err("Cannot get the BIF bus period.\n");
return -ENXIO;
}
rc = ctrl->bdev->desc->ops->get_bus_period(ctrl->bdev);
if (rc < 0)
pr_err("Error during bus period retrieval, rc=%d\n", rc);
return rc;
}
EXPORT_SYMBOL(bif_ctrl_get_bus_period);
/**
* bif_ctrl_set_bus_period() - set the BIF bus period (tau_bif) in nanoseconds
* @ctrl: BIF controller consumer handle
* @period_ns: BIF bus period in nanoseconds to use
*
* If the exact period is not supported by the BIF controller hardware, then the
* next larger supported period will be used.
*
* Returns 0 on success or errno if an error occurred.
*/
int bif_ctrl_set_bus_period(struct bif_ctrl *ctrl, int period_ns)
{
int rc;
if (IS_ERR_OR_NULL(ctrl)) {
pr_err("Invalid controller handle.\n");
return -ENODEV;
}
if (!ctrl->bdev->desc->ops->set_bus_period) {
pr_err("Cannot set the BIF bus period.\n");
return -ENXIO;
}
bif_ctrl_lock(ctrl);
rc = ctrl->bdev->desc->ops->set_bus_period(ctrl->bdev, period_ns);
if (rc)
pr_err("Error during bus period configuration, rc=%d\n", rc);
bif_ctrl_unlock(ctrl);
return rc;
}
EXPORT_SYMBOL(bif_ctrl_set_bus_period);
/**
* bif_ctrl_get_bus_state() - get the current state of the BIF bus
* @ctrl: BIF controller consumer handle
*
* Returns a bus state from enum bif_bus_state if successful or errno if an
* error occurred.
*/
int bif_ctrl_get_bus_state(struct bif_ctrl *ctrl)
{
int rc;
if (IS_ERR_OR_NULL(ctrl)) {
pr_err("Invalid controller handle.\n");
return -ENODEV;
}
rc = ctrl->bdev->desc->ops->get_bus_state(ctrl->bdev);
if (rc < 0)
pr_err("Error during bus state retrieval, rc=%d\n", rc);
return rc;
}
EXPORT_SYMBOL(bif_ctrl_get_bus_state);
/**
* bif_ctrl_set_bus_state() - set the state of the BIF bus
* @ctrl: BIF controller consumer handle
* @state: State for the BIF bus to enter
*
* Returns 0 on success or errno if an error occurred.
*/
int bif_ctrl_set_bus_state(struct bif_ctrl *ctrl, enum bif_bus_state state)
{
int rc;
if (IS_ERR_OR_NULL(ctrl)) {
pr_err("Invalid controller handle.\n");
return -ENODEV;
}
bif_ctrl_lock(ctrl);
rc = ctrl->bdev->desc->ops->set_bus_state(ctrl->bdev, state);
if (rc < 0)
pr_err("Error during bus state configuration, rc=%d\n", rc);
/*
* Uncache the selected slave if the new bus state results in the slave
* becoming unselected.
*/
if (state == BIF_BUS_STATE_MASTER_DISABLED
|| state == BIF_BUS_STATE_POWER_DOWN
|| state == BIF_BUS_STATE_STANDBY)
ctrl->bdev->selected_sdev = NULL;
bif_ctrl_unlock(ctrl);
return rc;
}
EXPORT_SYMBOL(bif_ctrl_set_bus_state);
/*
* Check if the specified function is a protocol function and if it is, then
* instantiate protocol function data for the slave.
*/
static int bif_initialize_protocol_function(struct bif_slave_dev *sdev,
struct bif_ddb_l2_data *func)
{
int rc = 0;
u8 buf[4];
/* Ensure that this is a protocol function. */
if (func->function_type != BIF_FUNC_PROTOCOL)
return 0;
if (sdev->protocol_function) {
pr_err("Duplicate protocol function found for BIF slave; DEV_ADR=0x%02X\n",
sdev->slave_addr);
return -EPERM;
}
sdev->protocol_function = kzalloc(sizeof(struct bif_protocol_function),
GFP_KERNEL);
if (!sdev->protocol_function) {
pr_err("out of memory\n");
return -ENOMEM;
}
rc = _bif_slave_read(sdev, func->function_pointer, buf, 4);
if (rc) {
pr_err("Protocol function data read failed, rc=%d\n", rc);
return rc;
}
sdev->protocol_function->protocol_pointer = buf[0] << 8 | buf[1];
sdev->protocol_function->device_id_pointer = buf[2] << 8 | buf[3];
sdev->protocol_function->l2_entry = func;
rc = _bif_slave_read(sdev, sdev->protocol_function->device_id_pointer,
sdev->protocol_function->device_id, BIF_DEVICE_ID_BYTE_LENGTH);
if (rc) {
pr_err("Device ID read failed, rc=%d\n", rc);
return rc;
}
/* Check if this slave does not have a UID value stored. */
if (sdev->unique_id_bits_known == 0) {
sdev->unique_id_bits_known = BIF_UNIQUE_ID_BIT_LENGTH;
/* Fill in UID using manufacturer ID and device ID. */
sdev->unique_id[0] = sdev->l1_data.manufacturer_id >> 8;
sdev->unique_id[1] = sdev->l1_data.manufacturer_id;
memcpy(&sdev->unique_id[2],
sdev->protocol_function->device_id,
BIF_DEVICE_ID_BYTE_LENGTH);
}
return rc;
}
/*
* Check if the specified function is a slave control function and if it is,
* then instantiate slave control function data for the slave.
*/
static int bif_initialize_slave_control_function(struct bif_slave_dev *sdev,
struct bif_ddb_l2_data *func)
{
int rc = 0;
int i;
u8 buf[3];
/* Ensure that this is a slave control function. */
if (func->function_type != BIF_FUNC_SLAVE_CONTROL)
return 0;
if (sdev->slave_ctrl_function) {
pr_err("Duplicate slave control function found for BIF slave; DEV_ADR=0x%02X\n",
sdev->slave_addr);
return -EPERM;
}
sdev->slave_ctrl_function
= kzalloc(sizeof(struct bif_protocol_function), GFP_KERNEL);
if (!sdev->slave_ctrl_function) {
pr_err("out of memory\n");
return -ENOMEM;
}
rc = _bif_slave_read(sdev, func->function_pointer, buf, 3);
if (rc) {
pr_err("Slave control function data read failed, rc=%d\n", rc);
return rc;
}
sdev->slave_ctrl_function->slave_ctrl_pointer = buf[0] << 8 | buf[1];
sdev->slave_ctrl_function->task_count
= buf[2] * SLAVE_CTRL_TASKS_PER_SET;
sdev->slave_ctrl_function->l2_entry = func;
if (sdev->slave_ctrl_function->task_count > 0) {
sdev->slave_ctrl_function->irq_notifier_list =
kzalloc(sizeof(struct blocking_notifier_head)
* sdev->slave_ctrl_function->task_count,
GFP_KERNEL);
if (!sdev->slave_ctrl_function->irq_notifier_list) {
pr_err("out of memory\n");
kfree(sdev->slave_ctrl_function);
return -ENOMEM;
}
for (i = 0; i < sdev->slave_ctrl_function->task_count; i++) {
BLOCKING_INIT_NOTIFIER_HEAD(
&sdev->slave_ctrl_function->irq_notifier_list[i]);
}
}
return rc;
}
/*
* Check if the specified function is an NVM function and if it is, then
* instantiate NVM function data for the slave and read all objects.
*/
static int bif_initialize_nvm_function(struct bif_slave_dev *sdev,
struct bif_ddb_l2_data *func)
{
int rc = 0;
int data_len, read_size;
u8 buf[8], object_type;
struct bif_object *object;
struct bif_object *temp;
u16 addr;
u16 crc;
/* Ensure that this is an NVM function. */
if (func->function_type != BIF_FUNC_NVM)
return 0;
if (sdev->nvm_function) {
pr_err("Duplicate NVM function found for BIF slave; DEV_ADR=0x%02X\n",
sdev->slave_addr);
return -EPERM;
}
sdev->nvm_function
= kzalloc(sizeof(*sdev->nvm_function), GFP_KERNEL);
if (!sdev->nvm_function) {
pr_err("out of memory\n");
return -ENOMEM;
}
rc = _bif_slave_read(sdev, func->function_pointer, buf, 8);
if (rc) {
pr_err("NVM function data read failed, rc=%d\n", rc);
return rc;
}
sdev->nvm_function->nvm_pointer = buf[0] << 8 | buf[1];
sdev->nvm_function->slave_control_channel = buf[2];
sdev->nvm_function->write_buffer_size = buf[3];
sdev->nvm_function->nvm_base_address = buf[4] << 8 | buf[5];
sdev->nvm_function->nvm_size = buf[6] << 8 | buf[7];
/* Read NVM lock offset */
rc = _bif_slave_read(sdev, sdev->nvm_function->nvm_pointer, buf, 2);
if (rc) {
pr_err("Slave memory read failed, rc=%d\n", rc);
return rc;
}
sdev->nvm_function->nvm_lock_offset = buf[0] << 8 | buf[1];
INIT_LIST_HEAD(&sdev->nvm_function->object_list);
/* Read object list */
addr = sdev->nvm_function->nvm_base_address;
rc = _bif_slave_read(sdev, addr, &object_type, 1);
if (rc) {
pr_err("Slave memory read failed, rc=%d\n", rc);
return rc;
}
while (object_type != BIF_OBJ_END_OF_LIST) {
object = kzalloc(sizeof(*object), GFP_KERNEL);
if (!object) {
pr_err("out of memory\n");
rc = -ENOMEM;
goto free_data;
}
list_add_tail(&object->list, &sdev->nvm_function->object_list);
rc = _bif_slave_read(sdev, addr + 1, buf + 1, 5);
if (rc) {
pr_err("Slave memory read of object header failed; addr=0x%04X, len=%d, rc=%d\n",
addr + 1, 5, rc);
goto free_data;
}
object->addr = addr;
object->type = object_type;
object->version = buf[1];
object->manufacturer_id = buf[2] << 8 | buf[3];
object->length = buf[4] << 8 | buf[5];
if ((object->addr + object->length)
> (sdev->nvm_function->nvm_base_address
+ sdev->nvm_function->nvm_size)) {
pr_warn("warning: BIF slave object is not formatted correctly; NVM base=0x%04X, NVM len=%d, object addr=0x%04X, object len=%d\n",
sdev->nvm_function->nvm_base_address,
sdev->nvm_function->nvm_size,
object->addr,
object->length);
/* Limit object size to remaining NVM size. */
object->length = sdev->nvm_function->nvm_size
+ sdev->nvm_function->nvm_base_address
- object->addr;
}
/* Object header + CRC takes up 8 bytes. */
data_len = object->length - 8;
object->data = kmalloc(data_len, GFP_KERNEL);
if (!object->data) {
pr_err("out of memory\n");
rc = -ENOMEM;
goto free_data;
}
rc = _bif_slave_read(sdev, addr + 6, object->data, data_len);
if (rc) {
pr_err("Slave memory read of object data failed; addr=0x%04X, len=%d, rc=%d\n",
addr + 6, data_len, rc);
goto free_data;
}
if ((object->length + addr) >= (sdev->nvm_function->nvm_size
+ sdev->nvm_function->nvm_base_address))
read_size = 2;
else
read_size = 3;
rc = _bif_slave_read(sdev, addr + 6 + data_len, buf, read_size);
if (rc) {
pr_err("Slave memory read of object CRC failed; addr=0x%04X, len=%d, rc=%d\n",
addr + 6 + data_len, read_size, rc);
goto free_data;
}
object->crc = buf[0] << 8 | buf[1];
object_type = (read_size == 3) ? buf[2] : BIF_OBJ_END_OF_LIST;
sdev->nvm_function->object_count++;
crc = bif_object_crc_ccitt(object);
if (crc != object->crc)
pr_info("BIF object at addr=0x%04X has invalid CRC; crc calc=0x%04X, crc exp=0x%04X\n",
object->addr, crc, object->crc);
addr += object->length;
}
return rc;
free_data:
list_for_each_entry_safe(object, temp,
&sdev->nvm_function->object_list, list) {
list_del(&object->list);
kfree(object->data);
kfree(object);
}
kfree(sdev->nvm_function);
sdev->nvm_function = NULL;
return rc;
}
static int bif_parse_slave_data(struct bif_slave_dev *sdev)
{
int rc = 0;
u8 buf[10];
u8 *func_buf;
struct bif_ddb_l2_data *func;
int function_count, i;
rc = _bif_slave_read(sdev, BIF_DDB_L1_BASE_ADDR, buf, 10);
if (rc) {
pr_err("DDB L1 data read failed, rc=%d\n", rc);
return rc;
}
sdev->l1_data.revision = buf[0];
sdev->l1_data.level = buf[1];
sdev->l1_data.device_class = buf[2] << 8 | buf[3];
sdev->l1_data.manufacturer_id = buf[4] << 8 | buf[5];
sdev->l1_data.product_id = buf[6] << 8 | buf[7];
sdev->l1_data.length = buf[8] << 8 | buf[9];
function_count = sdev->l1_data.length / 4;
if (sdev->l1_data.length % 4) {
pr_err("Function directory length=%d is invalid\n",
sdev->l1_data.length);
return -EPROTO;
}
/* No DDB L2 function directory */
if (function_count == 0)
return 0;
func_buf = kmalloc(sdev->l1_data.length, GFP_KERNEL);
if (!func_buf) {
pr_err("out of memory\n");
return -ENOMEM;
}
sdev->function_directory = kzalloc(
function_count * sizeof(struct bif_ddb_l2_data), GFP_KERNEL);
if (!sdev->function_directory) {
pr_err("out of memory\n");
return -ENOMEM;
}
rc = _bif_slave_read(sdev, BIF_DDB_L2_BASE_ADDR, func_buf,
sdev->l1_data.length);
if (rc) {
pr_err("DDB L2 data read failed, rc=%d\n", rc);
return rc;
}
for (i = 0; i < function_count; i++) {
func = &sdev->function_directory[i];
func->function_type = func_buf[i * 4];
func->function_version = func_buf[i * 4 + 1];
func->function_pointer = func_buf[i * 4 + 2] << 8
| func_buf[i * 4 + 3];
rc = bif_initialize_protocol_function(sdev, func);
if (rc)
goto done;
rc = bif_initialize_slave_control_function(sdev, func);
if (rc)
goto done;
rc = bif_initialize_nvm_function(sdev, func);
if (rc)
goto done;
}
done:
kfree(func_buf);
return rc;
}
static int bif_add_secondary_slaves(struct bif_slave_dev *primary_slave)
{
int rc = 0;
int data_len, i;
u16 crc;
struct bif_slave_dev *sdev;
struct bif_object *object;
list_for_each_entry(object, &primary_slave->nvm_function->object_list,
list) {
if (object->type != BIF_OBJ_SEC_SLAVE)
continue;
data_len = object->length - 8;
if (data_len % BIF_UNIQUE_ID_BYTE_LENGTH) {
pr_info("Invalid secondary slave object found, addr=0x%04X, data len=%d\n",
object->addr, data_len);
continue;
}
crc = bif_object_crc_ccitt(object);
if (crc != object->crc) {
pr_info("BIF object at addr=0x%04X has invalid CRC; crc calc=0x%04X, crc exp=0x%04X\n",
object->addr, crc, object->crc);
continue;
}
for (i = 0; i < data_len / BIF_UNIQUE_ID_BYTE_LENGTH; i++) {
sdev = bif_add_slave(primary_slave->bdev);
if (IS_ERR(sdev)) {
rc = PTR_ERR(sdev);
pr_err("bif_add_slave failed, rc=%d\n", rc);
return rc;
}
memcpy(sdev->unique_id,
&object->data[i * BIF_UNIQUE_ID_BYTE_LENGTH],
BIF_UNIQUE_ID_BYTE_LENGTH);
sdev->unique_id_bits_known = BIF_UNIQUE_ID_BIT_LENGTH;
rc = bif_select_slave(sdev);
if (rc) {
pr_err("Could not select slave, rc=%d\n", rc);
goto free_slave;
}
rc = bif_is_slave_selected(sdev->bdev);
if (rc < 0) {
pr_err("Transaction failed, rc=%d\n", rc);
goto free_slave;
} else if (rc == 1) {
sdev->present = true;
sdev->bdev->selected_sdev = sdev;
rc = bif_parse_slave_data(sdev);
if (rc) {
pr_err("Failed to parse secondary slave data, rc=%d\n",
rc);
goto free_slave;
}
} else {
sdev->present = false;
sdev->bdev->selected_sdev = NULL;
}
}
}
return rc;
free_slave:
bif_remove_slave(sdev);
return rc;
}
/*
* Performs UID search to identify all slaves attached to the bus. Assumes that
* all necessary locks are held.
*/
static int bif_perform_uid_search(struct bif_ctrl_dev *bdev)
{
struct bif_slave_dev *sdev;
struct bif_slave_dev *new_slave;
bool resp[2], resp_dilc;
int i;
int rc = 0;
u8 cmd_probe[2] = {BIF_CMD_DIP0, BIF_CMD_DIP1};
u8 cmd_enter[2] = {BIF_CMD_DIE0, BIF_CMD_DIE1};
/*
* Iterate over all partially known UIDs adding new ones as they are
* found.
*/
list_for_each_entry(sdev, &bif_sdev_list, list) {
/* Skip slaves with fully known UIDs. */
if (sdev->unique_id_bits_known == BIF_UNIQUE_ID_BIT_LENGTH
|| sdev->bdev != bdev)
continue;
/* Begin a new UID search. */
rc = bdev->desc->ops->bus_transaction(bdev, BIF_TRANS_BC,
BIF_CMD_DISS);
if (rc) {
pr_err("bus_transaction failed, rc=%d\n", rc);
return rc;
}
/* Step through all known UID bits (MSB to LSB). */
for (i = 0; i < sdev->unique_id_bits_known; i++) {
rc = bdev->desc->ops->bus_transaction(bdev,
BIF_TRANS_BC,
cmd_enter[get_uid_bit(sdev->unique_id, i)]);
if (rc) {
pr_err("bus_transaction failed, rc=%d\n", rc);
return rc;
}
}
/* Step through unknown UID bits. */
for (i = sdev->unique_id_bits_known;
i < BIF_UNIQUE_ID_BIT_LENGTH; i++) {
rc = bdev->desc->ops->bus_transaction_query(bdev,
BIF_TRANS_BC, cmd_probe[0], &resp[0]);
if (rc) {
pr_err("bus_transaction failed, rc=%d\n", rc);
return rc;
}
rc = bdev->desc->ops->bus_transaction_query(bdev,
BIF_TRANS_BC, cmd_probe[1], &resp[1]);
if (rc) {
pr_err("bus_transaction failed, rc=%d\n", rc);
return rc;
}
if (resp[0] && resp[1]) {
/* Create an entry for the new UID branch. */
new_slave = bif_add_slave(bdev);
if (IS_ERR(new_slave)) {
rc = PTR_ERR(sdev);
pr_err("bif_add_slave failed, rc=%d\n",
rc);
return rc;
}
memcpy(new_slave->unique_id, sdev->unique_id,
BIF_UNIQUE_ID_BYTE_LENGTH);
new_slave->bdev = sdev->bdev;
set_uid_bit(sdev->unique_id, i, 0);
sdev->unique_id_bits_known = i + 1;
set_uid_bit(new_slave->unique_id, i, 1);
new_slave->unique_id_bits_known = i + 1;
} else if (resp[0]) {
set_uid_bit(sdev->unique_id, i, 0);
sdev->unique_id_bits_known = i + 1;
} else if (resp[1]) {
set_uid_bit(sdev->unique_id, i, 1);
sdev->unique_id_bits_known = i + 1;
} else {
pr_debug("no bus query response received\n");
rc = -ENXIO;
return rc;
}
rc = bdev->desc->ops->bus_transaction(bdev,
BIF_TRANS_BC, cmd_enter[resp[0] ? 0 : 1]);
if (rc) {
pr_err("bus_transaction failed, rc=%d\n", rc);
return rc;
}
}
rc = bdev->desc->ops->bus_transaction_query(bdev,
BIF_TRANS_BC, BIF_CMD_DILC, &resp_dilc);
if (rc) {
pr_err("bus_transaction failed, rc=%d\n", rc);
return rc;
}
if (resp_dilc) {
sdev->present = true;
sdev->bdev->selected_sdev = sdev;
rc = bif_parse_slave_data(sdev);
if (rc) {
pr_err("Failed to parse secondary slave data, rc=%d\n",
rc);
return rc;
}
} else {
pr_err("Slave failed to respond to DILC bus command; its UID is thus unverified.\n");
sdev->unique_id_bits_known = 0;
rc = -ENXIO;
return rc;
}
}
return rc;
}
/*
* Removes slaves from the bif_sdev_list which have the same UID as previous
* slaves in the list.
*/
static int bif_remove_duplicate_slaves(struct bif_ctrl_dev *bdev)
{
struct bif_slave_dev *sdev;
struct bif_slave_dev *last_slave;
struct bif_slave_dev *temp;
list_for_each_entry_safe(last_slave, temp, &bif_sdev_list, list) {
list_for_each_entry(sdev, &bif_sdev_list, list) {
if (last_slave == sdev) {
break;
} else if (memcmp(last_slave->unique_id,
sdev->unique_id,
BIF_UNIQUE_ID_BYTE_LENGTH) == 0) {
bif_remove_slave(last_slave);
break;
}
}
}
return 0;
}
static int bif_add_all_slaves(struct bif_ctrl_dev *bdev)
{
struct bif_slave_dev *sdev;
int rc = 0;
int i;
bool has_slave = false, is_primary_slave = false;
mutex_lock(&bif_sdev_list_mutex);
mutex_lock(&bdev->mutex);
list_for_each_entry(sdev, &bif_sdev_list, list) {
if (sdev->bdev == bdev) {
has_slave = true;
break;
}
}
if (!has_slave) {
/* Create a single empty slave to start the search algorithm. */
sdev = bif_add_slave(bdev);
if (IS_ERR(sdev)) {
rc = PTR_ERR(sdev);
pr_err("bif_add_slave failed, rc=%d\n", rc);
goto out;
}
for (i = 0; i < BIF_TRANSACTION_RETRY_COUNT; i++) {
/* Attempt to select primary slave in battery pack. */
rc = bdev->desc->ops->bus_transaction(bdev,
BIF_TRANS_SDA, BIF_PRIMARY_SLAVE_DEV_ADR);
if (rc == 0)
break;
}
if (rc) {
pr_err("BIF bus_transaction failed, rc=%d\n", rc);
goto out;
}
/* Check if a slave is selected. */
rc = bif_is_slave_selected(bdev);
if (rc < 0) {
pr_err("BIF bus_transaction failed, rc=%d\n", rc);
goto out;
} else {
is_primary_slave = rc;
}
}
if (is_primary_slave) {
pr_debug("Using primary slave at DEV_ADR==0x%02X\n",
BIF_PRIMARY_SLAVE_DEV_ADR);
sdev->bdev->selected_sdev = sdev;
sdev->present = true;
sdev->slave_addr = BIF_PRIMARY_SLAVE_DEV_ADR;
rc = bif_parse_slave_data(sdev);
if (rc) {
pr_err("Failed to parse primary slave data, rc=%d\n",
rc);
goto out;
}
rc = bif_add_secondary_slaves(sdev);
if (rc) {
pr_err("Failed to add secondary slaves, rc=%d\n", rc);
goto out;
}
} else {
pr_debug("Falling back on full UID search.\n");
for (i = 0; i < BIF_TRANSACTION_RETRY_COUNT; i++) {
rc = bif_perform_uid_search(bdev);
if (rc == 0)
break;
}
if (rc) {
pr_debug("BIF UID search failed, rc=%d\n", rc);
goto out;
}
}
bif_remove_duplicate_slaves(bdev);
mutex_unlock(&bdev->mutex);
mutex_unlock(&bif_sdev_list_mutex);
return rc;
out:
mutex_unlock(&bdev->mutex);
mutex_unlock(&bif_sdev_list_mutex);
pr_debug("BIF slave search failed, rc=%d\n", rc);
return rc;
}
static int bif_add_known_slave(struct bif_ctrl_dev *bdev, u8 slave_addr)
{
struct bif_slave_dev *sdev;
int rc = 0;
int i;
for (i = 0; i < BIF_TRANSACTION_RETRY_COUNT; i++) {
/* Attempt to select the slave. */
rc = bdev->desc->ops->bus_transaction(bdev, BIF_TRANS_SDA,
slave_addr);
if (rc == 0)
break;
}
if (rc) {
pr_err("BIF bus_transaction failed, rc=%d\n", rc);
return rc;
}
/* Check if a slave is selected. */
rc = bif_is_slave_selected(bdev);
if (rc < 0) {
pr_err("BIF bus_transaction failed, rc=%d\n", rc);
return rc;
}
sdev = bif_add_slave(bdev);
if (IS_ERR(sdev)) {
rc = PTR_ERR(sdev);
pr_err("bif_add_slave failed, rc=%d\n", rc);
return rc;
}
sdev->bdev->selected_sdev = sdev;
sdev->present = true;
sdev->slave_addr = slave_addr;
rc = bif_parse_slave_data(sdev);
if (rc) {
pr_err("Failed to parse slave data, addr=0x%02X, rc=%d\n",
slave_addr, rc);
return rc;
}
return rc;
}
static int bif_add_known_slaves_from_dt(struct bif_ctrl_dev *bdev,
struct device_node *of_node)
{
int len = 0;
int rc, i;
u32 addr;
const __be32 *val;
mutex_lock(&bif_sdev_list_mutex);
mutex_lock(&bdev->mutex);
val = of_get_property(of_node, "qcom,known-device-addresses", &len);
len /= sizeof(u32);
if (val && len == 0) {
pr_err("qcom,known-device-addresses property is invalid\n");
rc = -EINVAL;
goto out;
}
for (i = 0; i < len; i++) {
addr = be32_to_cpup(val++);
if (addr == 0x00 || addr > 0xFF) {
rc = -EINVAL;
pr_err("qcom,known-device-addresses property contains invalid address=0x%X\n",
addr);
goto out;
}
rc = bif_add_known_slave(bdev, addr);
if (rc) {
pr_err("bif_add_known_slave() failed, rc=%d\n", rc);
goto out;
}
}
out:
if (len > 0)
bif_remove_duplicate_slaves(bdev);
mutex_unlock(&bdev->mutex);
mutex_unlock(&bif_sdev_list_mutex);
return rc;
}
/*
* Programs a device address for the specified slave in order to simplify
* slave selection in the future.
*/
static int bif_assign_slave_dev_addr(struct bif_slave_dev *sdev, u8 dev_addr)
{
int rc;
u16 addr;
if (!sdev->protocol_function) {
pr_err("Protocol function not present; cannot set device address.\n");
return -ENODEV;
}
addr = PROTOCOL_FUNC_DEV_ADR_ADDR(
sdev->protocol_function->protocol_pointer);
rc = _bif_slave_write(sdev, addr, &dev_addr, 1);
if (rc)
pr_err("Failed to set slave device address.\n");
else
sdev->slave_addr = dev_addr;
return rc;
}
/* Assigns a unique device address to all slaves which do not have one. */
static int bif_assign_all_slaves_dev_addr(struct bif_ctrl_dev *bdev)
{
struct bif_slave_dev *sdev;
struct bif_slave_dev *sibling;
bool duplicate;
int rc = 0;
u8 dev_addr, first_dev_addr;
mutex_lock(&bif_sdev_list_mutex);
mutex_lock(&bdev->mutex);
first_dev_addr = next_dev_addr;
/*
* Iterate over all partially known UIDs adding new ones as they are
* found.
*/
list_for_each_entry(sdev, &bif_sdev_list, list) {
/*
* Skip slaves without known UIDs, which already have a device
* address or which aren't present.
*/
if (sdev->unique_id_bits_known != BIF_UNIQUE_ID_BIT_LENGTH
|| sdev->slave_addr != 0x00 || !sdev->present)
continue;
do {
dev_addr = next_dev_addr;
duplicate = false;
list_for_each_entry(sibling, &bif_sdev_list, list) {
if (sibling->slave_addr == dev_addr) {
duplicate = true;
break;
}
}
next_dev_addr = dev_addr + 1;
} while (duplicate && (next_dev_addr != first_dev_addr));
if (next_dev_addr == first_dev_addr) {
pr_err("No more BIF slave device addresses available.\n");
rc = -ENODEV;
goto out;
}
rc = bif_assign_slave_dev_addr(sdev, dev_addr);
if (rc) {
pr_err("Failed to set slave address.\n");
goto out;
}
}
mutex_unlock(&bdev->mutex);
mutex_unlock(&bif_sdev_list_mutex);
return rc;
out:
mutex_unlock(&bdev->mutex);
mutex_unlock(&bif_sdev_list_mutex);
pr_err("BIF slave device address setting failed, rc=%d\n", rc);
return rc;
}
/**
* bdev_get_drvdata() - get the private BIF controller driver data
* @bdev: BIF controller device pointer
*/
void *bdev_get_drvdata(struct bif_ctrl_dev *bdev)
{
return bdev->driver_data;
}
EXPORT_SYMBOL(bdev_get_drvdata);
static const char * const battery_label[] = {
"unknown",
"none",
"special 1",
"special 2",
"special 3",
"low cost",
"smart",
};
static const char *bif_get_battery_pack_type(int rid_ohm)
{
const char *label = battery_label[0];
if (rid_ohm > BIF_BATT_RID_SMART_MAX)
label = battery_label[1];
else if (rid_ohm >= BIF_BATT_RID_SMART_MIN)
label = battery_label[6];
else if (rid_ohm >= BIF_BATT_RID_LOW_COST_MIN
&& rid_ohm <= BIF_BATT_RID_LOW_COST_MAX)
label = battery_label[5];
else if (rid_ohm >= BIF_BATT_RID_SPECIAL3_MIN
&& rid_ohm <= BIF_BATT_RID_SPECIAL3_MAX)
label = battery_label[4];
else if (rid_ohm >= BIF_BATT_RID_SPECIAL2_MIN
&& rid_ohm <= BIF_BATT_RID_SPECIAL2_MAX)
label = battery_label[3];
else if (rid_ohm >= BIF_BATT_RID_SPECIAL1_MIN
&& rid_ohm <= BIF_BATT_RID_SPECIAL1_MAX)
label = battery_label[2];
return label;
}
/**
* bif_ctrl_register() - register a BIF controller with the BIF framework
* @bif_desc: Pointer to BIF controller descriptor
* @dev: Device pointer of the BIF controller
* @driver_data: Private driver data to associate with the BIF controller
* @of_node Pointer to the device tree node of the BIF controller
*
* Returns a BIF controller device pointer for the controller if registration
* is successful or an ERR_PTR if an error occurred.
*/
struct bif_ctrl_dev *bif_ctrl_register(struct bif_ctrl_desc *bif_desc,
struct device *dev, void *driver_data, struct device_node *of_node)
{
struct bif_ctrl_dev *bdev = ERR_PTR(-EINVAL);
struct bif_slave_dev *sdev;
bool battery_present = false;
bool slaves_present = false;
int rc, rid_ohm;
if (!bif_desc) {
pr_err("Invalid bif_desc specified\n");
return bdev;
} else if (!bif_desc->name) {
pr_err("BIF name missing\n");
return bdev;
} else if (!bif_desc->ops) {
pr_err("BIF operations missing\n");
return bdev;
} else if (!bif_desc->ops->bus_transaction
|| !bif_desc->ops->bus_transaction_query
|| !bif_desc->ops->bus_transaction_read
|| !bif_desc->ops->get_bus_state
|| !bif_desc->ops->set_bus_state) {
pr_err("BIF operation callback function(s) missing\n");
return bdev;
}
bdev = kzalloc(sizeof(struct bif_ctrl_dev), GFP_KERNEL);
if (bdev == NULL) {
pr_err("Memory allocation failed for bif_ctrl_dev\n");
return ERR_PTR(-ENOMEM);
}
mutex_init(&bdev->mutex);
INIT_LIST_HEAD(&bdev->list);
INIT_DELAYED_WORK(&bdev->enter_irq_mode_work, bif_enter_irq_mode_work);
bdev->desc = bif_desc;
bdev->ctrl_dev = dev;
bdev->driver_data = driver_data;
bdev->irq_mode_delay_jiffies = 2;
mutex_lock(&bif_ctrl_list_mutex);
list_add_tail(&bdev->list, &bif_ctrl_list);
mutex_unlock(&bif_ctrl_list_mutex);
rc = bif_add_all_slaves(bdev);
if (rc)
pr_debug("Search for all slaves failed, rc=%d\n", rc);
rc = bif_add_known_slaves_from_dt(bdev, of_node);
if (rc)
pr_err("Adding slaves based on device tree addressed failed, rc=%d.\n",
rc);
rc = bif_assign_all_slaves_dev_addr(bdev);
if (rc)
pr_err("Failed to set slave device address, rc=%d\n", rc);
bif_print_slaves();
if (bdev->desc->ops->get_battery_presence) {
rc = bdev->desc->ops->get_battery_presence(bdev);
if (rc < 0) {
pr_err("Could not determine battery presence, rc=%d\n",
rc);
} else {
battery_present = rc;
pr_info("Battery pack present = %c\n", rc ? 'Y' : 'N');
}
}
if (bdev->desc->ops->get_battery_rid) {
rid_ohm = bdev->desc->ops->get_battery_rid(bdev);
if (rid_ohm >= 0)
pr_info("Battery pack type = %s (Rid=%d ohm)\n",
bif_get_battery_pack_type(rid_ohm), rid_ohm);
else
pr_err("Could not read Rid, rc=%d\n", rid_ohm);
}
list_for_each_entry(sdev, &bif_sdev_list, list) {
if (sdev->present) {
battery_present = true;
slaves_present = true;
break;
}
}
BLOCKING_INIT_NOTIFIER_HEAD(&bdev->bus_change_notifier);
/* Disable the BIF bus master if no slaves are found. */
if (!slaves_present) {
rc = bdev->desc->ops->set_bus_state(bdev,
BIF_BUS_STATE_MASTER_DISABLED);
if (rc < 0)
pr_err("Could not disble BIF master, rc=%d\n", rc);
}
if (battery_present) {
bdev->battery_present = true;
rc = blocking_notifier_call_chain(&bdev->bus_change_notifier,
BIF_BUS_EVENT_BATTERY_INSERTED, bdev);
if (rc)
pr_err("Call chain noification failed, rc=%d\n", rc);
}
return bdev;
}
EXPORT_SYMBOL(bif_ctrl_register);
/**
* bif_ctrl_unregister() - unregisters a BIF controller
* @bdev: BIF controller device pointer
*/
void bif_ctrl_unregister(struct bif_ctrl_dev *bdev)
{
if (bdev) {
mutex_lock(&bif_ctrl_list_mutex);
list_del(&bdev->list);
mutex_unlock(&bif_ctrl_list_mutex);
}
}
EXPORT_SYMBOL(bif_ctrl_unregister);
Reference in a new issue View git blame Copy permalink