From a603bd09f9a9965c85fe45922b3da5c1be041c4d Mon Sep 17 00:00:00 2001 From: Tony Truong Date: Tue, 29 Dec 2015 15:04:44 -0800 Subject: mhi: Use standard kernel return codes 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 Signed-off-by: Tony Truong --- drivers/net/ethernet/msm/msm_rmnet_mhi.c | 34 ++-- drivers/platform/msm/mhi/mhi.h | 37 +++-- drivers/platform/msm/mhi/mhi_bhi.c | 6 +- drivers/platform/msm/mhi/mhi_event.c | 22 ++- drivers/platform/msm/mhi/mhi_iface.c | 10 +- drivers/platform/msm/mhi/mhi_init.c | 19 +-- drivers/platform/msm/mhi/mhi_isr.c | 22 ++- drivers/platform/msm/mhi/mhi_main.c | 203 ++++++++++++----------- drivers/platform/msm/mhi/mhi_mmio_ops.c | 29 ++-- drivers/platform/msm/mhi/mhi_pm.c | 45 +++--- drivers/platform/msm/mhi/mhi_ring_ops.c | 30 ++-- drivers/platform/msm/mhi/mhi_ssr.c | 20 ++- drivers/platform/msm/mhi/mhi_states.c | 268 ++++++++++++++----------------- drivers/platform/msm/mhi_uci/mhi_uci.c | 47 +++--- include/linux/msm_mhi.h | 38 +---- 15 files changed, 386 insertions(+), 444 deletions(-) diff --git a/drivers/net/ethernet/msm/msm_rmnet_mhi.c b/drivers/net/ethernet/msm/msm_rmnet_mhi.c index 7971e1dc28db..ecdb806a2ae2 100644 --- a/drivers/net/ethernet/msm/msm_rmnet_mhi.c +++ b/drivers/net/ethernet/msm/msm_rmnet_mhi.c @@ -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", diff --git a/drivers/platform/msm/mhi/mhi.h b/drivers/platform/msm/mhi/mhi.h index fd92c47ca3cb..c6fa39d6e0e2 100644 --- a/drivers/platform/msm/mhi/mhi.h +++ b/drivers/platform/msm/mhi/mhi.h @@ -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, diff --git a/drivers/platform/msm/mhi/mhi_bhi.c b/drivers/platform/msm/mhi/mhi_bhi.c index fe89c9f8a21e..5e50a17a26c9 100644 --- a/drivers/platform/msm/mhi/mhi_bhi.c +++ b/drivers/platform/msm/mhi/mhi_bhi.c @@ -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; diff --git a/drivers/platform/msm/mhi/mhi_event.c b/drivers/platform/msm/mhi/mhi_event.c index 76b7761964cb..968021cb6dae 100644 --- a/drivers/platform/msm/mhi/mhi_event.c +++ b/drivers/platform/msm/mhi/mhi_event.c @@ -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; } } diff --git a/drivers/platform/msm/mhi/mhi_iface.c b/drivers/platform/msm/mhi/mhi_iface.c index 696a3d14ece1..b7785ba7e403 100644 --- a/drivers/platform/msm/mhi/mhi_iface.c +++ b/drivers/platform/msm/mhi/mhi_iface.c @@ -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", diff --git a/drivers/platform/msm/mhi/mhi_init.c b/drivers/platform/msm/mhi/mhi_init.c index 600553cfdfca..deeff3df8b2b 100644 --- a/drivers/platform/msm/mhi/mhi_init.c +++ b/drivers/platform/msm/mhi/mhi_init.c @@ -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; } diff --git a/drivers/platform/msm/mhi/mhi_isr.c b/drivers/platform/msm/mhi/mhi_isr.c index 5ae858ae7c9d..5336b9ff0c11 100644 --- a/drivers/platform/msm/mhi/mhi_isr.c +++ b/drivers/platform/msm/mhi/mhi_isr.c @@ -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); } diff --git a/drivers/platform/msm/mhi/mhi_main.c b/drivers/platform/msm/mhi/mhi_main.c index 04e6f7c1451c..3c7a5d31c396 100644 --- a/drivers/platform/msm/mhi/mhi_main.c +++ b/drivers/platform/msm/mhi/mhi_main.c @@ -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; diff --git a/drivers/platform/msm/mhi/mhi_mmio_ops.c b/drivers/platform/msm/mhi/mhi_mmio_ops.c index 1d780c9863d5..ddf18e466cd3 100644 --- a/drivers/platform/msm/mhi/mhi_mmio_ops.c +++ b/drivers/platform/msm/mhi/mhi_mmio_ops.c @@ -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; } diff --git a/drivers/platform/msm/mhi/mhi_pm.c b/drivers/platform/msm/mhi/mhi_pm.c index f4fe3caa8f95..a928c05b805a 100644 --- a/drivers/platform/msm/mhi/mhi_pm.c +++ b/drivers/platform/msm/mhi/mhi_pm.c @@ -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; } diff --git a/drivers/platform/msm/mhi/mhi_ring_ops.c b/drivers/platform/msm/mhi/mhi_ring_ops.c index a27049a093eb..a8521a7fe814 100644 --- a/drivers/platform/msm/mhi/mhi_ring_ops.c +++ b/drivers/platform/msm/mhi/mhi_ring_ops.c @@ -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; } diff --git a/drivers/platform/msm/mhi/mhi_ssr.c b/drivers/platform/msm/mhi/mhi_ssr.c index 19ceee2f40ca..9e21fd7d9794 100644 --- a/drivers/platform/msm/mhi/mhi_ssr.c +++ b/drivers/platform/msm/mhi/mhi_ssr.c @@ -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; } diff --git a/drivers/platform/msm/mhi/mhi_states.c b/drivers/platform/msm/mhi/mhi_states.c index baf239580a17..56602246a935 100644 --- a/drivers/platform/msm/mhi/mhi_states.c +++ b/drivers/platform/msm/mhi/mhi_states.c @@ -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; + int r = 0; 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)) + 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.\n"); - return ret_val; + "Failed to init state transition to RESET ret %d\n", r); + mhi_log(MHI_MSG_CRITICAL, "Failed to reset mhi\n"); + } + return r; } -enum MHI_STATUS start_chan_sync(struct mhi_client_handle *client_handle) +int 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; + 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) - 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) + if (r) { 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", diff --git a/drivers/platform/msm/mhi_uci/mhi_uci.c b/drivers/platform/msm/mhi_uci/mhi_uci.c index 1d5490e0e7ae..9ae1b63a75c9 100644 --- a/drivers/platform/msm/mhi_uci/mhi_uci.c +++ b/drivers/platform/msm/mhi_uci/mhi_uci.c @@ -26,6 +26,7 @@ #include #include #include +#include #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; diff --git a/include/linux/msm_mhi.h b/include/linux/msm_mhi.h index fd6602cf2266..765750396613 100644 --- a/include/linux/msm_mhi.h +++ b/include/linux/msm_mhi.h @@ -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); -- cgit v1.2.3