summaryrefslogtreecommitdiff
path: root/drivers
diff options
context:
space:
mode:
authorTony Truong <truong@codeaurora.org>2015-12-29 15:04:44 -0800
committerDavid Keitel <dkeitel@codeaurora.org>2016-03-23 21:24:52 -0700
commita603bd09f9a9965c85fe45922b3da5c1be041c4d (patch)
tree93e011e931e741d7d42a9b68c1ca40d008c91e1c /drivers
parentc9ccb157049a927b4168dbcd23389d9b062deef6 (diff)
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 <adanaila@codeaurora.org> Signed-off-by: Tony Truong <truong@codeaurora.org>
Diffstat (limited to 'drivers')
-rw-r--r--drivers/net/ethernet/msm/msm_rmnet_mhi.c34
-rw-r--r--drivers/platform/msm/mhi/mhi.h37
-rw-r--r--drivers/platform/msm/mhi/mhi_bhi.c6
-rw-r--r--drivers/platform/msm/mhi/mhi_event.c22
-rw-r--r--drivers/platform/msm/mhi/mhi_iface.c10
-rw-r--r--drivers/platform/msm/mhi/mhi_init.c19
-rw-r--r--drivers/platform/msm/mhi/mhi_isr.c22
-rw-r--r--drivers/platform/msm/mhi/mhi_main.c203
-rw-r--r--drivers/platform/msm/mhi/mhi_mmio_ops.c29
-rw-r--r--drivers/platform/msm/mhi/mhi_pm.c45
-rw-r--r--drivers/platform/msm/mhi/mhi_ring_ops.c30
-rw-r--r--drivers/platform/msm/mhi/mhi_ssr.c20
-rw-r--r--drivers/platform/msm/mhi/mhi_states.c268
-rw-r--r--drivers/platform/msm/mhi_uci/mhi_uci.c47
14 files changed, 378 insertions, 414 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 <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;
generated by cgit v1.2.3 (git 2.39.1) at 2024-10-14 05:21:12 +0000