Merge "mhi: Use standard kernel return codes" (38a65c7c) · Commits · e / devices / android_kernel_xiaomi_markw

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",