/* AP sends msgs to LPM3 for adc sampling&converting. */
static int adc_send_ipc_to_lpm3(int channel)
{
struct hisi_mbox_task *adc_tx_task;
int loop = ADC_IPC_MAX_CNT;
int ret = 0;
if (channel > ADC_CHN_MAX) {
pr_err("%s: invalid channel!\n", MODULE_NAME);
ret = -EINVAL;
goto err_adc_channel;
}
if (!hisi_adc_dev) {
pr_err("%s: adc dev is not initialized yet!\n", MODULE_NAME);
ret = -ENODEV;
goto err_adc_dev;
}
if (hisi_adc_dev->tx_msg[ADC_IPC_CMD_TYPE] != ADC_IPC_DATA)
hisi_adc_dev->tx_msg[ADC_IPC_CMD_TYPE] = ADC_IPC_DATA;
hisi_adc_dev->info.channel = channel;
hisi_adc_dev->tx_msg[ADC_IPC_CMD_CHANNEL] = channel;
adc_tx_task = hisi_mbox_task_alloc(hisi_adc_dev->mbox, HISI_MAILBOX_RP_LPM3, hisi_adc_dev->tx_msg,
ADC_IPC_CMD_LEN, 1, adc_complete_func, NULL);
if (!adc_tx_task) {
pr_err("%s: fail to alloc mbox task!\n", MODULE_NAME);
ret = -ENOMEM;
goto err_alloc_task;
}
do {
ret = hisi_mbox_msg_send_async(hisi_adc_dev->mbox, adc_tx_task);
loop--;
} while (ret == -ENOMEM && loop > 0);
if (ret) {
pr_err("%s: fail to send mbox msg, ret = %d!\n", MODULE_NAME, ret);
goto err_msg_async;
}
return ret;
err_msg_async:
hisi_mbox_task_free(&adc_tx_task);
err_alloc_task:
hisi_adc_dev->info.channel = ADC_RESULT_ERR;
err_adc_dev:
err_adc_channel:
return ret;
}
static int hisi_clkmbox_send_ipc(mbox_msg_t *msg, void *context, int autoack)
{
struct hisi_mbox_task *tx_task;
int loop = MAX_SEND_IPC_TRY;
mbox_msg_t *tx_msg;
int ret, i;
tx_msg = kzalloc(sizeof(mbox_msg_t) * LPM3_CMD_LEN, GFP_ATOMIC);
if (!tx_msg) {
pr_err("[%s] fail to alloc tx_msg!\n", __func__);
ret = -ENOMEM;
goto err;
}
/* construct cmd */
for (i = 0; i < LPM3_CMD_LEN; i++) {
tx_msg[i] = msg[i];
pr_debug("[%s] tx_msg[i] = 0x%x\n", __func__, tx_msg[i]);
}
tx_task = hisi_mbox_task_alloc(mbox_clk->mbox, HISI_MAILBOX_RP_LPM3,
tx_msg, LPM3_CMD_LEN, autoack, hisi_clkmbox_default_complete, context);
if (!tx_task) {
pr_err("[%s] fail to alloc mbox task!\n", __func__);
ret = -ENOMEM;
goto err_task;
}
/* try again if failing to send */
do {
ret = hisi_mbox_msg_send_async(mbox_clk->mbox, tx_task);
loop--;
} while (ret == -ENOMEM && loop > 0);
if (ret) {
pr_err("[%s] fail to send mbox msg, ret = %d!\n",
__func__, ret);
goto err_snd_async;
}
return 0;
err_snd_async:
hisi_mbox_task_free(&tx_task);
err_task:
kfree(tx_msg);
tx_msg = NULL;
err:
return ret;
}
static void mbox_debugfs_send_work(struct work_struct *work)
{
struct mbox_info *mbox_info =
container_of(work, struct mbox_info, work);
struct mbox_task *task_info = NULL;
struct hisi_mbox_task *tx_task = NULL;
int i = 0;
int time = debugfs_ipc_times;
while (time) {
pr_info("%s debugfs msg send NO.%d\n",
mbox_info->mbox->tx->name, ++i);
task_info = kmalloc(sizeof(*task_info), GFP_KERNEL);
if (!task_info)
continue;
task_info->mbox_index = mbox_info->index;
task_info->mail_index = i;
tx_task = mbox_debugfs_get_task(mbox_info->mbox,
mbox_info->msg,
mbox_info->len,
mbox_info->rp_name,
task_info);
if (!tx_task) {
msleep(100);
continue;
}
if (hisi_mbox_msg_send_async(mbox_info->mbox, tx_task)) {
kfree(task_info->tx_buffer);
kfree(task_info);
hisi_mbox_task_free(&tx_task);
if (i == debugfs_ipc_times) {
debugfs_ipc_times -= 1;
break;
}
msleep(100);
}
time--;
}
return;
}
void boot_iom3(void)
{
struct hisi_mbox_task *tx_task = NULL;
if (!(lpm3_mbox = hisi_mbox_get(HISI_MAILBOX_RP_LPM3, NULL))) {
hwlog_err("failed to get mailbox in %s\n", __func__);
return;
}
tx_task = hisi_mbox_task_alloc(lpm3_mbox,
HISI_MAILBOX_RP_LPM3,
&g_boot_iom3,
1,
1,
inputhub_power_on_complete,
NULL);
if(!tx_task) {
hwlog_err("failed to alloc task %s\n", __func__);
return;
}
if (hisi_mbox_msg_send_async(lpm3_mbox,tx_task) != 0) {
hwlog_err("hisi_mbox_msg_send_async error in %s\n", __func__);
}
}
int inputhub_mcu_send(const char *buf, unsigned long length)
{
struct hisi_mbox_task *tx_task = NULL;
mbox_msg_t *tx_buffer = NULL;
mbox_msg_len_t len=0;
int i = 0;
int ret = -1;
if(NULL==mbox)
inputhub_mcu_connect();
if(NULL==mbox)
return ret;
len = (length + sizeof(mbox_msg_t) - 1) / (sizeof(mbox_msg_t));
//todo:send 256 bytes max one time, and repeat until buf was sent.
tx_buffer = (mbox_msg_t *)kmalloc(sizeof(mbox_msg_t)*len, GFP_KERNEL);
if (!tx_buffer)
return ret;
memcpy(tx_buffer, buf, length);
pr_debug("inputhub_mcu_send------------->length = %d, len = %d\n", (int)length, (int)len);
for (i = 0; i < len; i++)
pr_debug("tx_buffer[%d] = 0x%x\n", i, tx_buffer[i]);
tx_task = hisi_mbox_task_alloc(mbox,
HISI_MAILBOX_RP_IOM3,
tx_buffer,
len,
0,
inputhub_mcu_send_complete,
NULL);
if (!tx_task) {
kfree((void *)tx_buffer);
return ret;
}
INIT_COMPLETION(send_complete);
ret=hisi_mbox_msg_send_async(mbox,tx_task);
if(ret)
{
hwlog_err("hisi_mbox_msg_send_async return %d.\n", ret);
if (tx_task->tx_buffer)
kfree((void *)tx_task->tx_buffer);
tx_task->tx_buffer = NULL;
hisi_mbox_task_free(&tx_task);
return -1;
}
wait_for_completion(&send_complete);
if ((-ETIMEOUT) == tx_task->tx_error) {
hwlog_err("send failed timeout\n");
if(!dsm_client_ocuppy(shb_dclient)){
dsm_client_record(shb_dclient, "IOM3RSTSTAT: 0x%x\n", read_reg32(IOM3RSTSTAT_ADDR));
dsm_client_record(shb_dclient, "PERRSTSTAT4: 0x%x\n", read_reg32(PERRSTSTAT4_ADDR));
dsm_client_record(shb_dclient, "PERSTAT5: 0x%x\n", read_reg32(PERSTAT5_ADDR));
dsm_client_record(shb_dclient, "IOM3CLKEN: 0x%x\n", read_reg32(IOM3CLKEN_ADDR));
dsm_client_notify(shb_dclient, DSM_SHB_ERR_IPC_TIMEOUT);
}
ret = -1;
}else{
hwlog_debug("send success\n");
ret = 0;
}
kfree((void *)tx_task->tx_buffer);
tx_task->tx_buffer = NULL;
hisi_mbox_task_free(&tx_task);
return ret;
}