Merge branch 'cxgb4' (2ef1e9ef) · Commits · e / devices / android_kernel_xiaomi_markw

drivers/net/ethernet/chelsio/Kconfig

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -68,7 +68,7 @@ config CHELSIO_T3

	config CHELSIO_T4		config CHELSIO_T4
	tristate "Chelsio Communications T4/T5 Ethernet support"		tristate "Chelsio Communications T4/T5 Ethernet support"
	depends on PCI		depends on PCI && (IPV6 \|\| IPV6=n)
	select FW_LOADER		select FW_LOADER
	select MDIO		select MDIO
	---help---		---help---

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

+15 −0

Original line number	Original line	Diff line number	Diff line
	@@ -4369,6 +4369,7 @@ EXPORT_SYMBOL(cxgb4_unregister_uld);
	* success (true) if it belongs otherwise failure (false).		* success (true) if it belongs otherwise failure (false).
	* Called with rcu_read_lock() held.		* Called with rcu_read_lock() held.
	*/		*/
			#if IS_ENABLED(CONFIG_IPV6)
	static bool cxgb4_netdev(const struct net_device *netdev)		static bool cxgb4_netdev(const struct net_device *netdev)
	{		{
	struct adapter *adap;		struct adapter *adap;
	@@ -4490,6 +4491,13 @@ static int update_root_dev_clip(struct net_device *dev)
	return ret;		return ret;

	/* Parse all bond and vlan devices layered on top of the physical dev */		/* Parse all bond and vlan devices layered on top of the physical dev */
			root_dev = netdev_master_upper_dev_get_rcu(dev);
			if (root_dev) {
			ret = update_dev_clip(root_dev, dev);
			if (ret)
			return ret;
			}

	for (i = 0; i < VLAN_N_VID; i++) {		for (i = 0; i < VLAN_N_VID; i++) {
	root_dev = __vlan_find_dev_deep_rcu(dev, htons(ETH_P_8021Q), i);		root_dev = __vlan_find_dev_deep_rcu(dev, htons(ETH_P_8021Q), i);
	if (!root_dev)		if (!root_dev)
	@@ -4522,6 +4530,7 @@ static void update_clip(const struct adapter *adap)
	}		}
	rcu_read_unlock();		rcu_read_unlock();
	}		}
			#endif /* IS_ENABLED(CONFIG_IPV6) */

	/**		/**
	* cxgb_up - enable the adapter		* cxgb_up - enable the adapter
	@@ -4568,7 +4577,9 @@ static int cxgb_up(struct adapter *adap)
	t4_intr_enable(adap);		t4_intr_enable(adap);
	adap->flags \|= FULL_INIT_DONE;		adap->flags \|= FULL_INIT_DONE;
	notify_ulds(adap, CXGB4_STATE_UP);		notify_ulds(adap, CXGB4_STATE_UP);
			#if IS_ENABLED(CONFIG_IPV6)
	update_clip(adap);		update_clip(adap);
			#endif
	out:		out:
	return err;		return err;
	irq_err:		irq_err:
	@@ -6862,14 +6873,18 @@ static int __init cxgb4_init_module(void)
	if (ret < 0)		if (ret < 0)
	debugfs_remove(cxgb4_debugfs_root);		debugfs_remove(cxgb4_debugfs_root);

			#if IS_ENABLED(CONFIG_IPV6)
	register_inet6addr_notifier(&cxgb4_inet6addr_notifier);		register_inet6addr_notifier(&cxgb4_inet6addr_notifier);
			#endif

	return ret;		return ret;
	}		}

	static void __exit cxgb4_cleanup_module(void)		static void __exit cxgb4_cleanup_module(void)
	{		{
			#if IS_ENABLED(CONFIG_IPV6)
	unregister_inet6addr_notifier(&cxgb4_inet6addr_notifier);		unregister_inet6addr_notifier(&cxgb4_inet6addr_notifier);
			#endif
	pci_unregister_driver(&cxgb4_driver);		pci_unregister_driver(&cxgb4_driver);
	debugfs_remove(cxgb4_debugfs_root); /* NULL ok */		debugfs_remove(cxgb4_debugfs_root); /* NULL ok */
	}		}

