evie/android_kernel_oneplus_msm8998
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

mhi: Use standard kernel return codes

Browse source 
Replace the MHI defined enum for return codes with
kernel standard return codes. This greatly improves readability
and parsing of errors by userspace clients.

Change-Id: Ica47f8c3a149f23243b5fb6a4aabcdc0a36b1535
Signed-off-by: Andrei Danaila <adanaila@codeaurora.org>
Signed-off-by: Tony Truong <truong@codeaurora.org>
This commit is contained in:
Tony Truong 2015-12-29 15:04:44 -08:00 • committed by David Keitel
parent c9ccb15704
commit a603bd09f9
15 changed files with 393 additions and 451 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

34
drivers/net/ethernet/msm/msm_rmnet_mhi.c
View file

@ -234,7 +234,7 @@ static int rmnet_mhi_poll(struct napi_struct *napi, int budget)
struct net_device *dev = napi->dev;
struct rmnet_mhi_private *rmnet_mhi_ptr =
*(struct rmnet_mhi_private **)netdev_priv(dev);
enum MHI_STATUS res = MHI_STATUS_reserved;
int res = 0;
bool should_reschedule = true;
struct sk_buff *skb;
struct mhi_skb_priv *skb_priv;
@ -245,12 +245,12 @@ static int rmnet_mhi_poll(struct napi_struct *napi, int budget)
while (received_packets < budget) {
struct mhi_result *result =
mhi_poll(rmnet_mhi_ptr->rx_client_handle);
if (result->transaction_status == MHI_STATUS_DEVICE_NOT_READY) {
if (result->transaction_status == -ENOTCONN) {
rmnet_log(MSG_INFO,
"Transaction status not ready, continuing\n");
break;
} else if (result->transaction_status != MHI_STATUS_SUCCESS &&
result->transaction_status != MHI_STATUS_OVERFLOW) {
} else if (result->transaction_status != 0 &&
result->transaction_status != -EOVERFLOW) {
rmnet_log(MSG_CRITICAL,
"mhi_poll failed, error %d\n",
result->transaction_status);
@ -280,7 +280,7 @@ static int rmnet_mhi_poll(struct napi_struct *napi, int budget)
skb->dev = dev;
skb->protocol = rmnet_mhi_ip_type_trans(skb);
if (result->transaction_status == MHI_STATUS_OVERFLOW)
if (result->transaction_status == -EOVERFLOW)
r = rmnet_mhi_process_fragment(rmnet_mhi_ptr, skb, 1);
else
r = rmnet_mhi_process_fragment(rmnet_mhi_ptr, skb, 0);
@ -326,7 +326,7 @@ static int rmnet_mhi_poll(struct napi_struct *napi, int budget)
rmnet_mhi_ptr->rx_client_handle,
skb->data, skb_priv->dma_size, MHI_EOT);
if (unlikely(MHI_STATUS_SUCCESS != res)) {
if (unlikely(0 != res)) {
rmnet_log(MSG_CRITICAL,
"mhi_queue_xfer failed, error %d", res);
dev_kfree_skb_irq(skb);
@ -395,7 +395,7 @@ static int rmnet_mhi_disable_channels(struct rmnet_mhi_private *rmnet_mhi_ptr)
static int rmnet_mhi_init_inbound(struct rmnet_mhi_private *rmnet_mhi_ptr)
{
u32 i;
enum MHI_STATUS res;
int res;
struct mhi_skb_priv *rx_priv;
u32 cur_mru = rmnet_mhi_ptr->mru;
struct sk_buff *skb;
@ -431,7 +431,7 @@ static int rmnet_mhi_init_inbound(struct rmnet_mhi_private *rmnet_mhi_ptr)
skb->data,
rx_priv->dma_size,
MHI_EOT);
if (MHI_STATUS_SUCCESS != res) {
if (0 != res) {
rmnet_log(MSG_CRITICAL,
"mhi_queue_xfer failed, error %d", res);
return -EIO;
@ -599,7 +599,7 @@ static int rmnet_mhi_xmit(struct sk_buff *skb, struct net_device *dev)
{
struct rmnet_mhi_private *rmnet_mhi_ptr =
*(struct rmnet_mhi_private **)netdev_priv(dev);
enum MHI_STATUS res = MHI_STATUS_reserved;
int res = 0;
unsigned long flags;
int retry = 0;
struct mhi_skb_priv *tx_priv;
@ -635,7 +635,7 @@ static int rmnet_mhi_xmit(struct sk_buff *skb, struct net_device *dev)
}
} while (retry);
if (MHI_STATUS_SUCCESS != res) {
if (0 != res) {
netif_stop_queue(dev);
rmnet_log(MSG_CRITICAL,
"mhi_queue_xfer failed, error %d\n", res);
@ -797,7 +797,7 @@ static int rmnet_mhi_enable_iface(struct rmnet_mhi_private *rmnet_mhi_ptr)
{
int ret = 0;
struct rmnet_mhi_private **rmnet_mhi_ctxt = NULL;
enum MHI_STATUS r = MHI_STATUS_SUCCESS;
int r = 0;
memset(tx_interrupts_count, 0, sizeof(tx_interrupts_count));
memset(rx_interrupts_count, 0, sizeof(rx_interrupts_count));
@ -828,7 +828,7 @@ static int rmnet_mhi_enable_iface(struct rmnet_mhi_private *rmnet_mhi_ptr)
rmnet_log(MSG_INFO,
"Opening TX channel\n");
r = mhi_open_channel(rmnet_mhi_ptr->tx_client_handle);
if (r != MHI_STATUS_SUCCESS) {
if (r != 0) {
rmnet_log(MSG_CRITICAL,
"Failed to start TX chan ret %d\n", r);
goto mhi_tx_chan_start_fail;
@ -840,7 +840,7 @@ static int rmnet_mhi_enable_iface(struct rmnet_mhi_private *rmnet_mhi_ptr)
rmnet_log(MSG_INFO,
"Opening RX channel\n");
r = mhi_open_channel(rmnet_mhi_ptr->rx_client_handle);
if (r != MHI_STATUS_SUCCESS) {
if (r != 0) {
rmnet_log(MSG_CRITICAL,
"Failed to start RX chan ret %d\n", r);
goto mhi_rx_chan_start_fail;
@ -907,7 +907,7 @@ static void rmnet_mhi_cb(struct mhi_cb_info *cb_info)
{
struct rmnet_mhi_private *rmnet_mhi_ptr;
struct mhi_result *result;
enum MHI_STATUS r = MHI_STATUS_SUCCESS;
int r = 0;
if (NULL != cb_info && NULL != cb_info->result) {
result = cb_info->result;
@ -978,7 +978,7 @@ static struct mhi_client_info_t rmnet_mhi_info = {rmnet_mhi_cb};
static int __init rmnet_mhi_init(void)
{
int i;
enum MHI_STATUS res = MHI_STATUS_SUCCESS;
int res = 0;
struct rmnet_mhi_private *rmnet_mhi_ptr = 0;
rmnet_ipc_log = ipc_log_context_create(RMNET_IPC_LOG_PAGES,
"mhi_rmnet", 0);
@ -1003,7 +1003,7 @@ static int __init rmnet_mhi_init(void)
rmnet_mhi_ptr->tx_channel, 0,
&rmnet_mhi_info, rmnet_mhi_ptr);
if (MHI_STATUS_SUCCESS != res) {
if (0 != res) {
rmnet_mhi_ptr->tx_client_handle = 0;
rmnet_log(MSG_CRITICAL,
"mhi_register_channel failed chan %d ret %d\n",
@ -1014,7 +1014,7 @@ static int __init rmnet_mhi_init(void)
rmnet_mhi_ptr->rx_channel, 0,
&rmnet_mhi_info, rmnet_mhi_ptr);
if (MHI_STATUS_SUCCESS != res) {
if (0 != res) {
rmnet_mhi_ptr->rx_client_handle = 0;
rmnet_log(MSG_CRITICAL,
"mhi_register_channel failed chan %d, ret %d\n",

37
drivers/platform/msm/mhi/mhi.h
View file

@ -553,21 +553,20 @@ struct mhi_data_buf {
irqreturn_t mhi_msi_ipa_handlr(int irq_number, void *dev_id);
int mhi_reset_all_thread_queues(
struct mhi_device_ctxt *mhi_dev_ctxt);
enum MHI_STATUS mhi_add_elements_to_event_rings(
int mhi_add_elements_to_event_rings(
struct mhi_device_ctxt *mhi_dev_ctxt,
enum STATE_TRANSITION new_state);
int get_nr_avail_ring_elements(struct mhi_ring *ring);
enum MHI_STATUS get_nr_enclosed_el(struct mhi_ring *ring, void *loc_1,
int get_nr_enclosed_el(struct mhi_ring *ring, void *loc_1,
void *loc_2, u32 *nr_el);
enum MHI_STATUS mhi_init_mmio(struct mhi_device_ctxt *mhi_dev_ctxt);
int mhi_init_mmio(struct mhi_device_ctxt *mhi_dev_ctxt);
int mhi_init_device_ctxt(struct mhi_pcie_dev_info *dev_info,
struct mhi_device_ctxt *mhi_dev_ctxt);
enum MHI_STATUS mhi_init_local_event_ring(struct mhi_device_ctxt *mhi_dev_ctxt,
int mhi_init_local_event_ring(struct mhi_device_ctxt *mhi_dev_ctxt,
u32 nr_ev_el, u32 event_ring_index);
/*Mhi Initialization functions */
enum MHI_STATUS mhi_send_cmd(struct mhi_device_ctxt *dest_device,
int mhi_send_cmd(struct mhi_device_ctxt *dest_device,
enum MHI_COMMAND which_cmd, u32 chan);
enum MHI_STATUS mhi_queue_tx_pkt(struct mhi_device_ctxt *mhi_dev_ctxt,
int mhi_queue_tx_pkt(struct mhi_device_ctxt *mhi_dev_ctxt,
enum MHI_CLIENT_CHANNEL chan,
void *payload,
size_t payload_size);
@ -588,26 +587,26 @@ int ctxt_add_element(struct mhi_ring *ring, void **assigned_addr);
int ctxt_del_element(struct mhi_ring *ring, void **assigned_addr);
int get_element_index(struct mhi_ring *ring, void *address,
uintptr_t *index);
enum MHI_STATUS recycle_trb_and_ring(struct mhi_device_ctxt *mhi_dev_ctxt,
int recycle_trb_and_ring(struct mhi_device_ctxt *mhi_dev_ctxt,
struct mhi_ring *ring, enum MHI_RING_TYPE ring_type, u32 ring_index);
enum MHI_STATUS parse_xfer_event(struct mhi_device_ctxt *ctxt,
int parse_xfer_event(struct mhi_device_ctxt *ctxt,
union mhi_event_pkt *event, u32 event_id);
enum MHI_EVENT_CCS get_cmd_pkt(struct mhi_device_ctxt *mhi_dev_ctxt,
union mhi_event_pkt *ev_pkt,
union mhi_cmd_pkt **cmd_pkt, u32 event_index);
enum MHI_STATUS parse_cmd_event(struct mhi_device_ctxt *ctxt,
int parse_cmd_event(struct mhi_device_ctxt *ctxt,
union mhi_event_pkt *event, u32 event_index);
int parse_event_thread(void *ctxt);
enum MHI_STATUS mhi_test_for_device_ready(
int mhi_test_for_device_ready(
struct mhi_device_ctxt *mhi_dev_ctxt);
enum MHI_STATUS mhi_test_for_device_reset(
int mhi_test_for_device_reset(
struct mhi_device_ctxt *mhi_dev_ctxt);
int validate_ring_el_addr(struct mhi_ring *ring, uintptr_t addr);
int validate_ev_el_addr(struct mhi_ring *ring, uintptr_t addr);
int mhi_state_change_thread(void *ctxt);
enum MHI_STATUS mhi_init_state_transition(struct mhi_device_ctxt *mhi_dev_ctxt,
int mhi_init_state_transition(struct mhi_device_ctxt *mhi_dev_ctxt,
enum STATE_TRANSITION new_state);
enum MHI_STATUS mhi_wait_for_mdm(struct mhi_device_ctxt *mhi_dev_ctxt);
int mhi_wait_for_mdm(struct mhi_device_ctxt *mhi_dev_ctxt);
enum hrtimer_restart mhi_initiate_m1(struct hrtimer *timer);
int mhi_pci_suspend(struct device *dev);
int mhi_pci_resume(struct device *dev);
@ -628,14 +627,14 @@ int mhi_assert_device_wake(struct mhi_device_ctxt *mhi_dev_ctxt);
int mhi_reg_notifiers(struct mhi_device_ctxt *mhi_dev_ctxt);
int mhi_cpu_notifier_cb(struct notifier_block *nfb, unsigned long action,
void *hcpu);
enum MHI_STATUS init_mhi_base_state(struct mhi_device_ctxt *mhi_dev_ctxt);
enum MHI_STATUS mhi_turn_off_pcie_link(struct mhi_device_ctxt *mhi_dev_ctxt);
enum MHI_STATUS mhi_turn_on_pcie_link(struct mhi_device_ctxt *mhi_dev_ctxt);
int init_mhi_base_state(struct mhi_device_ctxt *mhi_dev_ctxt);
int mhi_turn_off_pcie_link(struct mhi_device_ctxt *mhi_dev_ctxt);
int mhi_turn_on_pcie_link(struct mhi_device_ctxt *mhi_dev_ctxt);
int mhi_initiate_m0(struct mhi_device_ctxt *mhi_dev_ctxt);
int mhi_initiate_m3(struct mhi_device_ctxt *mhi_dev_ctxt);
int mhi_set_bus_request(struct mhi_device_ctxt *mhi_dev_ctxt,
int index);
enum MHI_STATUS start_chan_sync(struct mhi_client_handle *client_handle);
int start_chan_sync(struct mhi_client_handle *client_handle);
void mhi_process_db(struct mhi_device_ctxt *mhi_dev_ctxt, void __iomem *io_addr,
uintptr_t io_offset, u32 val);
void mhi_reg_write_field(struct mhi_device_ctxt *mhi_dev_ctxt,
@ -652,7 +651,7 @@ int mhi_runtime_suspend(struct device *dev);
int get_chan_props(struct mhi_device_ctxt *mhi_dev_ctxt, int chan,
struct mhi_chan_info *chan_info);
int mhi_runtime_resume(struct device *dev);
enum MHI_STATUS mhi_trigger_reset(struct mhi_device_ctxt *mhi_dev_ctxt);
int mhi_trigger_reset(struct mhi_device_ctxt *mhi_dev_ctxt);
int init_ev_rings(struct mhi_device_ctxt *mhi_dev_ctxt,
enum MHI_TYPE_EVENT_RING type);
void mhi_reset_ev_ctxt(struct mhi_device_ctxt *mhi_dev_ctxt,

6
drivers/platform/msm/mhi/mhi_bhi.c
View file

@ -31,7 +31,7 @@ static ssize_t bhi_write(struct file *file,
const char __user *buf,
size_t count, loff_t *offp)
{
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int ret_val = 0;
u32 pcie_word_val = 0;
u32 i = 0;
struct bhi_ctxt_t *bhi_ctxt =
@ -150,7 +150,7 @@ static ssize_t bhi_write(struct file *file,
ret_val = mhi_init_state_transition(mhi_dev_ctxt,
STATE_TRANSITION_RESET);
if (MHI_STATUS_SUCCESS != ret_val) {
if (ret_val) {
mhi_log(MHI_MSG_CRITICAL,
"Failed to start state change event\n");
}
@ -169,7 +169,7 @@ static const struct file_operations bhi_fops = {
int bhi_probe(struct mhi_pcie_dev_info *mhi_pcie_device)
{
struct bhi_ctxt_t *bhi_ctxt = &mhi_pcie_device->bhi_ctxt;
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int ret_val = 0;
u32 pcie_word_val = 0;
int r;

22
drivers/platform/msm/mhi/mhi_event.c
View file

@ -128,7 +128,7 @@ void ring_ev_db(struct mhi_device_ctxt *mhi_dev_ctxt, u32 event_ring_index)
event_ring_index, db_value);
}
static enum MHI_STATUS mhi_event_ring_init(struct mhi_event_ctxt *ev_list,
static int mhi_event_ring_init(struct mhi_event_ctxt *ev_list,
struct mhi_ring *ring, u32 el_per_ring,
u32 intmodt_val, u32 msi_vec)
{
@ -141,7 +141,7 @@ static enum MHI_STATUS mhi_event_ring_init(struct mhi_event_ctxt *ev_list,
ring->overwrite_en = 0;
/* Flush writes to MMIO */
wmb();
return MHI_STATUS_SUCCESS;
return 0;
}
void init_event_ctxt_array(struct mhi_device_ctxt *mhi_dev_ctxt)
@ -163,7 +163,7 @@ void init_event_ctxt_array(struct mhi_device_ctxt *mhi_dev_ctxt)
int init_local_ev_ring_by_type(struct mhi_device_ctxt *mhi_dev_ctxt,
enum MHI_TYPE_EVENT_RING type)
{
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int ret_val = 0;
u32 i;
mhi_log(MHI_MSG_INFO, "Entered\n");
@ -184,11 +184,10 @@ int init_local_ev_ring_by_type(struct mhi_device_ctxt *mhi_dev_ctxt,
return 0;
}
enum MHI_STATUS mhi_add_elements_to_event_rings(
struct mhi_device_ctxt *mhi_dev_ctxt,
int mhi_add_elements_to_event_rings(struct mhi_device_ctxt *mhi_dev_ctxt,
enum STATE_TRANSITION new_state)
{
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int ret_val = 0;
switch (new_state) {
case STATE_TRANSITION_READY:
@ -202,19 +201,19 @@ enum MHI_STATUS mhi_add_elements_to_event_rings(
default:
mhi_log(MHI_MSG_ERROR,
"Unrecognized event stage, %d\n", new_state);
ret_val = MHI_STATUS_ERROR;
ret_val = -EINVAL;
break;
}
return ret_val;
}
enum MHI_STATUS mhi_init_local_event_ring(struct mhi_device_ctxt *mhi_dev_ctxt,
int mhi_init_local_event_ring(struct mhi_device_ctxt *mhi_dev_ctxt,
u32 nr_ev_el, u32 ring_index)
{
union mhi_event_pkt *ev_pkt = NULL;
u32 i = 0;
unsigned long flags = 0;
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int ret_val = 0;
spinlock_t *lock =
&mhi_dev_ctxt->mhi_ev_spinlock_list[ring_index];
struct mhi_ring *event_ctxt =
@ -222,7 +221,7 @@ enum MHI_STATUS mhi_init_local_event_ring(struct mhi_device_ctxt *mhi_dev_ctxt,
if (NULL == mhi_dev_ctxt || 0 == nr_ev_el) {
mhi_log(MHI_MSG_ERROR, "Bad Input data, quitting\n");
return MHI_STATUS_ERROR;
return -EINVAL;
}
spin_lock_irqsave(lock, flags);
@ -235,10 +234,9 @@ enum MHI_STATUS mhi_init_local_event_ring(struct mhi_device_ctxt *mhi_dev_ctxt,
for (i = 0; i < nr_ev_el - 1; ++i) {
ret_val = ctxt_add_element(event_ctxt, (void *)&ev_pkt);
if (MHI_STATUS_SUCCESS != ret_val) {
if (0 != ret_val) {
mhi_log(MHI_MSG_ERROR,
"Failed to insert el in ev ctxt\n");
ret_val = MHI_STATUS_ERROR;
break;
}
}

10
drivers/platform/msm/mhi/mhi_iface.c
View file

@ -154,8 +154,9 @@ int mhi_ctxt_init(struct mhi_pcie_dev_info *mhi_pcie_dev)
"Setting IRQ Base to 0x%x\n", mhi_pcie_dev->core.irq_base);
mhi_pcie_dev->core.max_nr_msis = requested_msi_number;
ret_val = mhi_init_pm_sysfs(&pcie_device->dev);
if (ret_val != 0) {
mhi_log(MHI_MSG_ERROR, "Failed to setup sysfs.\n");
if (ret_val) {
mhi_log(MHI_MSG_ERROR, "Failed to setup sysfs ret %d\n",
ret_val);
goto sysfs_config_err;
}
if (!mhi_init_debugfs(&mhi_pcie_dev->mhi_ctxt))
@ -173,9 +174,10 @@ int mhi_ctxt_init(struct mhi_pcie_dev_info *mhi_pcie_dev)
goto mhi_state_transition_error;
}
}
if (MHI_STATUS_SUCCESS != mhi_reg_notifiers(&mhi_pcie_dev->mhi_ctxt)) {
ret_val = mhi_reg_notifiers(&mhi_pcie_dev->mhi_ctxt);
if (ret_val) {
mhi_log(MHI_MSG_ERROR, "Failed to register for notifiers\n");
return MHI_STATUS_ERROR;
return ret_val;
}
mhi_log(MHI_MSG_INFO,
"Finished all driver probing returning ret_val %d.\n",

19
drivers/platform/msm/mhi/mhi_init.c
View file

@ -163,7 +163,7 @@ int populate_bb_list(struct list_head *bb_list, int num_bb)
* @ring_size: Ring size
* @ring: Pointer to the shadow command context
*
* @Return MHI_STATUS
* @Return errno
*/
static int mhi_cmd_ring_init(struct mhi_cmd_ctxt *cmd_ctxt,
void *trb_list_virt_addr,
@ -377,7 +377,7 @@ static int mhi_init_events(struct mhi_device_ctxt *mhi_dev_ctxt)
GFP_KERNEL);
if (NULL == mhi_dev_ctxt->mhi_ev_wq.mhi_event_wq) {
mhi_log(MHI_MSG_ERROR, "Failed to init event");
return MHI_STATUS_ERROR;
return -ENOMEM;
}
mhi_dev_ctxt->mhi_ev_wq.state_change_event =
kmalloc(sizeof(wait_queue_head_t), GFP_KERNEL);
@ -467,12 +467,12 @@ static int mhi_spawn_threads(struct mhi_device_ctxt *mhi_dev_ctxt)
mhi_dev_ctxt,
"mhi_ev_thrd");
if (IS_ERR(mhi_dev_ctxt->event_thread_handle))
return MHI_STATUS_ERROR;
return PTR_ERR(mhi_dev_ctxt->event_thread_handle);
mhi_dev_ctxt->st_thread_handle = kthread_run(mhi_state_change_thread,
mhi_dev_ctxt,
"mhi_st_thrd");
if (IS_ERR(mhi_dev_ctxt->event_thread_handle))
return MHI_STATUS_ERROR;
return PTR_ERR(mhi_dev_ctxt->event_thread_handle);
return 0;
}
@ -485,7 +485,7 @@ static int mhi_spawn_threads(struct mhi_device_ctxt *mhi_dev_ctxt)
which this mhi context belongs
* @param mhi_struct device [IN/OUT] reference to a mhi context to be populated
*
* @return MHI_STATUS
* @return errno
*/
int mhi_init_device_ctxt(struct mhi_pcie_dev_info *dev_info,
struct mhi_device_ctxt *mhi_dev_ctxt)
@ -583,7 +583,7 @@ error_during_props:
* @event_ring: Event ring to be mapped to this channel context
* @ring: Shadow context to be initialized alongside
*
* @Return MHI_STATUS
* @Return errno
*/
int mhi_init_chan_ctxt(struct mhi_chan_ctxt *cc_list,
uintptr_t trb_list_phy, uintptr_t trb_list_virt,
@ -629,11 +629,8 @@ int mhi_reg_notifiers(struct mhi_device_ctxt *mhi_dev_ctxt)
u32 ret_val;
if (NULL == mhi_dev_ctxt)
return MHI_STATUS_ERROR;
return -EINVAL;
mhi_dev_ctxt->mhi_cpu_notifier.notifier_call = mhi_cpu_notifier_cb;
ret_val = register_cpu_notifier(&mhi_dev_ctxt->mhi_cpu_notifier);
if (ret_val)
return MHI_STATUS_ERROR;
else
return 0;
return ret_val;
}

22
drivers/platform/msm/mhi/mhi_isr.c
View file

@ -1,4 +1,4 @@
/* Copyright (c) 2014-2015, The Linux Foundation. All rights reserved.
/* Copyright (c) 2014-2016, 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
@ -59,15 +59,14 @@ irqreturn_t mhi_msi_ipa_handlr(int irq_number, void *dev_id)
cb_info.result = &client_handle->result;
cb_info.cb_reason = MHI_CB_XFER;
cb_info.chan = client_handle->chan_info.chan_nr;
cb_info.result->transaction_status =
MHI_STATUS_SUCCESS;
cb_info.result->transaction_status = 0;
client_info->mhi_client_cb(&cb_info);
}
}
return IRQ_HANDLED;
}
static enum MHI_STATUS mhi_process_event_ring(
static int mhi_process_event_ring(
struct mhi_device_ctxt *mhi_dev_ctxt,
u32 ev_index,
u32 event_quota)
@ -75,7 +74,7 @@ static enum MHI_STATUS mhi_process_event_ring(
union mhi_event_pkt *local_rp = NULL;
union mhi_event_pkt *device_rp = NULL;
union mhi_event_pkt event_to_process;
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int ret_val = 0;
struct mhi_event_ctxt *ev_ctxt = NULL;
union mhi_cmd_pkt *cmd_pkt = NULL;
union mhi_event_pkt *ev_ptr = NULL;
@ -110,7 +109,7 @@ static enum MHI_STATUS mhi_process_event_ring(
mhi_log(MHI_MSG_INFO, "First Reset CC event\n");
MHI_TRB_SET_INFO(CMD_TRB_TYPE, cmd_pkt,
MHI_PKT_TYPE_RESET_CHAN_DEFER_CMD);
ret_val = MHI_STATUS_CMD_PENDING;
ret_val = -EINPROGRESS;
break;
} else if ((MHI_TRB_READ_INFO(CMD_TRB_TYPE, cmd_pkt)
== MHI_PKT_TYPE_RESET_CHAN_DEFER_CMD)) {
@ -120,8 +119,7 @@ static enum MHI_STATUS mhi_process_event_ring(
"Processing Reset CC event\n");
}
}
if (unlikely(MHI_STATUS_SUCCESS !=
recycle_trb_and_ring(mhi_dev_ctxt,
if (unlikely(0 != recycle_trb_and_ring(mhi_dev_ctxt,
local_ev_ctxt,
MHI_RING_TYPE_EVENT_RING,
ev_index)))
@ -197,7 +195,7 @@ static enum MHI_STATUS mhi_process_event_ring(
MHI_RING_TYPE_EVENT_RING,
ev_index,
ev_ctxt->mhi_event_read_ptr);
ret_val = MHI_STATUS_SUCCESS;
ret_val = 0;
--event_quota;
}
return ret_val;
@ -254,7 +252,7 @@ int parse_event_thread(void *ctxt)
mhi_process_event_ring(mhi_dev_ctxt, i,
mhi_dev_ctxt->ev_ring_props[i].nr_desc);
if (ret_val_process_event ==
MHI_STATUS_CMD_PENDING)
-EINPROGRESS)
atomic_inc(ev_pen_ptr);
}
}
@ -264,7 +262,7 @@ int parse_event_thread(void *ctxt)
struct mhi_result *mhi_poll(struct mhi_client_handle *client_handle)
{
enum MHI_STATUS ret_val;
int ret_val;
client_handle->result.buf_addr = NULL;
client_handle->result.bytes_xferd = 0;
@ -272,7 +270,7 @@ struct mhi_result *mhi_poll(struct mhi_client_handle *client_handle)
ret_val = mhi_process_event_ring(client_handle->mhi_dev_ctxt,
client_handle->event_ring_index,
1);
if (MHI_STATUS_SUCCESS != ret_val)
if (ret_val)
mhi_log(MHI_MSG_INFO, "NAPI failed to process event ring\n");
return &(client_handle->result);
}

203
drivers/platform/msm/mhi/mhi_main.c
View file

@ -264,23 +264,23 @@ static int populate_tre_ring(struct mhi_client_handle *client_handle)
return 0;
}
enum MHI_STATUS mhi_open_channel(struct mhi_client_handle *client_handle)
int mhi_open_channel(struct mhi_client_handle *client_handle)
{
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int ret_val = 0;
struct mhi_device_ctxt *mhi_dev_ctxt;
int r = 0;
int chan;
if (NULL == client_handle ||
client_handle->magic != MHI_HANDLE_MAGIC)
return MHI_STATUS_ERROR;
return -EINVAL;
mhi_dev_ctxt = client_handle->mhi_dev_ctxt;
r = get_chan_props(mhi_dev_ctxt,
client_handle->chan_info.chan_nr,
&client_handle->chan_info);
if (r)
return MHI_STATUS_ERROR;
return r;
chan = client_handle->chan_info.chan_nr;
mhi_log(MHI_MSG_INFO,
@ -291,7 +291,7 @@ enum MHI_STATUS mhi_open_channel(struct mhi_client_handle *client_handle)
mhi_log(MHI_MSG_INFO,
"Chan %d, MHI exec_env %d, not ready!\n",
chan, mhi_dev_ctxt->dev_exec_env);
return MHI_STATUS_DEVICE_NOT_READY;
return -ENOTCONN;
}
r = populate_tre_ring(client_handle);
if (r) {
@ -309,7 +309,7 @@ enum MHI_STATUS mhi_open_channel(struct mhi_client_handle *client_handle)
mhi_log(MHI_MSG_ERROR,
"Failed to initialize bb ctxt chan %d ret %d\n",
chan, r);
return MHI_STATUS_ERROR;
return r;
}
client_handle->msi_vec =
@ -322,9 +322,9 @@ enum MHI_STATUS mhi_open_channel(struct mhi_client_handle *client_handle)
init_completion(&client_handle->chan_open_complete);
ret_val = start_chan_sync(client_handle);
if (MHI_STATUS_SUCCESS != ret_val)
if (0 != ret_val)
mhi_log(MHI_MSG_ERROR,
"Failed to start chan 0x%x\n", chan);
"Failed to start chan 0x%x, ret %d\n", chan, ret_val);
BUG_ON(ret_val);
client_handle->chan_status = 1;
mhi_log(MHI_MSG_INFO,
@ -333,29 +333,29 @@ enum MHI_STATUS mhi_open_channel(struct mhi_client_handle *client_handle)
}
EXPORT_SYMBOL(mhi_open_channel);
enum MHI_STATUS mhi_register_channel(struct mhi_client_handle **client_handle,
int mhi_register_channel(struct mhi_client_handle **client_handle,
enum MHI_CLIENT_CHANNEL chan, s32 device_index,
struct mhi_client_info_t *client_info, void *user_data)
{
struct mhi_device_ctxt *mhi_dev_ctxt = NULL;
if (!VALID_CHAN_NR(chan))
return MHI_STATUS_INVALID_CHAN_ERR;
return -EINVAL;
if (NULL == client_handle || device_index < 0)
return MHI_STATUS_ERROR;
return -EINVAL;
mhi_dev_ctxt = &(mhi_devices.device_list[device_index].mhi_ctxt);
if (NULL != mhi_dev_ctxt->client_handle_list[chan])
return MHI_STATUS_ALREADY_REGISTERED;
return -EISCONN;
mhi_log(MHI_MSG_INFO,
"Opened channel 0x%x for client\n", chan);
*client_handle = kzalloc(sizeof(struct mhi_client_handle), GFP_KERNEL);
if (NULL == *client_handle)
return MHI_STATUS_ALLOC_ERROR;
return -ENOMEM;
mhi_dev_ctxt->client_handle_list[chan] = *client_handle;
(*client_handle)->mhi_dev_ctxt = mhi_dev_ctxt;
@ -380,7 +380,7 @@ enum MHI_STATUS mhi_register_channel(struct mhi_client_handle **client_handle,
mhi_log(MHI_MSG_VERBOSE,
"Successfuly registered chan 0x%x\n", chan);
return MHI_STATUS_SUCCESS;
return 0;
}
EXPORT_SYMBOL(mhi_register_channel);
@ -388,7 +388,7 @@ void mhi_close_channel(struct mhi_client_handle *client_handle)
{
u32 chan;
int r = 0;
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int ret_val = 0;
if (!client_handle ||
client_handle->magic != MHI_HANDLE_MAGIC ||
@ -402,7 +402,7 @@ void mhi_close_channel(struct mhi_client_handle *client_handle)
if (!atomic_read(&client_handle->mhi_dev_ctxt->flags.pending_ssr)) {
ret_val = mhi_send_cmd(client_handle->mhi_dev_ctxt,
MHI_COMMAND_RESET_CHAN, chan);
if (ret_val != MHI_STATUS_SUCCESS) {
if (ret_val != 0) {
mhi_log(MHI_MSG_ERROR,
"Failed to send reset cmd for chan %d ret %d\n",
chan, ret_val);
@ -445,9 +445,9 @@ void mhi_update_chan_db(struct mhi_device_ctxt *mhi_dev_ctxt,
chan, db_value);
}
enum MHI_STATUS mhi_check_m2_transition(struct mhi_device_ctxt *mhi_dev_ctxt)
int mhi_check_m2_transition(struct mhi_device_ctxt *mhi_dev_ctxt)
{
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int ret_val = 0;
if (mhi_dev_ctxt->mhi_state == MHI_STATE_M2) {
mhi_log(MHI_MSG_INFO, "M2 Transition flag value = %d\n",
@ -455,27 +455,27 @@ enum MHI_STATUS mhi_check_m2_transition(struct mhi_device_ctxt *mhi_dev_ctxt)
if ((atomic_read(&mhi_dev_ctxt->flags.m2_transition)) == 0) {
if (mhi_dev_ctxt->flags.link_up) {
mhi_assert_device_wake(mhi_dev_ctxt);
ret_val = MHI_STATUS_CHAN_NOT_READY;
ret_val = -ENOTCONN;
}
} else{
mhi_log(MHI_MSG_INFO, "M2 transition flag is set\n");
ret_val = MHI_STATUS_CHAN_NOT_READY;
ret_val = -ENOTCONN;
}
} else {
ret_val = MHI_STATUS_SUCCESS;
ret_val = 0;
}
return ret_val;
}
static inline enum MHI_STATUS mhi_queue_tre(struct mhi_device_ctxt
static inline int mhi_queue_tre(struct mhi_device_ctxt
*mhi_dev_ctxt,
u32 chan,
enum MHI_RING_TYPE type)
{
struct mhi_chan_ctxt *chan_ctxt;
unsigned long flags = 0;
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int ret_val = 0;
u64 db_value = 0;
chan_ctxt = &mhi_dev_ctxt->dev_space.ring_ctxt.cc_list[chan];
@ -485,7 +485,7 @@ static inline enum MHI_STATUS mhi_queue_tre(struct mhi_device_ctxt
atomic_inc(&mhi_dev_ctxt->counters.outbound_acks);
ret_val = mhi_check_m2_transition(mhi_dev_ctxt);
if (likely(((ret_val == MHI_STATUS_SUCCESS) &&
if (likely(((ret_val == 0) &&
(((mhi_dev_ctxt->mhi_state == MHI_STATE_M0) ||
(mhi_dev_ctxt->mhi_state == MHI_STATE_M1))) &&
(chan_ctxt->mhi_chan_state != MHI_CHAN_STATE_ERROR)) &&
@ -504,11 +504,10 @@ static inline enum MHI_STATUS mhi_queue_tre(struct mhi_device_ctxt
spin_unlock_irqrestore(
&mhi_dev_ctxt->db_write_lock[chan], flags);
} else if (type == MHI_RING_TYPE_CMD_RING) {
db_value =
mhi_v2p_addr(mhi_dev_ctxt,
MHI_RING_TYPE_CMD_RING,
PRIMARY_CMD_RING,
(uintptr_t)
db_value = mhi_v2p_addr(mhi_dev_ctxt,
MHI_RING_TYPE_CMD_RING,
PRIMARY_CMD_RING,
(uintptr_t)
mhi_dev_ctxt->mhi_local_cmd_ctxt[PRIMARY_CMD_RING].wp);
mhi_dev_ctxt->cmd_ring_order++;
mhi_process_db(mhi_dev_ctxt,
@ -517,14 +516,14 @@ static inline enum MHI_STATUS mhi_queue_tre(struct mhi_device_ctxt
} else {
mhi_log(MHI_MSG_VERBOSE,
"Wrong type of packet = %d\n", type);
ret_val = MHI_STATUS_ERROR;
ret_val = -EPROTO;
}
} else {
mhi_log(MHI_MSG_VERBOSE,
"Wakeup, pending data state %d chan state %d\n",
mhi_dev_ctxt->mhi_state,
chan_ctxt->mhi_chan_state);
ret_val = MHI_STATUS_SUCCESS;
ret_val = 0;
}
return ret_val;
}
@ -638,20 +637,19 @@ void reset_bb_ctxt(struct mhi_device_ctxt *mhi_dev_ctxt,
mhi_log(MHI_MSG_VERBOSE, "Exited\n");
}
static enum MHI_STATUS mhi_queue_dma_xfer(
static int mhi_queue_dma_xfer(
struct mhi_client_handle *client_handle,
dma_addr_t buf, size_t buf_len, enum MHI_FLAGS mhi_flags)
{
union mhi_xfer_pkt *pkt_loc;
enum MHI_STATUS ret_val;
int ret_val;
enum MHI_CLIENT_CHANNEL chan;
struct mhi_device_ctxt *mhi_dev_ctxt;
unsigned long flags;
if (!client_handle || !buf || !buf_len) {
mhi_log(MHI_MSG_CRITICAL, "Bad input args\n");
return MHI_STATUS_ERROR;
}
if (!client_handle || !buf || !buf_len)
return -EINVAL;
mhi_dev_ctxt = client_handle->mhi_dev_ctxt;
MHI_ASSERT(VALID_BUF(buf, buf_len, mhi_dev_ctxt),
"Client buffer is of invalid length\n");
@ -682,7 +680,7 @@ static enum MHI_STATUS mhi_queue_dma_xfer(
/* Add the TRB to the correct transfer ring */
ret_val = ctxt_add_element(&mhi_dev_ctxt->mhi_local_chan_ctxt[chan],
(void *)&pkt_loc);
if (unlikely(MHI_STATUS_SUCCESS != ret_val)) {
if (unlikely(0 != ret_val)) {
mhi_log(MHI_MSG_VERBOSE,
"Failed to insert trb in xfer ring\n");
goto error;
@ -693,7 +691,7 @@ static enum MHI_STATUS mhi_queue_dma_xfer(
GET_CHAN_PROPS(CHAN_DIR, client_handle->chan_info.flags))
atomic_inc(&mhi_dev_ctxt->counters.outbound_acks);
ret_val = mhi_queue_tre(mhi_dev_ctxt, chan, MHI_RING_TYPE_XFER_RING);
if (unlikely(MHI_STATUS_SUCCESS != ret_val))
if (unlikely(ret_val))
mhi_log(MHI_MSG_VERBOSE, "Failed queue TRE.\n");
atomic_dec(&mhi_dev_ctxt->flags.data_pending);
read_unlock_irqrestore(&mhi_dev_ctxt->xfer_lock, flags);
@ -749,7 +747,7 @@ int mhi_queue_xfer(struct mhi_client_handle *client_handle,
}
EXPORT_SYMBOL(mhi_queue_xfer);
enum MHI_STATUS mhi_send_cmd(struct mhi_device_ctxt *mhi_dev_ctxt,
int mhi_send_cmd(struct mhi_device_ctxt *mhi_dev_ctxt,
enum MHI_COMMAND cmd, u32 chan)
{
unsigned long flags = 0;
@ -758,13 +756,13 @@ enum MHI_STATUS mhi_send_cmd(struct mhi_device_ctxt *mhi_dev_ctxt,
enum MHI_CHAN_STATE to_state = MHI_CHAN_STATE_DISABLED;
enum MHI_PKT_TYPE ring_el_type = MHI_PKT_TYPE_NOOP_CMD;
struct mutex *chan_mutex = NULL;
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int ret_val = 0;
if (chan >= MHI_MAX_CHANNELS ||
cmd >= MHI_COMMAND_MAX_NR || mhi_dev_ctxt == NULL) {
mhi_log(MHI_MSG_ERROR,
"Invalid channel id, received id: 0x%x", chan);
return MHI_STATUS_ERROR;
return -EINVAL;
}
mhi_log(MHI_MSG_INFO,
@ -780,7 +778,7 @@ enum MHI_STATUS mhi_send_cmd(struct mhi_device_ctxt *mhi_dev_ctxt,
*/
if (MHI_CMD_PENDING == mhi_dev_ctxt->mhi_chan_pend_cmd_ack[chan]) {
mhi_log(MHI_MSG_ERROR, "Cmd Pending on chan %d", chan);
ret_val = MHI_STATUS_CMD_PENDING;
ret_val = -EALREADY;
goto error_invalid;
}
@ -805,7 +803,7 @@ enum MHI_STATUS mhi_send_cmd(struct mhi_device_ctxt *mhi_dev_ctxt,
mhi_log(MHI_MSG_ERROR,
"Invalid stt cmd 0x%x, from_state 0x%x\n",
cmd, from_state);
ret_val = MHI_STATUS_BAD_STATE;
ret_val = -EPERM;
goto error_invalid;
}
ring_el_type = MHI_PKT_TYPE_START_CHAN_CMD;
@ -902,11 +900,11 @@ static void parse_outbound_bb(struct mhi_device_ctxt *mhi_dev_ctxt,
mhi_log(MHI_MSG_RAW, "Exited\n");
}
static enum MHI_STATUS parse_outbound(struct mhi_device_ctxt *mhi_dev_ctxt,
static int parse_outbound(struct mhi_device_ctxt *mhi_dev_ctxt,
u32 chan, union mhi_xfer_pkt *local_ev_trb_loc, u16 xfer_len)
{
struct mhi_result *result = NULL;
enum MHI_STATUS ret_val = 0;
int ret_val = 0;
struct mhi_client_handle *client_handle = NULL;
struct mhi_ring *local_chan_ctxt = NULL;
struct mhi_cb_info cb_info;
@ -943,10 +941,10 @@ static enum MHI_STATUS parse_outbound(struct mhi_device_ctxt *mhi_dev_ctxt,
mhi_log(MHI_MSG_RAW,
"Processed outbound ack chan %d Pending acks %d.\n",
chan, atomic_read(&mhi_dev_ctxt->counters.outbound_acks));
return MHI_STATUS_SUCCESS;
return 0;
}
static enum MHI_STATUS parse_inbound(struct mhi_device_ctxt *mhi_dev_ctxt,
static int parse_inbound(struct mhi_device_ctxt *mhi_dev_ctxt,
u32 chan, union mhi_xfer_pkt *local_ev_trb_loc, u16 xfer_len)
{
struct mhi_client_handle *client_handle;
@ -1032,16 +1030,16 @@ static enum MHI_STATUS parse_inbound(struct mhi_device_ctxt *mhi_dev_ctxt,
*/
}
}
return MHI_STATUS_SUCCESS;
return 0;
}
static enum MHI_STATUS validate_xfer_el_addr(struct mhi_chan_ctxt *ring,
static int validate_xfer_el_addr(struct mhi_chan_ctxt *ring,
uintptr_t addr)
{
return (addr < (ring->mhi_trb_ring_base_addr) ||
addr > (ring->mhi_trb_ring_base_addr)
+ (ring->mhi_trb_ring_len - 1)) ?
MHI_STATUS_ERROR : MHI_STATUS_SUCCESS;
-ERANGE : 0;
}
static void print_tre(int chan, struct mhi_ring *ring, struct mhi_tx_pkt *tre)
@ -1055,7 +1053,7 @@ static void print_tre(int chan, struct mhi_ring *ring, struct mhi_tx_pkt *tre)
tre->buffer_ptr, tre->buf_len, tre->info);
}
enum MHI_STATUS parse_xfer_event(struct mhi_device_ctxt *ctxt,
int parse_xfer_event(struct mhi_device_ctxt *ctxt,
union mhi_event_pkt *event, u32 event_id)
{
struct mhi_device_ctxt *mhi_dev_ctxt = (struct mhi_device_ctxt *)ctxt;
@ -1075,7 +1073,7 @@ enum MHI_STATUS parse_xfer_event(struct mhi_device_ctxt *ctxt,
chan = MHI_EV_READ_CHID(EV_CHID, event);
if (unlikely(!VALID_CHAN_NR(chan))) {
mhi_log(MHI_MSG_ERROR, "Bad ring id.\n");
return MHI_STATUS_ERROR;
return -EINVAL;
}
ev_code = MHI_EV_READ_CODE(EV_TRB_CODE, event);
client_handle = mhi_dev_ctxt->client_handle_list[chan];
@ -1085,9 +1083,9 @@ enum MHI_STATUS parse_xfer_event(struct mhi_device_ctxt *ctxt,
"Event Received, chan %d, cc_code %d\n",
chan, ev_code);
if (ev_code == MHI_EVENT_CC_OVERFLOW)
result->transaction_status = MHI_STATUS_OVERFLOW;
result->transaction_status = -EOVERFLOW;
else
result->transaction_status = MHI_STATUS_SUCCESS;
result->transaction_status = 0;
switch (ev_code) {
case MHI_EVENT_CC_OVERFLOW:
@ -1096,7 +1094,7 @@ enum MHI_STATUS parse_xfer_event(struct mhi_device_ctxt *ctxt,
{
dma_addr_t trb_data_loc;
u32 ieot_flag;
enum MHI_STATUS ret_val;
int ret_val;
struct mhi_ring *local_chan_ctxt;
local_chan_ctxt =
@ -1118,11 +1116,11 @@ enum MHI_STATUS parse_xfer_event(struct mhi_device_ctxt *ctxt,
local_trb_loc,
local_ev_trb_loc,
&nr_trb_to_parse);
if (unlikely(MHI_STATUS_SUCCESS != ret_val)) {
if (unlikely(ret_val)) {
mhi_log(MHI_MSG_CRITICAL,
"Failed to get nr available trbs ret: %d.\n",
ret_val);
return MHI_STATUS_ERROR;
return ret_val;
}
do {
u64 phy_buf_loc;
@ -1140,7 +1138,7 @@ enum MHI_STATUS parse_xfer_event(struct mhi_device_ctxt *ctxt,
mhi_log(MHI_MSG_CRITICAL,
"Bad buffer ptr: %lx.\n",
(uintptr_t)trb_data_loc);
return MHI_STATUS_ERROR;
return -EINVAL;
}
if (local_chan_ctxt->dir == MHI_IN) {
parse_inbound(mhi_dev_ctxt, chan,
@ -1186,8 +1184,7 @@ enum MHI_STATUS parse_xfer_event(struct mhi_device_ctxt *ctxt,
}
client_handle = mhi_dev_ctxt->client_handle_list[chan];
if (NULL != client_handle) {
result->transaction_status =
MHI_STATUS_DEVICE_NOT_READY;
result->transaction_status = -ENOTCONN;
}
break;
}
@ -1212,28 +1209,28 @@ enum MHI_STATUS parse_xfer_event(struct mhi_device_ctxt *ctxt,
return 0;
}
enum MHI_STATUS recycle_trb_and_ring(struct mhi_device_ctxt *mhi_dev_ctxt,
int recycle_trb_and_ring(struct mhi_device_ctxt *mhi_dev_ctxt,
struct mhi_ring *ring,
enum MHI_RING_TYPE ring_type,
u32 ring_index)
{
enum MHI_STATUS ret_val = MHI_STATUS_ERROR;
int ret_val = 0;
u64 db_value = 0;
void *removed_element = NULL;
void *added_element = NULL;
ret_val = ctxt_del_element(ring, &removed_element);
if (MHI_STATUS_SUCCESS != ret_val) {
if (ret_val) {
mhi_log(MHI_MSG_ERROR, "Could not remove element from ring\n");
return MHI_STATUS_ERROR;
return ret_val;
}
ret_val = ctxt_add_element(ring, &added_element);
if (MHI_STATUS_SUCCESS != ret_val)
if (0 != ret_val)
mhi_log(MHI_MSG_ERROR, "Could not add element to ring\n");
db_value = mhi_v2p_addr(mhi_dev_ctxt, ring_type, ring_index,
(uintptr_t) ring->wp);
if (MHI_STATUS_SUCCESS != ret_val)
if (0 != ret_val)
return ret_val;
if (MHI_RING_TYPE_XFER_RING == ring_type) {
union mhi_xfer_pkt *removed_xfer_pkt =
@ -1248,7 +1245,7 @@ enum MHI_STATUS recycle_trb_and_ring(struct mhi_device_ctxt *mhi_dev_ctxt,
unsigned long flags;
if (ring_index >= mhi_dev_ctxt->mmio_info.nr_event_rings)
return MHI_STATUS_ERROR;
return -ERANGE;
lock = &mhi_dev_ctxt->mhi_ev_spinlock_list[ring_index];
spin_lock_irqsave(lock, flags);
db_value = mhi_v2p_addr(mhi_dev_ctxt, ring_type, ring_index,
@ -1327,11 +1324,11 @@ enum MHI_STATUS recycle_trb_and_ring(struct mhi_device_ctxt *mhi_dev_ctxt,
return ret_val;
}
static enum MHI_STATUS reset_chan_cmd(struct mhi_device_ctxt *mhi_dev_ctxt,
static int reset_chan_cmd(struct mhi_device_ctxt *mhi_dev_ctxt,
union mhi_cmd_pkt *cmd_pkt)
{
u32 chan = 0;
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int ret_val = 0;
struct mhi_ring *local_chan_ctxt;
struct mhi_chan_ctxt *chan_ctxt;
struct mhi_client_handle *client_handle = NULL;
@ -1345,7 +1342,7 @@ static enum MHI_STATUS reset_chan_cmd(struct mhi_device_ctxt *mhi_dev_ctxt,
if (!VALID_CHAN_NR(chan)) {
mhi_log(MHI_MSG_ERROR,
"Bad channel number for CCE\n");
return MHI_STATUS_ERROR;
return -EINVAL;
}
bb_ctxt = &mhi_dev_ctxt->chan_bb_list[chan];
@ -1392,7 +1389,7 @@ static enum MHI_STATUS reset_chan_cmd(struct mhi_device_ctxt *mhi_dev_ctxt,
return ret_val;
}
static enum MHI_STATUS start_chan_cmd(struct mhi_device_ctxt *mhi_dev_ctxt,
static int start_chan_cmd(struct mhi_device_ctxt *mhi_dev_ctxt,
union mhi_cmd_pkt *cmd_pkt)
{
u32 chan;
@ -1406,7 +1403,7 @@ static enum MHI_STATUS start_chan_cmd(struct mhi_device_ctxt *mhi_dev_ctxt,
if (NULL != mhi_dev_ctxt->client_handle_list[chan])
complete(
&mhi_dev_ctxt->client_handle_list[chan]->chan_open_complete);
return MHI_STATUS_SUCCESS;
return 0;
}
enum MHI_EVENT_CCS get_cmd_pkt(struct mhi_device_ctxt *mhi_dev_ctxt,
union mhi_event_pkt *ev_pkt,
@ -1419,50 +1416,47 @@ enum MHI_EVENT_CCS get_cmd_pkt(struct mhi_device_ctxt *mhi_dev_ctxt,
phy_trb_loc = (uintptr_t)MHI_EV_READ_PTR(EV_PTR,
ev_pkt);
else
return MHI_STATUS_ERROR;
return -EINVAL;
*cmd_pkt = (union mhi_cmd_pkt *)mhi_p2v_addr(mhi_dev_ctxt,
MHI_RING_TYPE_CMD_RING, event_index,
phy_trb_loc);
return MHI_EV_READ_CODE(EV_TRB_CODE, ev_pkt);
}
enum MHI_STATUS parse_cmd_event(struct mhi_device_ctxt *mhi_dev_ctxt,
int parse_cmd_event(struct mhi_device_ctxt *mhi_dev_ctxt,
union mhi_event_pkt *ev_pkt, u32 event_index)
{
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int ret_val = 0;
union mhi_cmd_pkt *cmd_pkt = NULL;
u32 event_code;
u32 event_code = 0;
event_code = get_cmd_pkt(mhi_dev_ctxt, ev_pkt, &cmd_pkt, event_index);
switch (event_code) {
case MHI_EVENT_CC_SUCCESS:
{
u32 chan;
u32 chan = 0;
MHI_TRB_GET_INFO(CMD_TRB_CHID, cmd_pkt, chan);
switch (MHI_TRB_READ_INFO(CMD_TRB_TYPE, cmd_pkt)) {
mhi_log(MHI_MSG_INFO, "CCE chan %d cmd %d\n",
chan,
mhi_log(MHI_MSG_INFO, "CCE chan %d cmd %d\n", chan,
MHI_TRB_READ_INFO(CMD_TRB_TYPE, cmd_pkt));
case MHI_PKT_TYPE_RESET_CHAN_CMD:
if (MHI_STATUS_SUCCESS != reset_chan_cmd(mhi_dev_ctxt,
cmd_pkt))
ret_val = reset_chan_cmd(mhi_dev_ctxt, cmd_pkt);
if (ret_val)
mhi_log(MHI_MSG_INFO,
"Failed to process reset cmd\n");
"Failed to process reset cmd ret %d\n",
ret_val);
break;
case MHI_PKT_TYPE_STOP_CHAN_CMD:
if (MHI_STATUS_SUCCESS != ret_val) {
if (ret_val) {
mhi_log(MHI_MSG_INFO,
"Failed to set chan state\n");
return MHI_STATUS_ERROR;
return ret_val;
}
break;
case MHI_PKT_TYPE_START_CHAN_CMD:
if (MHI_STATUS_SUCCESS != start_chan_cmd(mhi_dev_ctxt,
cmd_pkt))
ret_val = start_chan_cmd(mhi_dev_ctxt, cmd_pkt);
if (ret_val)
mhi_log(MHI_MSG_INFO,
"Failed to process reset cmd\n");
break;
@ -1481,7 +1475,7 @@ enum MHI_STATUS parse_cmd_event(struct mhi_device_ctxt *mhi_dev_ctxt,
break;
}
ctxt_del_element(mhi_dev_ctxt->mhi_local_cmd_ctxt, NULL);
return MHI_STATUS_SUCCESS;
return 0;
}
int mhi_poll_inbound(struct mhi_client_handle *client_handle,
@ -1489,12 +1483,11 @@ int mhi_poll_inbound(struct mhi_client_handle *client_handle,
{
struct mhi_tx_pkt *pending_trb = 0;
struct mhi_device_ctxt *mhi_dev_ctxt = NULL;
u32 chan = 0;
struct mhi_ring *local_chan_ctxt;
struct mhi_ring *local_chan_ctxt = NULL;
struct mutex *chan_mutex = NULL;
int r = 0;
struct mhi_ring *bb_ctxt;
struct mhi_buf_info *bb;
struct mhi_ring *bb_ctxt = NULL;
struct mhi_buf_info *bb = NULL;
int chan = 0, r = 0;
if (!client_handle || !result || !client_handle->mhi_dev_ctxt)
return -EINVAL;
@ -1557,7 +1550,7 @@ int validate_ring_el_addr(struct mhi_ring *ring, uintptr_t addr)
-ERANGE : 0;
}
enum MHI_STATUS mhi_wait_for_mdm(struct mhi_device_ctxt *mhi_dev_ctxt)
int mhi_wait_for_mdm(struct mhi_device_ctxt *mhi_dev_ctxt)
{
u32 j = 0;
@ -1565,20 +1558,22 @@ enum MHI_STATUS mhi_wait_for_mdm(struct mhi_device_ctxt *mhi_dev_ctxt)
== 0xFFFFFFFF
&& j <= MHI_MAX_LINK_RETRIES) {
mhi_log(MHI_MSG_CRITICAL,
"Could not access MDM retry %d\n", j);
"Could not access device retry %d\n", j);
msleep(MHI_LINK_STABILITY_WAIT_MS);
if (MHI_MAX_LINK_RETRIES == j) {
mhi_log(MHI_MSG_CRITICAL,
"Could not access MDM, FAILING!\n");
return MHI_STATUS_ERROR;
"Could not access device, FAILING!\n");
return -ETIME;
}
j++;
}
return MHI_STATUS_SUCCESS;
return 0;
}
int mhi_get_max_desc(struct mhi_client_handle *client_handle)
{
if (!client_handle)
return -EINVAL;
return client_handle->chan_info.max_desc - 1;
}
EXPORT_SYMBOL(mhi_get_max_desc);
@ -1640,13 +1635,13 @@ int mhi_set_bus_request(struct mhi_device_ctxt *mhi_dev_ctxt,
index);
}
enum MHI_STATUS mhi_deregister_channel(struct mhi_client_handle
int mhi_deregister_channel(struct mhi_client_handle
*client_handle) {
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int ret_val = 0;
int chan;
if (!client_handle || client_handle->magic != MHI_HANDLE_MAGIC)
return MHI_STATUS_ERROR;
return -EINVAL;
chan = client_handle->chan_info.chan_nr;
client_handle->magic = 0;
client_handle->mhi_dev_ctxt->client_handle_list[chan] = NULL;

29
drivers/platform/msm/mhi/mhi_mmio_ops.c
View file

@ -1,4 +1,4 @@
/* Copyright (c) 2014-2015, The Linux Foundation. All rights reserved.
/* Copyright (c) 2014-2016, 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
@ -13,7 +13,7 @@
#include "mhi_hwio.h"
#include "mhi.h"
enum MHI_STATUS mhi_test_for_device_reset(struct mhi_device_ctxt *mhi_dev_ctxt)
int mhi_test_for_device_reset(struct mhi_device_ctxt *mhi_dev_ctxt)
{
u32 pcie_word_val = 0;
u32 expiry_counter;
@ -25,7 +25,7 @@ enum MHI_STATUS mhi_test_for_device_reset(struct mhi_device_ctxt *mhi_dev_ctxt)
MHICTRL_RESET_MASK,
MHICTRL_RESET_SHIFT);
if (pcie_word_val == 0xFFFFFFFF)
return MHI_STATUS_LINK_DOWN;
return -ENOTCONN;
while (MHI_STATE_RESET != pcie_word_val && expiry_counter < 100) {
expiry_counter++;
mhi_log(MHI_MSG_ERROR,
@ -39,11 +39,11 @@ enum MHI_STATUS mhi_test_for_device_reset(struct mhi_device_ctxt *mhi_dev_ctxt)
}
if (MHI_STATE_READY != pcie_word_val)
return MHI_STATUS_DEVICE_NOT_READY;
return MHI_STATUS_SUCCESS;
return -ENOTCONN;
return 0;
}
enum MHI_STATUS mhi_test_for_device_ready(struct mhi_device_ctxt *mhi_dev_ctxt)
int mhi_test_for_device_ready(struct mhi_device_ctxt *mhi_dev_ctxt)
{
u32 pcie_word_val = 0;
u32 expiry_counter;
@ -58,7 +58,7 @@ enum MHI_STATUS mhi_test_for_device_ready(struct mhi_device_ctxt *mhi_dev_ctxt)
MHISTATUS_READY_SHIFT);
if (pcie_word_val == 0xFFFFFFFF)
return MHI_STATUS_LINK_DOWN;
return -ENOTCONN;
expiry_counter = 0;
while (MHI_STATE_READY != pcie_word_val && expiry_counter < 50) {
expiry_counter++;
@ -72,16 +72,16 @@ enum MHI_STATUS mhi_test_for_device_ready(struct mhi_device_ctxt *mhi_dev_ctxt)
}
if (pcie_word_val != MHI_STATE_READY)
return MHI_STATUS_DEVICE_NOT_READY;
return MHI_STATUS_SUCCESS;
return -ETIMEDOUT;
return 0;
}
enum MHI_STATUS mhi_init_mmio(struct mhi_device_ctxt *mhi_dev_ctxt)
int mhi_init_mmio(struct mhi_device_ctxt *mhi_dev_ctxt)
{
u64 pcie_dword_val = 0;
u32 pcie_word_val = 0;
u32 i = 0;
enum MHI_STATUS ret_val;
int ret_val;
mhi_log(MHI_MSG_INFO, "~~~ Initializing MMIO ~~~\n");
mhi_dev_ctxt->mmio_info.mmio_addr = mhi_dev_ctxt->dev_props->bar0_base;
@ -95,7 +95,7 @@ enum MHI_STATUS mhi_init_mmio(struct mhi_device_ctxt *mhi_dev_ctxt)
if (0 == mhi_dev_ctxt->mmio_info.mmio_len) {
mhi_log(MHI_MSG_ERROR, "Received mmio length as zero\n");
return MHI_STATUS_ERROR;
return -EIO;
}
mhi_log(MHI_MSG_INFO, "Testing MHI Ver\n");
@ -104,11 +104,10 @@ enum MHI_STATUS mhi_init_mmio(struct mhi_device_ctxt *mhi_dev_ctxt)
if (MHI_VERSION != mhi_dev_ctxt->dev_props->mhi_ver) {
mhi_log(MHI_MSG_CRITICAL, "Bad MMIO version, 0x%x\n",
mhi_dev_ctxt->dev_props->mhi_ver);
if (mhi_dev_ctxt->dev_props->mhi_ver == 0xFFFFFFFF)
ret_val = mhi_wait_for_mdm(mhi_dev_ctxt);
if (ret_val)
return MHI_STATUS_ERROR;
return ret_val;
}
/* Enable the channels */
for (i = 0; i < MHI_MAX_CHANNELS; ++i) {
@ -246,6 +245,6 @@ enum MHI_STATUS mhi_init_mmio(struct mhi_device_ctxt *mhi_dev_ctxt)
MHIDATALIMIT_LOWER_MHIDATALIMIT_LOWER_SHIFT,
pcie_word_val);
mhi_log(MHI_MSG_INFO, "Done..\n");
return MHI_STATUS_SUCCESS;
return 0;
}

45
drivers/platform/msm/mhi/mhi_pm.c
View file

@ -65,10 +65,13 @@ int mhi_runtime_suspend(struct device *dev)
int r = 0;
struct mhi_device_ctxt *mhi_dev_ctxt = dev->platform_data;
mhi_log(MHI_MSG_INFO, "Runtime Suspend - Entered\n");
mhi_log(MHI_MSG_INFO, "Entered\n");
r = mhi_initiate_m3(mhi_dev_ctxt);
if (r)
mhi_log(MHI_MSG_ERROR, "Init M3 failed ret %d\n", r);
pm_runtime_mark_last_busy(dev);
mhi_log(MHI_MSG_INFO, "Runtime Suspend - Exited\n");
mhi_log(MHI_MSG_INFO, "Exited\n");
return r;
}
@ -77,10 +80,12 @@ int mhi_runtime_resume(struct device *dev)
int r = 0;
struct mhi_device_ctxt *mhi_dev_ctxt = dev->platform_data;
mhi_log(MHI_MSG_INFO, "Runtime Resume - Entered\n");
mhi_log(MHI_MSG_INFO, "Entered\n");
r = mhi_initiate_m0(mhi_dev_ctxt);
if (r)
mhi_log(MHI_MSG_ERROR, "Init M0 failed ret %d\n", r);
pm_runtime_mark_last_busy(dev);
mhi_log(MHI_MSG_INFO, "Runtime Resume - Exited\n");
mhi_log(MHI_MSG_INFO, "Exited\n");
return r;
}
@ -88,6 +93,7 @@ int mhi_pci_resume(struct device *dev)
{
int r = 0;
struct mhi_device_ctxt *mhi_dev_ctxt = dev->platform_data;
r = mhi_initiate_m0(mhi_dev_ctxt);
if (r)
goto exit;
@ -139,9 +145,10 @@ ssize_t sysfs_init_m3(struct device *dev, struct device_attribute *attr,
"Failed to suspend %d\n", r);
return r;
}
if (MHI_STATUS_SUCCESS != mhi_turn_off_pcie_link(mhi_dev_ctxt))
r = mhi_turn_off_pcie_link(mhi_dev_ctxt);
if (r)
mhi_log(MHI_MSG_CRITICAL,
"Failed to turn off link\n");
"Failed to turn off link ret %d\n", r);
return count;
}
@ -150,14 +157,14 @@ ssize_t sysfs_init_mhi_reset(struct device *dev, struct device_attribute *attr,
{
struct mhi_device_ctxt *mhi_dev_ctxt =
&mhi_devices.device_list[0].mhi_ctxt;
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int r = 0;
mhi_log(MHI_MSG_INFO, "Triggering MHI Reset.\n");
ret_val = mhi_trigger_reset(mhi_dev_ctxt);
if (ret_val != MHI_STATUS_SUCCESS)
r = mhi_trigger_reset(mhi_dev_ctxt);
if (r != 0)
mhi_log(MHI_MSG_CRITICAL,
"Failed to trigger MHI RESET ret %d\n",
ret_val);
r);
else
mhi_log(MHI_MSG_INFO, "Triggered! MHI RESET\n");
return count;
@ -167,7 +174,7 @@ ssize_t sysfs_init_m0(struct device *dev, struct device_attribute *attr,
{
struct mhi_device_ctxt *mhi_dev_ctxt =
&mhi_devices.device_list[0].mhi_ctxt;
if (MHI_STATUS_SUCCESS != mhi_turn_on_pcie_link(mhi_dev_ctxt)) {
if (0 != mhi_turn_on_pcie_link(mhi_dev_ctxt)) {
mhi_log(MHI_MSG_CRITICAL,
"Failed to resume link\n");
return count;
@ -180,11 +187,10 @@ ssize_t sysfs_init_m0(struct device *dev, struct device_attribute *attr,
return count;
}
enum MHI_STATUS mhi_turn_off_pcie_link(struct mhi_device_ctxt *mhi_dev_ctxt)
int mhi_turn_off_pcie_link(struct mhi_device_ctxt *mhi_dev_ctxt)
{
int r;
struct pci_dev *pcie_dev;
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int r = 0;
mhi_log(MHI_MSG_INFO, "Entered...\n");
pcie_dev = mhi_dev_ctxt->dev_info->pcie_device;
@ -204,7 +210,6 @@ enum MHI_STATUS mhi_turn_off_pcie_link(struct mhi_device_ctxt *mhi_dev_ctxt)
if (r) {
mhi_log(MHI_MSG_CRITICAL,
"Failed to set pcie power state to D3 hotret: %x\n", r);
ret_val = MHI_STATUS_ERROR;
goto exit;
}
r = msm_pcie_pm_control(MSM_PCIE_SUSPEND,
@ -219,14 +224,13 @@ enum MHI_STATUS mhi_turn_off_pcie_link(struct mhi_device_ctxt *mhi_dev_ctxt)
exit:
mutex_unlock(&mhi_dev_ctxt->mhi_link_state);
mhi_log(MHI_MSG_INFO, "Exited...\n");
return MHI_STATUS_SUCCESS;
return 0;
}
enum MHI_STATUS mhi_turn_on_pcie_link(struct mhi_device_ctxt *mhi_dev_ctxt)
int mhi_turn_on_pcie_link(struct mhi_device_ctxt *mhi_dev_ctxt)
{
int r = 0;
struct pci_dev *pcie_dev;
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
pcie_dev = mhi_dev_ctxt->dev_info->pcie_device;
@ -241,7 +245,6 @@ enum MHI_STATUS mhi_turn_on_pcie_link(struct mhi_device_ctxt *mhi_dev_ctxt)
if (r) {
mhi_log(MHI_MSG_CRITICAL,
"Failed to resume pcie bus ret %d\n", r);
ret_val = MHI_STATUS_ERROR;
goto exit;
}
@ -250,20 +253,18 @@ enum MHI_STATUS mhi_turn_on_pcie_link(struct mhi_device_ctxt *mhi_dev_ctxt)
if (r) {
mhi_log(MHI_MSG_CRITICAL,
"Failed to load stored state %d\n", r);
ret_val = MHI_STATUS_ERROR;
goto exit;
}
r = msm_pcie_recover_config(mhi_dev_ctxt->dev_info->pcie_device);
if (r) {
mhi_log(MHI_MSG_CRITICAL,
"Failed to Recover config space ret: %d\n", r);
ret_val = MHI_STATUS_ERROR;
goto exit;
}
mhi_dev_ctxt->flags.link_up = 1;
exit:
mutex_unlock(&mhi_dev_ctxt->mhi_link_state);
mhi_log(MHI_MSG_INFO, "Exited...\n");
return ret_val;
return r;
}

30
drivers/platform/msm/mhi/mhi_ring_ops.c
View file

@ -1,4 +1,4 @@
/* Copyright (c) 2014-2015, The Linux Foundation. All rights reserved.
/* Copyright (c) 2014-2016, 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
@ -123,11 +123,11 @@ int get_nr_avail_ring_elements(struct mhi_ring *ring)
{
u32 nr_el = 0;
uintptr_t ring_size = 0;
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int ret_val = 0;
ring_size = ring->len / ring->el_size;
ret_val = get_nr_enclosed_el(ring, ring->rp, ring->wp, &nr_el);
if (ret_val != MHI_STATUS_SUCCESS) {
if (ret_val != 0) {
mhi_log(MHI_MSG_ERROR,
"Failed to get enclosed el ret %d.\n", ret_val);
return 0;
@ -135,26 +135,28 @@ int get_nr_avail_ring_elements(struct mhi_ring *ring)
return ring_size - nr_el - 1;
}
enum MHI_STATUS get_nr_enclosed_el(struct mhi_ring *ring, void *rp,
int get_nr_enclosed_el(struct mhi_ring *ring, void *rp,
void *wp, u32 *nr_el)
{
uintptr_t index_rp = 0;
uintptr_t index_wp = 0;
uintptr_t ring_size = 0;
int r = 0;
if (0 == ring->el_size || NULL == ring ||
NULL == ring->base || 0 == ring->len) {
mhi_log(MHI_MSG_ERROR, "Bad input parameters, quitting.\n");
return MHI_STATUS_ERROR;
return -EINVAL;
}
if (MHI_STATUS_SUCCESS != get_element_index(ring, rp, &index_rp)) {
r = get_element_index(ring, rp, &index_rp);
if (r) {
mhi_log(MHI_MSG_CRITICAL, "Bad element index rp 0x%p.\n", rp);
return MHI_STATUS_ERROR;
return r;
}
if (MHI_STATUS_SUCCESS != get_element_index(ring, wp, &index_wp)) {
r = get_element_index(ring, wp, &index_wp);
if (r) {
mhi_log(MHI_MSG_CRITICAL, "Bad element index wp 0x%p.\n", wp);
return MHI_STATUS_ERROR;
return r;
}
ring_size = ring->len / ring->el_size;
@ -164,7 +166,7 @@ enum MHI_STATUS get_nr_enclosed_el(struct mhi_ring *ring, void *rp,
*nr_el = ring_size - (index_rp - index_wp);
else
*nr_el = 0;
return MHI_STATUS_SUCCESS;
return 0;
}
int get_element_index(struct mhi_ring *ring,
@ -178,15 +180,15 @@ int get_element_index(struct mhi_ring *ring,
return r;
}
enum MHI_STATUS get_element_addr(struct mhi_ring *ring,
int get_element_addr(struct mhi_ring *ring,
uintptr_t index, void **address)
{
uintptr_t ring_size = 0;
if (NULL == ring || NULL == address)
return MHI_STATUS_ERROR;
return -EINVAL;
ring_size = ring->len / ring->el_size;
*address = (void *)((uintptr_t)ring->base +
(index % ring_size) * ring->el_size);
return MHI_STATUS_SUCCESS;
return 0;
}

20
drivers/platform/msm/mhi/mhi_ssr.c
View file

@ -1,4 +1,4 @@
/* Copyright (c) 2014-2015, The Linux Foundation. All rights reserved.
/* Copyright (c) 2014-2016, 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
@ -35,7 +35,7 @@ static int mhi_ssr_notify_cb(struct notifier_block *nb,
"Received Subsystem event BEFORE_POWERUP\n");
atomic_set(&mhi_dev_ctxt->flags.pending_powerup, 1);
ret_val = init_mhi_base_state(mhi_dev_ctxt);
if (MHI_STATUS_SUCCESS != ret_val)
if (0 != ret_val)
mhi_log(MHI_MSG_CRITICAL,
"Failed to transition to base state %d.\n",
ret_val);
@ -164,7 +164,7 @@ void mhi_notify_clients(struct mhi_device_ctxt *mhi_dev_ctxt,
void mhi_link_state_cb(struct msm_pcie_notify *notify)
{
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int ret_val = 0;
struct mhi_pcie_dev_info *mhi_pcie_dev = notify->data;
struct mhi_device_ctxt *mhi_dev_ctxt = NULL;
int r = 0;
@ -219,7 +219,7 @@ void mhi_link_state_cb(struct msm_pcie_notify *notify)
}
ret_val = mhi_init_state_transition(mhi_dev_ctxt,
STATE_TRANSITION_WAKE);
if (MHI_STATUS_SUCCESS != ret_val) {
if (0 != ret_val) {
mhi_log(MHI_MSG_CRITICAL,
"Failed to init state transition, to %d\n",
STATE_TRANSITION_WAKE);
@ -232,24 +232,22 @@ void mhi_link_state_cb(struct msm_pcie_notify *notify)
}
}
enum MHI_STATUS init_mhi_base_state(struct mhi_device_ctxt *mhi_dev_ctxt)
int init_mhi_base_state(struct mhi_device_ctxt *mhi_dev_ctxt)
{
int r = 0;
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
mhi_assert_device_wake(mhi_dev_ctxt);
mhi_dev_ctxt->flags.link_up = 1;
r =
mhi_set_bus_request(mhi_dev_ctxt, 1);
r = mhi_set_bus_request(mhi_dev_ctxt, 1);
if (r)
mhi_log(MHI_MSG_INFO,
"Failed to scale bus request to active set.\n");
ret_val = mhi_init_state_transition(mhi_dev_ctxt,
r = mhi_init_state_transition(mhi_dev_ctxt,
mhi_dev_ctxt->base_state);
if (MHI_STATUS_SUCCESS != ret_val) {
if (r) {
mhi_log(MHI_MSG_CRITICAL,
"Failed to start state change event, to %d\n",
mhi_dev_ctxt->base_state);
}
return ret_val;
return r;
}

282
drivers/platform/msm/mhi/mhi_states.c
View file

@ -129,12 +129,12 @@ static void ring_all_ev_dbs(struct mhi_device_ctxt *mhi_dev_ctxt)
}
}
static enum MHI_STATUS process_m0_transition(
static int process_m0_transition(
struct mhi_device_ctxt *mhi_dev_ctxt,
enum STATE_TRANSITION cur_work_item)
{
unsigned long flags;
int ret_val;
int r = 0;
mhi_log(MHI_MSG_INFO, "Entered\n");
@ -166,11 +166,11 @@ static enum MHI_STATUS process_m0_transition(
ring_all_cmd_dbs(mhi_dev_ctxt);
}
atomic_dec(&mhi_dev_ctxt->flags.data_pending);
ret_val = mhi_set_bus_request(mhi_dev_ctxt, 1);
if (ret_val)
r = mhi_set_bus_request(mhi_dev_ctxt, 1);
if (r)
mhi_log(MHI_MSG_CRITICAL,
"Could not set bus frequency ret: %d\n",
ret_val);
r);
mhi_dev_ctxt->flags.pending_M0 = 0;
if (atomic_read(&mhi_dev_ctxt->flags.pending_powerup)) {
atomic_set(&mhi_dev_ctxt->flags.pending_ssr, 0);
@ -185,15 +185,14 @@ static enum MHI_STATUS process_m0_transition(
write_unlock_irqrestore(&mhi_dev_ctxt->xfer_lock, flags);
mhi_log(MHI_MSG_INFO, "Exited\n");
return MHI_STATUS_SUCCESS;
return 0;
}
static enum MHI_STATUS process_m1_transition(
static int process_m1_transition(
struct mhi_device_ctxt *mhi_dev_ctxt,
enum STATE_TRANSITION cur_work_item)
{
unsigned long flags = 0;
int ret_val = 0;
int r = 0;
mhi_log(MHI_MSG_INFO,
@ -210,8 +209,8 @@ static enum MHI_STATUS process_m1_transition(
mhi_dev_ctxt->counters.m1_m2++;
}
write_unlock_irqrestore(&mhi_dev_ctxt->xfer_lock, flags);
ret_val = mhi_set_bus_request(mhi_dev_ctxt, 0);
if (ret_val)
r = mhi_set_bus_request(mhi_dev_ctxt, 0);
if (r)
mhi_log(MHI_MSG_INFO, "Failed to update bus request\n");
mhi_log(MHI_MSG_INFO, "Debouncing M2\n");
@ -228,7 +227,7 @@ static enum MHI_STATUS process_m1_transition(
&mhi_dev_ctxt->dev_info->pcie_device->dev);
r = pm_request_autosuspend(
&mhi_dev_ctxt->dev_info->pcie_device->dev);
if (r) {
if (r && r != -EAGAIN) {
mhi_log(MHI_MSG_ERROR,
"Failed to remove counter ret %d\n", r);
BUG_ON(mhi_dev_ctxt->dev_info->
@ -240,10 +239,10 @@ static enum MHI_STATUS process_m1_transition(
write_unlock_irqrestore(&mhi_dev_ctxt->xfer_lock, flags);
BUG_ON(atomic_read(&mhi_dev_ctxt->outbound_acks) < 0);
return MHI_STATUS_SUCCESS;
return 0;
}
static enum MHI_STATUS process_m3_transition(
static int process_m3_transition(
struct mhi_device_ctxt *mhi_dev_ctxt,
enum STATE_TRANSITION cur_work_item)
{
@ -257,10 +256,10 @@ static enum MHI_STATUS process_m3_transition(
wake_up_interruptible(mhi_dev_ctxt->mhi_ev_wq.m3_event);
write_unlock_irqrestore(&mhi_dev_ctxt->xfer_lock, flags);
mhi_dev_ctxt->counters.m0_m3++;
return MHI_STATUS_SUCCESS;
return 0;
}
static enum MHI_STATUS mhi_process_link_down(
static int mhi_process_link_down(
struct mhi_device_ctxt *mhi_dev_ctxt)
{
unsigned long flags;
@ -268,7 +267,7 @@ static enum MHI_STATUS mhi_process_link_down(
mhi_log(MHI_MSG_INFO, "Entered.\n");
if (NULL == mhi_dev_ctxt)
return MHI_STATUS_ERROR;
return -EINVAL;
write_lock_irqsave(&mhi_dev_ctxt->xfer_lock, flags);
mhi_dev_ctxt->flags.mhi_initialized = 0;
@ -296,28 +295,27 @@ static enum MHI_STATUS mhi_process_link_down(
atomic_set(&mhi_dev_ctxt->flags.data_pending, 0);
mhi_log(MHI_MSG_INFO, "Exited.\n");
return MHI_STATUS_SUCCESS;
return 0;
}
static enum MHI_STATUS process_link_down_transition(
static int process_link_down_transition(
struct mhi_device_ctxt *mhi_dev_ctxt,
enum STATE_TRANSITION cur_work_item)
{
mhi_log(MHI_MSG_INFO, "Entered\n");
if (MHI_STATUS_SUCCESS !=
if (0 !=
mhi_process_link_down(mhi_dev_ctxt)) {
mhi_log(MHI_MSG_CRITICAL,
"Failed to process link down\n");
}
mhi_log(MHI_MSG_INFO, "Exited.\n");
return MHI_STATUS_SUCCESS;
return 0;
}
static enum MHI_STATUS process_wake_transition(
static int process_wake_transition(
struct mhi_device_ctxt *mhi_dev_ctxt,
enum STATE_TRANSITION cur_work_item)
{
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int r = 0;
mhi_log(MHI_MSG_INFO, "Entered\n");
@ -338,21 +336,21 @@ static enum MHI_STATUS process_wake_transition(
if (!mhi_dev_ctxt->flags.mhi_initialized) {
mhi_log(MHI_MSG_INFO,
"MHI is not initialized transitioning to base.\n");
ret_val = init_mhi_base_state(mhi_dev_ctxt);
if (MHI_STATUS_SUCCESS != ret_val)
r = init_mhi_base_state(mhi_dev_ctxt);
if (0 != r)
mhi_log(MHI_MSG_CRITICAL,
"Failed to transition to base state %d.\n",
ret_val);
r);
}
exit:
__pm_relax(&mhi_dev_ctxt->w_lock);
mhi_log(MHI_MSG_INFO, "Exited.\n");
return ret_val;
return r;
}
static enum MHI_STATUS process_bhi_transition(
static int process_bhi_transition(
struct mhi_device_ctxt *mhi_dev_ctxt,
enum STATE_TRANSITION cur_work_item)
{
@ -361,37 +359,37 @@ static enum MHI_STATUS process_bhi_transition(
mhi_dev_ctxt->mhi_state = MHI_STATE_BHI;
wake_up_interruptible(mhi_dev_ctxt->mhi_ev_wq.bhi_event);
mhi_log(MHI_MSG_INFO, "Exited\n");
return MHI_STATUS_SUCCESS;
return 0;
}
static enum MHI_STATUS process_ready_transition(
static int process_ready_transition(
struct mhi_device_ctxt *mhi_dev_ctxt,
enum STATE_TRANSITION cur_work_item)
{
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int r = 0;
mhi_log(MHI_MSG_INFO, "Processing READY state transition\n");
mhi_dev_ctxt->mhi_state = MHI_STATE_READY;
ret_val = mhi_reset_all_thread_queues(mhi_dev_ctxt);
r = mhi_reset_all_thread_queues(mhi_dev_ctxt);
if (MHI_STATUS_SUCCESS != ret_val)
if (r)
mhi_log(MHI_MSG_ERROR,
"Failed to reset thread queues\n");
r = mhi_init_mmio(mhi_dev_ctxt);
/* Initialize MMIO */
if (MHI_STATUS_SUCCESS != mhi_init_mmio(mhi_dev_ctxt)) {
if (r) {
mhi_log(MHI_MSG_ERROR,
"Failure during MMIO initialization\n");
return MHI_STATUS_ERROR;
return r;
}
ret_val = mhi_add_elements_to_event_rings(mhi_dev_ctxt,
r = mhi_add_elements_to_event_rings(mhi_dev_ctxt,
cur_work_item);
if (MHI_STATUS_SUCCESS != ret_val) {
if (r) {
mhi_log(MHI_MSG_ERROR,
"Failure during event ring init\n");
return MHI_STATUS_ERROR;
return r;
}
mhi_dev_ctxt->flags.stop_threads = 0;
@ -401,7 +399,7 @@ static enum MHI_STATUS process_ready_transition(
MHICTRL_MHISTATE_MASK,
MHICTRL_MHISTATE_SHIFT,
MHI_STATE_M0);
return MHI_STATUS_SUCCESS;
return r;
}
static void mhi_reset_chan_ctxt(struct mhi_device_ctxt *mhi_dev_ctxt,
@ -418,12 +416,11 @@ static void mhi_reset_chan_ctxt(struct mhi_device_ctxt *mhi_dev_ctxt,
local_chan_ctxt->ack_rp = local_chan_ctxt->base;
}
static enum MHI_STATUS process_reset_transition(
static int process_reset_transition(
struct mhi_device_ctxt *mhi_dev_ctxt,
enum STATE_TRANSITION cur_work_item)
{
u32 i = 0;
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int r = 0, i = 0;
unsigned long flags = 0;
mhi_log(MHI_MSG_INFO, "Processing RESET state transition\n");
@ -432,18 +429,20 @@ static enum MHI_STATUS process_reset_transition(
write_unlock_irqrestore(&mhi_dev_ctxt->xfer_lock, flags);
mhi_dev_ctxt->counters.mhi_reset_cntr++;
mhi_dev_ctxt->dev_exec_env = MHI_EXEC_ENV_PBL;
ret_val = mhi_test_for_device_reset(mhi_dev_ctxt);
ret_val = mhi_test_for_device_ready(mhi_dev_ctxt);
switch (ret_val) {
case MHI_STATUS_SUCCESS:
r = mhi_test_for_device_reset(mhi_dev_ctxt);
if (r)
mhi_log(MHI_MSG_INFO, "Device not RESET ret %d\n", r);
r = mhi_test_for_device_ready(mhi_dev_ctxt);
switch (r) {
case 0:
break;
case MHI_STATUS_LINK_DOWN:
case -ENOTCONN:
mhi_log(MHI_MSG_CRITICAL, "Link down detected\n");
break;
case MHI_STATUS_DEVICE_NOT_READY:
ret_val = mhi_init_state_transition(mhi_dev_ctxt,
case -ETIMEDOUT:
r = mhi_init_state_transition(mhi_dev_ctxt,
STATE_TRANSITION_RESET);
if (MHI_STATUS_SUCCESS != ret_val)
if (0 != r)
mhi_log(MHI_MSG_CRITICAL,
"Failed to initiate 0x%x state trans\n",
STATE_TRANSITION_RESET);
@ -472,49 +471,47 @@ static enum MHI_STATUS process_reset_transition(
if (VALID_CHAN_NR(i))
mhi_reset_chan_ctxt(mhi_dev_ctxt, i);
}
ret_val = mhi_init_state_transition(mhi_dev_ctxt,
r = mhi_init_state_transition(mhi_dev_ctxt,
STATE_TRANSITION_READY);
if (MHI_STATUS_SUCCESS != ret_val)
if (0 != r)
mhi_log(MHI_MSG_CRITICAL,
"Failed to initiate 0x%x state trans\n",
STATE_TRANSITION_READY);
return ret_val;
return r;
}
static enum MHI_STATUS process_syserr_transition(
static int process_syserr_transition(
struct mhi_device_ctxt *mhi_dev_ctxt,
enum STATE_TRANSITION cur_work_item)
{
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
mhi_log(MHI_MSG_CRITICAL, "Received SYS ERROR. Resetting MHI\n");
if (MHI_STATUS_SUCCESS != ret_val) {
mhi_log(MHI_MSG_CRITICAL, "Failed to reset mhi\n");
return MHI_STATUS_ERROR;
}
mhi_dev_ctxt->mhi_state = MHI_STATE_RESET;
if (MHI_STATUS_SUCCESS != mhi_init_state_transition(mhi_dev_ctxt,
STATE_TRANSITION_RESET))
mhi_log(MHI_MSG_ERROR,
"Failed to init state transition to RESET.\n");
return ret_val;
}
enum MHI_STATUS start_chan_sync(struct mhi_client_handle *client_handle)
{
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int chan = client_handle->chan_info.chan_nr;
int r = 0;
mhi_log(MHI_MSG_CRITICAL, "Received SYS ERROR. Resetting MHI\n");
mhi_dev_ctxt->mhi_state = MHI_STATE_RESET;
r = mhi_init_state_transition(mhi_dev_ctxt,
STATE_TRANSITION_RESET);
if (r) {
mhi_log(MHI_MSG_ERROR,
"Failed to init state transition to RESET ret %d\n", r);
mhi_log(MHI_MSG_CRITICAL, "Failed to reset mhi\n");
}
return r;
}
int start_chan_sync(struct mhi_client_handle *client_handle)
{
int r = 0;
int chan = client_handle->chan_info.chan_nr;
init_completion(&client_handle->chan_open_complete);
ret_val = mhi_send_cmd(client_handle->mhi_dev_ctxt,
r = mhi_send_cmd(client_handle->mhi_dev_ctxt,
MHI_COMMAND_START_CHAN,
chan);
if (ret_val != MHI_STATUS_SUCCESS) {
if (r != 0) {
mhi_log(MHI_MSG_ERROR,
"Failed to send start command for chan %d ret %d\n",
chan, ret_val);
return ret_val;
chan, r);
return r;
}
r = wait_for_completion_timeout(
&client_handle->chan_open_complete,
@ -523,9 +520,9 @@ enum MHI_STATUS start_chan_sync(struct mhi_client_handle *client_handle)
mhi_log(MHI_MSG_ERROR,
"Timed out waiting for chan %d start completion\n",
chan);
ret_val = MHI_STATUS_ERROR;
r = -ETIME;
}
return ret_val;
return 0;
}
static void enable_clients(struct mhi_device_ctxt *mhi_dev_ctxt,
@ -533,9 +530,8 @@ static void enable_clients(struct mhi_device_ctxt *mhi_dev_ctxt,
{
struct mhi_client_handle *client_handle = NULL;
struct mhi_cb_info cb_info;
int i;
int i = 0, r = 0;
struct mhi_chan_info chan_info;
int r;
cb_info.cb_reason = MHI_CB_MHI_ENABLED;
@ -555,69 +551,53 @@ static void enable_clients(struct mhi_device_ctxt *mhi_dev_ctxt,
mhi_log(MHI_MSG_INFO, "Done.\n");
}
static enum MHI_STATUS process_sbl_transition(
static int process_sbl_transition(
struct mhi_device_ctxt *mhi_dev_ctxt,
enum STATE_TRANSITION cur_work_item)
{
int r;
pm_runtime_set_autosuspend_delay(
&mhi_dev_ctxt->dev_info->pcie_device->dev,
MHI_RPM_AUTOSUSPEND_TMR_VAL_MS);
pm_runtime_use_autosuspend(&mhi_dev_ctxt->dev_info->pcie_device->dev);
r = pm_runtime_set_active(&mhi_dev_ctxt->dev_info->pcie_device->dev);
if (r) {
mhi_log(MHI_MSG_ERROR,
"Failed to activate runtime pm ret %d\n", r);
}
pm_runtime_enable(&mhi_dev_ctxt->dev_info->pcie_device->dev);
pm_runtime_put_noidle(&mhi_dev_ctxt->dev_info->pcie_device->dev);
mhi_log(MHI_MSG_INFO, "Enabled runtime pm\n");
mhi_log(MHI_MSG_INFO, "Enabled runtime pm autosuspend\n");
mhi_dev_ctxt->dev_exec_env = MHI_EXEC_ENV_SBL;
enable_clients(mhi_dev_ctxt, mhi_dev_ctxt->dev_exec_env);
return MHI_STATUS_SUCCESS;
return 0;
}
static enum MHI_STATUS process_amss_transition(
static int process_amss_transition(
struct mhi_device_ctxt *mhi_dev_ctxt,
enum STATE_TRANSITION cur_work_item)
{
enum MHI_STATUS ret_val;
int r = 0, i = 0;
struct mhi_client_handle *client_handle = NULL;
int i = 0;
mhi_log(MHI_MSG_INFO, "Processing AMSS state transition\n");
mhi_dev_ctxt->dev_exec_env = MHI_EXEC_ENV_AMSS;
atomic_inc(&mhi_dev_ctxt->flags.data_pending);
mhi_assert_device_wake(mhi_dev_ctxt);
if (0 == mhi_dev_ctxt->flags.mhi_initialized) {
ret_val = mhi_add_elements_to_event_rings(mhi_dev_ctxt,
if (!mhi_dev_ctxt->flags.mhi_initialized) {
r = mhi_add_elements_to_event_rings(mhi_dev_ctxt,
cur_work_item);
if (MHI_STATUS_SUCCESS != ret_val)
return MHI_STATUS_ERROR;
mhi_dev_ctxt->flags.mhi_initialized = 1;
if (MHI_STATUS_SUCCESS != ret_val)
if (r) {
mhi_log(MHI_MSG_CRITICAL,
"Failed to set local chan state\n");
ring_all_chan_dbs(mhi_dev_ctxt);
mhi_log(MHI_MSG_INFO,
"Notifying clients that MHI is enabled\n");
if (ret_val != MHI_STATUS_SUCCESS)
mhi_log(MHI_MSG_CRITICAL,
"Failed to probe MHI CORE clients, ret 0x%x\n",
ret_val);
"Failed to set local chan state ret %d\n", r);
return r;
}
ring_all_chan_dbs(mhi_dev_ctxt);
mhi_log(MHI_MSG_INFO,
"Notifying clients that MHI is enabled\n");
enable_clients(mhi_dev_ctxt, mhi_dev_ctxt->dev_exec_env);
} else {
mhi_log(MHI_MSG_INFO, "MHI is initialized\n");
for (i = 0; i < MHI_MAX_CHANNELS; ++i) {
client_handle = mhi_dev_ctxt->client_handle_list[i];
if (client_handle && client_handle->chan_status)
ret_val = start_chan_sync(client_handle);
if (ret_val)
mhi_log(MHI_MSG_ERROR,
"Failed to start chan %d ret %d\n",
i, ret_val);
r = start_chan_sync(client_handle);
WARN(r, "Failed to start chan %d ret %d\n",
i, r);
return r;
}
ring_all_chan_dbs(mhi_dev_ctxt);
}
@ -627,12 +607,12 @@ static enum MHI_STATUS process_amss_transition(
mhi_dev_ctxt->flags.link_up)
mhi_deassert_device_wake(mhi_dev_ctxt);
mhi_log(MHI_MSG_INFO, "Exited\n");
return MHI_STATUS_SUCCESS;
return 0;
}
enum MHI_STATUS mhi_trigger_reset(struct mhi_device_ctxt *mhi_dev_ctxt)
int mhi_trigger_reset(struct mhi_device_ctxt *mhi_dev_ctxt)
{
enum MHI_STATUS ret_val;
int r = 0;
unsigned long flags = 0;
mhi_log(MHI_MSG_INFO, "Entered\n");
@ -643,67 +623,67 @@ enum MHI_STATUS mhi_trigger_reset(struct mhi_device_ctxt *mhi_dev_ctxt)
mhi_log(MHI_MSG_INFO, "Setting RESET to MDM.\n");
mhi_set_m_state(mhi_dev_ctxt, MHI_STATE_RESET);
mhi_log(MHI_MSG_INFO, "Transitioning state to RESET\n");
ret_val = mhi_init_state_transition(mhi_dev_ctxt,
r = mhi_init_state_transition(mhi_dev_ctxt,
STATE_TRANSITION_RESET);
if (MHI_STATUS_SUCCESS != ret_val)
if (0 != r)
mhi_log(MHI_MSG_CRITICAL,
"Failed to initiate 0x%x state trans ret %d\n",
STATE_TRANSITION_RESET, ret_val);
STATE_TRANSITION_RESET, r);
mhi_log(MHI_MSG_INFO, "Exiting\n");
return ret_val;
return r;
}
static enum MHI_STATUS process_stt_work_item(
static int process_stt_work_item(
struct mhi_device_ctxt *mhi_dev_ctxt,
enum STATE_TRANSITION cur_work_item)
{
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int r = 0;
mhi_log(MHI_MSG_INFO, "Transitioning to %d\n",
(int)cur_work_item);
trace_mhi_state(cur_work_item);
switch (cur_work_item) {
case STATE_TRANSITION_BHI:
ret_val = process_bhi_transition(mhi_dev_ctxt, cur_work_item);
r = process_bhi_transition(mhi_dev_ctxt, cur_work_item);
break;
case STATE_TRANSITION_RESET:
ret_val = process_reset_transition(mhi_dev_ctxt, cur_work_item);
r = process_reset_transition(mhi_dev_ctxt, cur_work_item);
break;
case STATE_TRANSITION_READY:
ret_val = process_ready_transition(mhi_dev_ctxt, cur_work_item);
r = process_ready_transition(mhi_dev_ctxt, cur_work_item);
break;
case STATE_TRANSITION_SBL:
ret_val = process_sbl_transition(mhi_dev_ctxt, cur_work_item);
r = process_sbl_transition(mhi_dev_ctxt, cur_work_item);
break;
case STATE_TRANSITION_AMSS:
ret_val = process_amss_transition(mhi_dev_ctxt, cur_work_item);
r = process_amss_transition(mhi_dev_ctxt, cur_work_item);
break;
case STATE_TRANSITION_M0:
ret_val = process_m0_transition(mhi_dev_ctxt, cur_work_item);
r = process_m0_transition(mhi_dev_ctxt, cur_work_item);
break;
case STATE_TRANSITION_M1:
ret_val = process_m1_transition(mhi_dev_ctxt, cur_work_item);
r = process_m1_transition(mhi_dev_ctxt, cur_work_item);
break;
case STATE_TRANSITION_M3:
ret_val = process_m3_transition(mhi_dev_ctxt, cur_work_item);
r = process_m3_transition(mhi_dev_ctxt, cur_work_item);
break;
case STATE_TRANSITION_SYS_ERR:
ret_val = process_syserr_transition(mhi_dev_ctxt,
r = process_syserr_transition(mhi_dev_ctxt,
cur_work_item);
break;
case STATE_TRANSITION_LINK_DOWN:
ret_val = process_link_down_transition(mhi_dev_ctxt,
r = process_link_down_transition(mhi_dev_ctxt,
cur_work_item);
break;
case STATE_TRANSITION_WAKE:
ret_val = process_wake_transition(mhi_dev_ctxt, cur_work_item);
r = process_wake_transition(mhi_dev_ctxt, cur_work_item);
break;
default:
mhi_log(MHI_MSG_ERROR,
"Unrecongized state: %d\n", cur_work_item);
break;
}
return ret_val;
return r;
}
int mhi_state_change_thread(void *ctxt)
@ -712,7 +692,6 @@ int mhi_state_change_thread(void *ctxt)
unsigned long flags = 0;
struct mhi_device_ctxt *mhi_dev_ctxt = (struct mhi_device_ctxt *)ctxt;
enum STATE_TRANSITION cur_work_item;
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
struct mhi_state_work_queue *work_q =
&mhi_dev_ctxt->state_change_work_item_list;
struct mhi_ring *state_change_q = &work_q->q_info;
@ -740,11 +719,11 @@ int mhi_state_change_thread(void *ctxt)
mhi_dev_ctxt->flags.st_thread_stopped = 0;
spin_lock_irqsave(work_q->q_lock, flags);
cur_work_item = *(enum STATE_TRANSITION *)(state_change_q->rp);
ret_val = ctxt_del_element(&work_q->q_info, NULL);
MHI_ASSERT(ret_val == MHI_STATUS_SUCCESS,
r = ctxt_del_element(&work_q->q_info, NULL);
MHI_ASSERT(r == 0,
"Failed to delete element from STT workqueue\n");
spin_unlock_irqrestore(work_q->q_lock, flags);
ret_val = process_stt_work_item(mhi_dev_ctxt, cur_work_item);
r = process_stt_work_item(mhi_dev_ctxt, cur_work_item);
}
return 0;
}
@ -757,13 +736,13 @@ int mhi_state_change_thread(void *ctxt)
* @new_state The state we wish to transition to
*
*/
enum MHI_STATUS mhi_init_state_transition(struct mhi_device_ctxt *mhi_dev_ctxt,
int mhi_init_state_transition(struct mhi_device_ctxt *mhi_dev_ctxt,
enum STATE_TRANSITION new_state)
{
unsigned long flags = 0;
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int r = 0, nr_avail_work_items = 0;
enum STATE_TRANSITION *cur_work_item = NULL;
s32 nr_avail_work_items = 0;
struct mhi_ring *stt_ring =
&mhi_dev_ctxt->state_change_work_item_list.q_info;
struct mhi_state_work_queue *work_q =
@ -772,20 +751,16 @@ enum MHI_STATUS mhi_init_state_transition(struct mhi_device_ctxt *mhi_dev_ctxt,
spin_lock_irqsave(work_q->q_lock, flags);
nr_avail_work_items = get_nr_avail_ring_elements(stt_ring);
if (0 >= nr_avail_work_items) {
mhi_log(MHI_MSG_CRITICAL, "No Room left on STT work queue\n");
return MHI_STATUS_ERROR;
}
BUG_ON(nr_avail_work_items <= 0);
mhi_log(MHI_MSG_VERBOSE,
"Processing state transition %x\n",
new_state);
*(enum STATE_TRANSITION *)stt_ring->wp = new_state;
ret_val = ctxt_add_element(stt_ring, (void **)&cur_work_item);
MHI_ASSERT(MHI_STATUS_SUCCESS == ret_val,
"Failed to add selement to STT workqueue\n");
r = ctxt_add_element(stt_ring, (void **)&cur_work_item);
BUG_ON(r);
spin_unlock_irqrestore(work_q->q_lock, flags);
wake_up_interruptible(mhi_dev_ctxt->mhi_ev_wq.state_change_event);
return ret_val;
return r;
}
int mhi_initiate_m0(struct mhi_device_ctxt *mhi_dev_ctxt)
@ -834,7 +809,7 @@ int mhi_initiate_m0(struct mhi_device_ctxt *mhi_dev_ctxt)
mhi_dev_ctxt->mhi_state);
goto exit;
} else {
if (MHI_STATUS_SUCCESS != mhi_turn_on_pcie_link(mhi_dev_ctxt)) {
if (0 != mhi_turn_on_pcie_link(mhi_dev_ctxt)) {
mhi_log(MHI_MSG_CRITICAL,
"Failed to resume link\n");
r = -EIO;
@ -877,8 +852,7 @@ int mhi_initiate_m3(struct mhi_device_ctxt *mhi_dev_ctxt)
{
unsigned long flags;
int r = 0;
int abort_m3 = 0;
int r = 0, abort_m3 = 0;
mhi_log(MHI_MSG_INFO,
"Entered MHI state %d, Pending M0 %d Pending M3 %d\n",

47
drivers/platform/msm/mhi_uci/mhi_uci.c
View file

@ -26,6 +26,7 @@
#include <linux/ipc_logging.h>
#include <linux/errno.h>
#include <linux/device.h>
#include <linux/errno.h>
#define MHI_DEV_NODE_NAME_LEN 13
#define MHI_MAX_NR_OF_CLIENTS 23
@ -247,10 +248,10 @@ static long mhi_uci_ctl_ioctl(struct file *file, unsigned int cmd,
static struct mhi_uci_ctxt_t uci_ctxt;
static enum MHI_STATUS mhi_init_inbound(struct uci_client *client_handle,
static int mhi_init_inbound(struct uci_client *client_handle,
enum MHI_CLIENT_CHANNEL chan)
{
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int ret_val = 0;
u32 i = 0;
struct chan_attr *chan_attributes =
&uci_ctxt.chan_attrib[chan];
@ -259,7 +260,7 @@ static enum MHI_STATUS mhi_init_inbound(struct uci_client *client_handle,
if (client_handle == NULL) {
uci_log(UCI_DBG_ERROR, "Bad Input data, quitting\n");
return MHI_STATUS_ERROR;
return -EINVAL;
}
chan_attributes->nr_trbs =
mhi_get_free_desc(client_handle->in_handle);
@ -267,7 +268,7 @@ static enum MHI_STATUS mhi_init_inbound(struct uci_client *client_handle,
kmalloc(sizeof(void *) * chan_attributes->nr_trbs,
GFP_KERNEL);
if (!client_handle->in_buf_list)
return MHI_STATUS_ERROR;
return -ENOMEM;
uci_log(UCI_DBG_INFO, "Channel %d supports %d desc\n",
i, chan_attributes->nr_trbs);
@ -280,7 +281,7 @@ static enum MHI_STATUS mhi_init_inbound(struct uci_client *client_handle,
client_handle->in_buf_list[i] = data_loc;
ret_val = mhi_queue_xfer(client_handle->in_handle,
data_loc, buf_size, MHI_EOT);
if (MHI_STATUS_SUCCESS != ret_val) {
if (0 != ret_val) {
kfree(data_loc);
uci_log(UCI_DBG_ERROR,
"Failed insertion for chan %d, ret %d\n",
@ -309,7 +310,7 @@ static int mhi_uci_send_packet(struct mhi_client_handle **client_handle,
if (client_handle == NULL || buf == NULL ||
!size || uci_handle == NULL)
return MHI_STATUS_ERROR;
return -EINVAL;
nr_avail_trbs = mhi_get_free_desc(*client_handle);
@ -389,7 +390,7 @@ static int mhi_uci_send_status_cmd(struct uci_client *client)
"Opening outbound control channel %d\n",
uci_ctrl_handle->out_chan);
ret_val = mhi_open_channel(uci_ctrl_handle->out_handle);
if (MHI_STATUS_SUCCESS != ret_val) {
if (0 != ret_val) {
uci_log(UCI_DBG_CRITICAL,
"Could not open chan %d, for sideband ctrl\n",
client->out_chan);
@ -532,7 +533,7 @@ static unsigned int mhi_uci_client_poll(struct file *file, poll_table *wait)
static int open_client_mhi_channels(struct uci_client *uci_client)
{
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int ret_val = 0;
int r = 0;
uci_log(UCI_DBG_INFO,
"Starting channels %d %d.\n",
@ -541,8 +542,8 @@ static int open_client_mhi_channels(struct uci_client *uci_client)
mutex_lock(&uci_client->out_chan_lock);
mutex_lock(&uci_client->in_chan_lock);
ret_val = mhi_open_channel(uci_client->out_handle);
if (ret_val != MHI_STATUS_SUCCESS) {
if (ret_val == MHI_STATUS_DEVICE_NOT_READY)
if (ret_val != 0) {
if (ret_val == -ENOTCONN)
r = -EAGAIN;
else
r = -EIO;
@ -551,7 +552,7 @@ static int open_client_mhi_channels(struct uci_client *uci_client)
uci_client->out_chan_state = 1;
ret_val = mhi_open_channel(uci_client->in_handle);
if (ret_val != MHI_STATUS_SUCCESS) {
if (ret_val != 0) {
uci_log(UCI_DBG_ERROR,
"Failed to open chan %d, ret 0x%x\n",
uci_client->out_chan, ret_val);
@ -563,7 +564,7 @@ static int open_client_mhi_channels(struct uci_client *uci_client)
uci_client->in_chan_state = 1;
ret_val = mhi_init_inbound(uci_client, uci_client->in_chan);
if (MHI_STATUS_SUCCESS != ret_val) {
if (0 != ret_val) {
uci_log(UCI_DBG_ERROR,
"Failed to init inbound 0x%x, ret 0x%x\n",
uci_client->in_chan, ret_val);
@ -802,7 +803,7 @@ static ssize_t mhi_uci_client_read(struct file *file, char __user *buf,
atomic_read(&uci_handle->avail_pkts));
ret_val = mhi_queue_xfer(client_handle, uci_handle->pkt_loc,
buf_size, MHI_EOT);
if (MHI_STATUS_SUCCESS != ret_val) {
if (0 != ret_val) {
uci_log(UCI_DBG_ERROR,
"Failed to recycle element\n");
ret_val = -EIO;
@ -863,7 +864,7 @@ sys_interrupt:
return ret_val;
}
static enum MHI_STATUS uci_init_client_attributes(struct mhi_uci_ctxt_t
static int uci_init_client_attributes(struct mhi_uci_ctxt_t
*uci_ctxt)
{
u32 i = 0;
@ -906,7 +907,7 @@ static enum MHI_STATUS uci_init_client_attributes(struct mhi_uci_ctxt_t
else
chan_attrib->dir = MHI_DIR_IN;
}
return MHI_STATUS_SUCCESS;
return 0;
}
static int process_mhi_disabled_notif_sync(struct uci_client *uci_handle)
@ -939,11 +940,11 @@ static void process_rs232_state(struct mhi_result *result)
struct rs232_ctrl_msg *rs232_pkt;
struct uci_client *client;
u32 msg_id;
enum MHI_STATUS ret_val;
int ret_val;
u32 chan;
mutex_lock(&uci_ctxt.ctrl_mutex);
if (result->transaction_status != MHI_STATUS_SUCCESS) {
if (result->transaction_status != 0) {
uci_log(UCI_DBG_ERROR,
"Non successful transfer code 0x%x\n",
result->transaction_status);
@ -980,7 +981,7 @@ error_size:
result->buf_addr,
result->bytes_xferd,
result->flags);
if (MHI_STATUS_SUCCESS != ret_val) {
if (0 != ret_val) {
uci_log(UCI_DBG_ERROR,
"Failed to recycle ctrl msg buffer\n");
}
@ -1062,7 +1063,7 @@ static void uci_xfer_cb(struct mhi_cb_info *cb_info)
static int mhi_register_client(struct uci_client *mhi_client, int index)
{
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int ret_val = 0;
uci_log(UCI_DBG_INFO, "Setting up workqueues.\n");
init_waitqueue_head(&mhi_client->read_wq);
@ -1081,7 +1082,7 @@ static int mhi_register_client(struct uci_client *mhi_client, int index)
0,
&uci_ctxt.client_info,
(void *)(uintptr_t)(mhi_client->out_chan));
if (MHI_STATUS_SUCCESS != ret_val)
if (0 != ret_val)
uci_log(UCI_DBG_ERROR,
"Failed to init outbound chan 0x%x, ret 0x%x\n",
mhi_client->out_chan, ret_val);
@ -1092,7 +1093,7 @@ static int mhi_register_client(struct uci_client *mhi_client, int index)
0,
&uci_ctxt.client_info,
(void *)(uintptr_t)(mhi_client->in_chan));
if (MHI_STATUS_SUCCESS != ret_val)
if (0 != ret_val)
uci_log(UCI_DBG_ERROR,
"Failed to init inbound chan 0x%x, ret 0x%x\n",
mhi_client->in_chan, ret_val);
@ -1111,7 +1112,7 @@ static const struct file_operations mhi_uci_client_fops = {
static int mhi_uci_init(void)
{
u32 i = 0;
enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS;
int ret_val = 0;
struct uci_client *mhi_client = NULL;
s32 r = 0;
mhi_uci_ipc_log = ipc_log_context_create(MHI_UCI_IPC_LOG_PAGES,
@ -1127,7 +1128,7 @@ static int mhi_uci_init(void)
uci_log(UCI_DBG_INFO, "Setting up channel attributes.\n");
ret_val = uci_init_client_attributes(&uci_ctxt);
if (MHI_STATUS_SUCCESS != ret_val) {
if (ret_val) {
uci_log(UCI_DBG_ERROR,
"Failed to init client attributes\n");
return -EIO;

38
include/linux/msm_mhi.h
View file

@ -18,28 +18,6 @@ struct mhi_client_handle;
#define MHI_DMA_MASK 0x3FFFFFFF
#define MHI_MAX_MTU 0xFFFF
enum MHI_STATUS {
MHI_STATUS_SUCCESS = 0,
MHI_STATUS_ERROR = 1,
MHI_STATUS_DEV_NOT_FOUND = 2,
MHI_STATUS_RING_FULL = 3,
MHI_STATUS_RING_EMPTY = 4,
MHI_STATUS_ALLOC_ERROR = 5,
MHI_STATUS_OBJ_BUSY = 6,
MHI_STATUS_DEVICE_NOT_READY = 7,
MHI_STATUS_INACTIVE = 8,
MHI_STATUS_BAD_STATE = 9,
MHI_STATUS_CHAN_NOT_READY = 10,
MHI_STATUS_CMD_PENDING = 11,
MHI_STATUS_LINK_DOWN = 12,
MHI_STATUS_ALREADY_REGISTERED = 13,
MHI_STATUS_USERSPACE_MEM_ERR = 14,
MHI_STATUS_BAD_HANDLE = 15,
MHI_STATUS_INVALID_CHAN_ERR = 16,
MHI_STATUS_OVERFLOW = 17,
MHI_STATUS_reserved = 0x80000000
};
enum MHI_CLIENT_CHANNEL {
MHI_CLIENT_LOOPBACK_OUT = 0,
MHI_CLIENT_LOOPBACK_IN = 1,
@ -109,7 +87,7 @@ struct mhi_result {
void *user_data;
void *buf_addr;
size_t bytes_xferd;
enum MHI_STATUS transaction_status;
int transaction_status;
enum MHI_FLAGS flags;
};
@ -128,9 +106,9 @@ struct mhi_client_info_t {
*
* @client_handle: Handle populated by MHI, opaque to client
*
* @Return MHI_STATUS
* @Return errno
*/
enum MHI_STATUS mhi_deregister_channel(struct mhi_client_handle *client_handle);
int mhi_deregister_channel(struct mhi_client_handle *client_handle);
/**
* mhi_register_channel - Client must call this function to obtain a handle for
@ -147,9 +125,9 @@ enum MHI_STATUS mhi_deregister_channel(struct mhi_client_handle *client_handle);
* callback invocation.
* Not thread safe, caller must ensure concurrency protection.
*
* @Return MHI_STATUS
* @Return errno
*/
enum MHI_STATUS mhi_register_channel(struct mhi_client_handle **client_handle,
int mhi_register_channel(struct mhi_client_handle **client_handle,
enum MHI_CLIENT_CHANNEL chan, s32 device_index,
struct mhi_client_info_t *client_info, void *user_data);
@ -160,9 +138,9 @@ enum MHI_STATUS mhi_register_channel(struct mhi_client_handle **client_handle,
*
* Not thread safe, caller must ensure concurrency protection.
*
* @Return MHI_STATUS
* @Return errno
*/
enum MHI_STATUS mhi_open_channel(struct mhi_client_handle *client_handle);
int mhi_open_channel(struct mhi_client_handle *client_handle);
/**
* mhi_queue_xfer - Client called function to add a buffer to MHI channel
@ -178,7 +156,7 @@ enum MHI_STATUS mhi_open_channel(struct mhi_client_handle *client_handle);
* Not thread safe, caller must ensure concurrency protection.
* User buffer must be physically contiguous.
*
* @Return MHI_STATUS
* @Return errno
*/
int mhi_queue_xfer(struct mhi_client_handle *client_handle,
void *buf, size_t buf_len, enum MHI_FLAGS mhi_flags);