Merge "msm: mhi: Resolve deadlock in iface down" (cd2fa386) · Commits · e / devices / android_kernel_sony_msm8994

drivers/net/ethernet/msm/msm_rmnet_mhi.c

+75 −48

Original line number	Diff line number	Diff line
		@@ -349,7 +349,7 @@ void rmnet_mhi_clean_buffers(struct net_device *dev)
		rmnet_log(MSG_INFO, "Exited\n");
		}

		static int rmnet_mhi_disable(struct rmnet_mhi_private *rmnet_mhi_ptr)
		static int rmnet_mhi_disable_channels(struct rmnet_mhi_private *rmnet_mhi_ptr)
		{
		rmnet_log(MSG_INFO, "Closing MHI TX channel\n");
		mhi_close_channel(rmnet_mhi_ptr->tx_client_handle);
		@@ -507,12 +507,26 @@ static void rmnet_mhi_rx_cb(struct mhi_result *result)

		static int rmnet_mhi_open(struct net_device *dev)
		{
		struct rmnet_mhi_private **rmnet_mhi_ptr = netdev_priv(dev);
		struct rmnet_mhi_private *rmnet_mhi_ptr =
		(struct rmnet_mhi_private *)netdev_priv(dev);

		rmnet_log(MSG_INFO,
		"Opened net dev interface for MHI chans %d and %d\n",
		(*rmnet_mhi_ptr)->tx_channel,
		(*rmnet_mhi_ptr)->rx_channel);
		rmnet_mhi_ptr->tx_channel,
		rmnet_mhi_ptr->rx_channel);
		netif_start_queue(dev);
		napi_enable(&(rmnet_mhi_ptr->napi));

		/* Poll to check if any buffers are accumulated in the
		* transport buffers
		*/
		if (napi_schedule_prep(&(rmnet_mhi_ptr->napi))) {
		mhi_mask_irq(rmnet_mhi_ptr->rx_client_handle);
		atomic_inc(&rmnet_mhi_ptr->irq_masked_cntr);
		__napi_schedule(&(rmnet_mhi_ptr->napi));
		} else {
		rx_interrupts_in_masked_irq[rmnet_mhi_ptr->dev_index]++;
		}
		return 0;

		}
		@@ -522,9 +536,10 @@ static int rmnet_mhi_disable_iface(struct rmnet_mhi_private *rmnet_mhi_ptr)
		rmnet_mhi_ptr->rx_enabled = 0;
		rmnet_mhi_ptr->tx_enabled = 0;
		rmnet_mhi_ptr->mhi_enabled = 0;
		if (0 != rmnet_mhi_ptr->dev) {
		if (rmnet_mhi_ptr->dev != 0) {
		netif_stop_queue(rmnet_mhi_ptr->dev);
		netif_napi_del(&(rmnet_mhi_ptr->napi));
		rmnet_mhi_disable_channels(rmnet_mhi_ptr);
		unregister_netdev(rmnet_mhi_ptr->dev);
		free_netdev(rmnet_mhi_ptr->dev);
		rmnet_mhi_ptr->dev = 0;
		@@ -532,24 +547,31 @@ static int rmnet_mhi_disable_iface(struct rmnet_mhi_private *rmnet_mhi_ptr)
		return 0;
		}

		static int rmnet_mhi_close(struct net_device *dev)
		static int rmnet_mhi_disable(struct rmnet_mhi_private *rmnet_mhi_ptr)
		{
		struct rmnet_mhi_private *rmnet_mhi_ptr =
		(struct rmnet_mhi_private *)netdev_priv(dev);
		rmnet_mhi_ptr->mhi_enabled = 0;
		rmnet_mhi_disable_iface(rmnet_mhi_ptr);
		napi_disable(&(rmnet_mhi_ptr->napi));
		if (atomic_read(&rmnet_mhi_ptr->irq_masked_cntr)) {
		atomic_dec(&rmnet_mhi_ptr->irq_masked_cntr);
		mhi_unmask_irq(rmnet_mhi_ptr->rx_client_handle);
		atomic_dec(&rmnet_mhi_ptr->irq_masked_cntr);
		}
		return 0;
		}

		static int rmnet_mhi_stop(struct net_device *dev)
		{
		rmnet_mhi_close(dev);
		struct rmnet_mhi_private *rmnet_mhi_ptr =
		(struct rmnet_mhi_private *)netdev_priv(dev);
		netif_stop_queue(dev);
		napi_disable(&(rmnet_mhi_ptr->napi));
		rmnet_log(MSG_VERBOSE, "Entered\n");
		if (atomic_read(&rmnet_mhi_ptr->irq_masked_cntr)) {
		mhi_unmask_irq(rmnet_mhi_ptr->rx_client_handle);
		atomic_dec(&rmnet_mhi_ptr->irq_masked_cntr);
		rmnet_log(MSG_ERROR, "IRQ was masked, unmasking...\n");
		}
		rmnet_log(MSG_VERBOSE, "Exited\n");
		return 0;
		}

		@@ -772,39 +794,13 @@ static int rmnet_mhi_enable_iface(struct rmnet_mhi_private *rmnet_mhi_ptr)
		memset(tx_ring_full_count, 0, sizeof(tx_ring_full_count));
		memset(tx_queued_packets_count, 0, sizeof(tx_queued_packets_count));
		memset(rx_napi_budget_overflow, 0, sizeof(rx_napi_budget_overflow));

		rmnet_log(MSG_INFO, "Entered.\n");

		if (rmnet_mhi_ptr == NULL) {
		rmnet_log(MSG_CRITICAL, "Bad input args.\n");
		return -EINVAL;
		}
		rmnet_mhi_ptr->dev =
		alloc_netdev(sizeof(struct rmnet_mhi_private *),
		RMNET_MHI_DEV_NAME, rmnet_mhi_setup);
		if (!rmnet_mhi_ptr->dev) {
		rmnet_log(MSG_CRITICAL, "Network device allocation failed\n");
		ret = -ENOMEM;
		goto net_dev_alloc_fail;
		}

		rmnet_mhi_ctxt = netdev_priv(rmnet_mhi_ptr->dev);
		*rmnet_mhi_ctxt = rmnet_mhi_ptr;

		ret = dma_set_mask(&(rmnet_mhi_ptr->dev->dev),
		MHI_DMA_MASK);
		if (0 != ret)
		rmnet_mhi_ptr->allocation_flags = GFP_KERNEL;
		else
		rmnet_mhi_ptr->allocation_flags = GFP_DMA;

		netif_napi_add(rmnet_mhi_ptr->dev, &(rmnet_mhi_ptr->napi),
		rmnet_mhi_poll, MHI_NAPI_WEIGHT_VALUE);

		ret = register_netdev(rmnet_mhi_ptr->dev);
		if (ret) {
		rmnet_log(MSG_CRITICAL,
		"Network device registration failed\n");
		goto net_dev_reg_fail;
		}

		rx_napi_skb_burst_min[rmnet_mhi_ptr->dev_index] = UINT_MAX;
		tx_cb_skb_free_burst_min[rmnet_mhi_ptr->dev_index] = UINT_MAX;
		@@ -834,25 +830,58 @@ static int rmnet_mhi_enable_iface(struct rmnet_mhi_private *rmnet_mhi_ptr)
		goto mhi_rx_chan_start_fail;
		} else {
		rmnet_mhi_ptr->rx_enabled = 1;
		rmnet_mhi_init_inbound(rmnet_mhi_ptr);
		}
		}
		rmnet_mhi_ptr->dev =
		alloc_netdev(sizeof(struct rmnet_mhi_private *),
		RMNET_MHI_DEV_NAME, rmnet_mhi_setup);
		if (!rmnet_mhi_ptr->dev) {
		rmnet_log(MSG_CRITICAL, "Network device allocation failed\n");
		ret = -ENOMEM;
		goto net_dev_alloc_fail;
		}

		rmnet_mhi_ctxt = netdev_priv(rmnet_mhi_ptr->dev);
		*rmnet_mhi_ctxt = rmnet_mhi_ptr;

		ret = dma_set_mask(&(rmnet_mhi_ptr->dev->dev),
		MHI_DMA_MASK);
		if (ret)
		rmnet_mhi_ptr->allocation_flags = GFP_KERNEL;
		else
		rmnet_mhi_ptr->allocation_flags = GFP_DMA;

		r = rmnet_mhi_init_inbound(rmnet_mhi_ptr);
		if (r) {
		rmnet_log(MSG_CRITICAL,
		"Failed to init inbound ret %d\n", r);
		}

		netif_napi_add(rmnet_mhi_ptr->dev, &(rmnet_mhi_ptr->napi),
		rmnet_mhi_poll, MHI_NAPI_WEIGHT_VALUE);

		rmnet_mhi_ptr->mhi_enabled = 1;
		ret = register_netdev(rmnet_mhi_ptr->dev);
		if (ret) {
		rmnet_log(MSG_CRITICAL,
		"Network device registration failed\n");
		goto net_dev_reg_fail;
		}

		napi_enable(&(rmnet_mhi_ptr->napi));
		netif_start_queue(rmnet_mhi_ptr->dev);
		rmnet_log(MSG_INFO, "Exited.\n");

		return 0;

		mhi_rx_chan_start_fail:
		mhi_close_channel(rmnet_mhi_ptr->tx_client_handle);
		mhi_tx_chan_start_fail:
		unregister_netdev(rmnet_mhi_ptr->dev);
		net_dev_reg_fail:
		netif_napi_del(&(rmnet_mhi_ptr->napi));
		free_netdev(rmnet_mhi_ptr->dev);
		net_dev_alloc_fail:
		mhi_close_channel(rmnet_mhi_ptr->rx_client_handle);
		rmnet_mhi_ptr->dev = NULL;
		mhi_rx_chan_start_fail:
		mhi_close_channel(rmnet_mhi_ptr->tx_client_handle);
		mhi_tx_chan_start_fail:
		rmnet_log(MSG_INFO, "Exited ret %d.\n", ret);
		return ret;
		}
		@@ -875,10 +904,8 @@ static void rmnet_mhi_cb(struct mhi_cb_info *cb_info)
		case MHI_CB_MHI_DISABLED:
		rmnet_log(MSG_CRITICAL,
		"Got MHI_DISABLED notification. Stopping stack\n");
		if (rmnet_mhi_ptr->mhi_enabled) {
		if (rmnet_mhi_ptr->mhi_enabled)
		rmnet_mhi_disable(rmnet_mhi_ptr);
		rmnet_mhi_disable_iface(rmnet_mhi_ptr);
		}
		break;
		case MHI_CB_MHI_ENABLED:
		rmnet_log(MSG_CRITICAL,