drivers/scsi/cxgbi/cxgb4i/cxgb4i.c

+8 −138

Original line number	Original line	Diff line number	Diff line
	@@ -259,6 +259,7 @@ static void send_act_open_req(struct cxgbi_sock csk, struct sk_buff skb,
	cxgb4_l2t_send(csk->cdev->ports[csk->port_id], skb, csk->l2t);		cxgb4_l2t_send(csk->cdev->ports[csk->port_id], skb, csk->l2t);
	}		}

			#if IS_ENABLED(CONFIG_IPV6)
	static void send_act_open_req6(struct cxgbi_sock csk, struct sk_buff skb,		static void send_act_open_req6(struct cxgbi_sock csk, struct sk_buff skb,
	struct l2t_entry *e)		struct l2t_entry *e)
	{		{
	@@ -344,6 +345,7 @@ static void send_act_open_req6(struct cxgbi_sock csk, struct sk_buff skb,

	cxgb4_l2t_send(csk->cdev->ports[csk->port_id], skb, csk->l2t);		cxgb4_l2t_send(csk->cdev->ports[csk->port_id], skb, csk->l2t);
	}		}
			#endif

	static void send_close_req(struct cxgbi_sock *csk)		static void send_close_req(struct cxgbi_sock *csk)
	{		{
	@@ -781,9 +783,11 @@ static void csk_act_open_retry_timer(unsigned long data)
	if (csk->csk_family == AF_INET) {		if (csk->csk_family == AF_INET) {
	send_act_open_func = send_act_open_req;		send_act_open_func = send_act_open_req;
	skb = alloc_wr(size, 0, GFP_ATOMIC);		skb = alloc_wr(size, 0, GFP_ATOMIC);
			#if IS_ENABLED(CONFIG_IPV6)
	} else {		} else {
	send_act_open_func = send_act_open_req6;		send_act_open_func = send_act_open_req6;
	skb = alloc_wr(size6, 0, GFP_ATOMIC);		skb = alloc_wr(size6, 0, GFP_ATOMIC);
			#endif
	}		}

	if (!skb)		if (!skb)
	@@ -1313,11 +1317,6 @@ static int init_act_open(struct cxgbi_sock *csk)
	cxgbi_sock_set_flag(csk, CTPF_HAS_ATID);		cxgbi_sock_set_flag(csk, CTPF_HAS_ATID);
	cxgbi_sock_get(csk);		cxgbi_sock_get(csk);

	n = dst_neigh_lookup(csk->dst, &csk->daddr.sin_addr.s_addr);
	if (!n) {
	pr_err("%s, can't get neighbour of csk->dst.\n", ndev->name);
	goto rel_resource;
	}
	csk->l2t = cxgb4_l2t_get(lldi->l2t, n, ndev, 0);		csk->l2t = cxgb4_l2t_get(lldi->l2t, n, ndev, 0);
	if (!csk->l2t) {		if (!csk->l2t) {
	pr_err("%s, cannot alloc l2t.\n", ndev->name);		pr_err("%s, cannot alloc l2t.\n", ndev->name);
	@@ -1335,8 +1334,10 @@ static int init_act_open(struct cxgbi_sock *csk)

	if (csk->csk_family == AF_INET)		if (csk->csk_family == AF_INET)
	skb = alloc_wr(size, 0, GFP_NOIO);		skb = alloc_wr(size, 0, GFP_NOIO);
			#if IS_ENABLED(CONFIG_IPV6)
	else		else
	skb = alloc_wr(size6, 0, GFP_NOIO);		skb = alloc_wr(size6, 0, GFP_NOIO);
			#endif

	if (!skb)		if (!skb)
	goto rel_resource;		goto rel_resource;
	@@ -1370,8 +1371,10 @@ static int init_act_open(struct cxgbi_sock *csk)
	cxgbi_sock_set_state(csk, CTP_ACTIVE_OPEN);		cxgbi_sock_set_state(csk, CTP_ACTIVE_OPEN);
	if (csk->csk_family == AF_INET)		if (csk->csk_family == AF_INET)
	send_act_open_req(csk, skb, csk->l2t);		send_act_open_req(csk, skb, csk->l2t);
			#if IS_ENABLED(CONFIG_IPV6)
	else		else
	send_act_open_req6(csk, skb, csk->l2t);		send_act_open_req6(csk, skb, csk->l2t);
			#endif
	neigh_release(n);		neigh_release(n);

	return 0;		return 0;
	@@ -1635,129 +1638,6 @@ static int cxgb4i_ddp_init(struct cxgbi_device *cdev)
	return 0;		return 0;
	}		}

	#if IS_ENABLED(CONFIG_IPV6)
	static int cxgbi_inet6addr_handler(struct notifier_block *this,
	unsigned long event, void *data)
	{
	struct inet6_ifaddr *ifa = data;
	struct net_device *event_dev = ifa->idev->dev;
	struct cxgbi_device *cdev;
	int ret = NOTIFY_DONE;

	if (event_dev->priv_flags & IFF_802_1Q_VLAN)
	event_dev = vlan_dev_real_dev(event_dev);

	cdev = cxgbi_device_find_by_netdev_rcu(event_dev, NULL);

	if (!cdev)
	return ret;

	switch (event) {
	case NETDEV_UP:
	ret = cxgb4_clip_get(event_dev,
	(const struct in6_addr *)
	((ifa)->addr.s6_addr));
	if (ret < 0)
	return ret;

	ret = NOTIFY_OK;
	break;

	case NETDEV_DOWN:
	cxgb4_clip_release(event_dev,
	(const struct in6_addr *)
	((ifa)->addr.s6_addr));
	ret = NOTIFY_OK;
	break;

	default:
	break;
	}

	return ret;
	}

	static struct notifier_block cxgbi_inet6addr_notifier = {
	.notifier_call = cxgbi_inet6addr_handler
	};

	/* Retrieve IPv6 addresses from a root device (bond, vlan) associated with
	* a physical device.
	* The physical device reference is needed to send the actual CLIP command.
	*/
	static int update_dev_clip(struct net_device root_dev, struct net_device dev)
	{
	struct inet6_dev *idev = NULL;
	struct inet6_ifaddr *ifa;
	int ret = 0;

	idev = __in6_dev_get(root_dev);
	if (!idev)
	return ret;

	read_lock_bh(&idev->lock);
	list_for_each_entry(ifa, &idev->addr_list, if_list) {
	pr_info("updating the clip for addr %pI6\n",
	ifa->addr.s6_addr);
	ret = cxgb4_clip_get(dev, (const struct in6_addr *)
	ifa->addr.s6_addr);
	if (ret < 0)
	break;
	}

	read_unlock_bh(&idev->lock);
	return ret;
	}

	static int update_root_dev_clip(struct net_device *dev)
	{
	struct net_device *root_dev = NULL;
	int i, ret = 0;

	/* First populate the real net device's IPv6 address */
	ret = update_dev_clip(dev, dev);
	if (ret)
	return ret;

	/* Parse all bond and vlan devices layered on top of the physical dev */
	root_dev = netdev_master_upper_dev_get(dev);
	if (root_dev) {
	ret = update_dev_clip(root_dev, dev);
	if (ret)
	return ret;
	}

	for (i = 0; i < VLAN_N_VID; i++) {
	root_dev = __vlan_find_dev_deep_rcu(dev, htons(ETH_P_8021Q), i);
	if (!root_dev)
	continue;

	ret = update_dev_clip(root_dev, dev);
	if (ret)
	break;
	}
	return ret;
	}

	static void cxgbi_update_clip(struct cxgbi_device *cdev)
	{
	int i;

	rcu_read_lock();

	for (i = 0; i < cdev->nports; i++) {
	struct net_device *dev = cdev->ports[i];
	int ret = 0;

	if (dev)
	ret = update_root_dev_clip(dev);
	if (ret < 0)
	break;
	}
	rcu_read_unlock();
	}
	#endif /* IS_ENABLED(CONFIG_IPV6) */

	static void t4_uld_add(const struct cxgb4_lld_info lldi)		static void t4_uld_add(const struct cxgb4_lld_info lldi)
	{		{
	struct cxgbi_device *cdev;		struct cxgbi_device *cdev;
	@@ -1876,10 +1756,6 @@ static int t4_uld_state_change(void *handle, enum cxgb4_state state)
	switch (state) {		switch (state) {
	case CXGB4_STATE_UP:		case CXGB4_STATE_UP:
	pr_info("cdev 0x%p, UP.\n", cdev);		pr_info("cdev 0x%p, UP.\n", cdev);
	#if IS_ENABLED(CONFIG_IPV6)
	cxgbi_update_clip(cdev);
	#endif
	/* re-initialize */
	break;		break;
	case CXGB4_STATE_START_RECOVERY:		case CXGB4_STATE_START_RECOVERY:
	pr_info("cdev 0x%p, RECOVERY.\n", cdev);		pr_info("cdev 0x%p, RECOVERY.\n", cdev);
	@@ -1910,17 +1786,11 @@ static int __init cxgb4i_init_module(void)
	return rc;		return rc;
	cxgb4_register_uld(CXGB4_ULD_ISCSI, &cxgb4i_uld_info);		cxgb4_register_uld(CXGB4_ULD_ISCSI, &cxgb4i_uld_info);

	#if IS_ENABLED(CONFIG_IPV6)
	register_inet6addr_notifier(&cxgbi_inet6addr_notifier);
	#endif
	return 0;		return 0;
	}		}

	static void __exit cxgb4i_exit_module(void)		static void __exit cxgb4i_exit_module(void)
	{		{
	#if IS_ENABLED(CONFIG_IPV6)
	unregister_inet6addr_notifier(&cxgbi_inet6addr_notifier);
	#endif
	cxgb4_unregister_uld(CXGB4_ULD_ISCSI);		cxgb4_unregister_uld(CXGB4_ULD_ISCSI);
	cxgbi_device_unregister_all(CXGBI_FLAG_DEV_T4);		cxgbi_device_unregister_all(CXGBI_FLAG_DEV_T4);
	cxgbi_iscsi_cleanup(&cxgb4i_iscsi_transport, &cxgb4i_stt);		cxgbi_iscsi_cleanup(&cxgb4i_iscsi_transport, &cxgb4i_stt);

drivers/scsi/cxgbi/libcxgbi.c

+2 −0

Original line number	Original line	Diff line number	Diff line
	@@ -275,6 +275,7 @@ struct cxgbi_device cxgbi_device_find_by_netdev_rcu(struct net_device ndev,
	}		}
	EXPORT_SYMBOL_GPL(cxgbi_device_find_by_netdev_rcu);		EXPORT_SYMBOL_GPL(cxgbi_device_find_by_netdev_rcu);

			#if IS_ENABLED(CONFIG_IPV6)
	static struct cxgbi_device cxgbi_device_find_by_mac(struct net_device ndev,		static struct cxgbi_device cxgbi_device_find_by_mac(struct net_device ndev,
	int *port)		int *port)
	{		{
	@@ -307,6 +308,7 @@ static struct cxgbi_device cxgbi_device_find_by_mac(struct net_device ndev,
	ndev, ndev->name);		ndev, ndev->name);
	return NULL;		return NULL;
	}		}
			#endif

	void cxgbi_hbas_remove(struct cxgbi_device *cdev)		void cxgbi_hbas_remove(struct cxgbi_device *cdev)
	{		{