Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 23426f19 authored by Tony Truong's avatar Tony Truong Committed by Gerrit - the friendly Code Review server
Browse files

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: default avatarAndrei Danaila <adanaila@codeaurora.org>
Signed-off-by: default avatarTony Truong <truong@codeaurora.org>
parent 938e70f3

drivers/net/ethernet/msm/msm_rmnet_mhi.c

+17 −17
Original line number Diff line number Diff line
@@ -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",

drivers/platform/msm/mhi/mhi.h

+18 −19
Original line number Diff line number Diff line
@@ -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,

drivers/platform/msm/mhi/mhi_bhi.c

+3 −3
Original line number Diff line number Diff line
@@ -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;

drivers/platform/msm/mhi/mhi_event.c

+10 −12
Original line number Diff line number Diff line
@@ -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;

		}

	}

drivers/platform/msm/mhi/mhi_iface.c

+6 −4
Original line number Diff line number Diff line
@@ -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",