/**
* spmi_register_board_info: Board-initialization routine.
* @bus_num: controller number (bus) on which this device will sit.
* @info: list of all devices on all controllers present on the board.
* @n: number of entries.
* API enumerates respective devices on corresponding controller.
* Called from board-init function.
* If controller is not present, only add to boards list
*/
int spmi_register_board_info(int busnum,
struct spmi_boardinfo const *info, unsigned n)
{
int i;
struct spmii_boardinfo *bi;
struct spmi_controller *ctrl;
bi = kzalloc(n * sizeof(*bi), GFP_KERNEL);
if (!bi)
return -ENOMEM;
ctrl = spmi_busnum_to_ctrl(busnum);
for (i = 0; i < n; i++, bi++, info++) {
memcpy(&bi->board_info, info, sizeof(*info));
mutex_lock(&board_lock);
list_add_tail(&bi->list, &board_list);
if (ctrl)
spmi_match_ctrl_to_boardinfo(ctrl, &bi->board_info);
mutex_unlock(&board_lock);
}
return 0;
}
/* Validate the SPMI device structure */
static struct device *get_valid_device(struct spmi_device *spmidev)
{
struct device *dev;
if (!spmidev)
return NULL;
dev = &spmidev->dev;
if (dev->bus != &spmi_bus_type || dev->type != &spmi_dev_type)
return NULL;
if (!spmidev->ctrl || !spmi_busnum_to_ctrl(spmidev->ctrl->nr))
return NULL;
return dev;
}
static void spmi_write(u8 value)
{
struct spmi_controller *ctrl = spmi_busnum_to_ctrl(0);
int ret = 0;
u16 addr = 0x0000;
u8 write_buf = 0x0;
u8 read_buf = 0x0;
addr = 0xdc46;
write_buf = value;
if (ctrl == NULL) {
HSD_ERR("spmi_write: spmi_controller is NULL!\n");
return;
}
ret = spmi_ext_register_writel(ctrl, 0, addr, &write_buf,1);
spmi_ext_register_readl(ctrl, 0, addr,&read_buf,1);
HSD_DBG("addr:%x,write_buf:%x,read_buf:%x,ret:%d\n",addr, write_buf,read_buf,ret);
}
/**
* spmi_alloc_device: Allocate a new SPMI devices.
* @ctrl: controller to which this device is to be added to.
* Context: can sleep
*
* Allows a driver to allocate and initialize a SPMI device without
* registering it immediately. This allows a driver to directly fill
* the spmi_device structure before calling spmi_add_device().
*
* Caller is responsible to call spmi_add_device() on the returned
* spmi_device. If the caller needs to discard the spmi_device without
* adding it, then spmi_dev_put() should be called.
*/
struct spmi_device *spmi_alloc_device(struct spmi_controller *ctrl)
{
struct spmi_device *spmidev;
if (!ctrl || !spmi_busnum_to_ctrl(ctrl->nr)) {
pr_err("Missing SPMI controller\n");
return NULL;
}
spmidev = kzalloc(sizeof(*spmidev), GFP_KERNEL);
if (!spmidev) {
dev_err(&ctrl->dev, "unable to allocate spmi_device\n");
return NULL;
}
spmidev->ctrl = ctrl;
spmidev->dev.parent = ctrl->dev.parent;
spmidev->dev.bus = &spmi_bus_type;
spmidev->dev.type = &spmi_dev_type;
device_initialize(&spmidev->dev);
return spmidev;
}