[deliverable/linux.git] / net / caif / caif_dev.c

/*
 * CAIF Interface registration.
 * Copyright (C) ST-Ericsson AB 2010
 * Author:	Sjur Brendeland/sjur.brandeland@stericsson.com
 * License terms: GNU General Public License (GPL) version 2
 *
 * Borrowed heavily from file: pn_dev.c. Thanks to
 *  Remi Denis-Courmont <remi.denis-courmont@nokia.com>
 *  and Sakari Ailus <sakari.ailus@nokia.com>
 */

#define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__

#include <linux/kernel.h>
#include <linux/if_arp.h>
#include <linux/net.h>
#include <linux/netdevice.h>
#include <linux/mutex.h>
#include <linux/module.h>
#include <net/netns/generic.h>
#include <net/net_namespace.h>
#include <net/pkt_sched.h>
#include <net/caif/caif_device.h>
#include <net/caif/caif_layer.h>
#include <net/caif/cfpkt.h>
#include <net/caif/cfcnfg.h>
#include <net/caif/cfserl.h>

MODULE_LICENSE("GPL");

/* Used for local tracking of the CAIF net devices */
struct caif_device_entry {
	struct cflayer layer;
	struct list_head list;
	struct net_device *netdev;
	int __percpu *pcpu_refcnt;
};

struct caif_device_entry_list {
	struct list_head list;
	/* Protects simulanous deletes in list */
	struct mutex lock;
};

struct caif_net {
	struct cfcnfg *cfg;
	struct caif_device_entry_list caifdevs;
};

static int caif_net_id;

struct cfcnfg *get_cfcnfg(struct net *net)
{
	struct caif_net *caifn;
	BUG_ON(!net);
	caifn = net_generic(net, caif_net_id);
	if (!caifn)
		return NULL;
	return caifn->cfg;
}
EXPORT_SYMBOL(get_cfcnfg);

static struct caif_device_entry_list *caif_device_list(struct net *net)
{
	struct caif_net *caifn;
	BUG_ON(!net);
	caifn = net_generic(net, caif_net_id);
	if (!caifn)
		return NULL;
	return &caifn->caifdevs;
}

static void caifd_put(struct caif_device_entry *e)
{
	irqsafe_cpu_dec(*e->pcpu_refcnt);
}

static void caifd_hold(struct caif_device_entry *e)
{
	irqsafe_cpu_inc(*e->pcpu_refcnt);
}

static int caifd_refcnt_read(struct caif_device_entry *e)
{
	int i, refcnt = 0;
	for_each_possible_cpu(i)
		refcnt += *per_cpu_ptr(e->pcpu_refcnt, i);
	return refcnt;
}

/* Allocate new CAIF device. */
static struct caif_device_entry *caif_device_alloc(struct net_device *dev)
{
	struct caif_device_entry_list *caifdevs;
	struct caif_device_entry *caifd;

	caifdevs = caif_device_list(dev_net(dev));
	if (!caifdevs)
		return NULL;

	caifd = kzalloc(sizeof(*caifd), GFP_KERNEL);
	if (!caifd)
		return NULL;
	caifd->pcpu_refcnt = alloc_percpu(int);
	if (!caifd->pcpu_refcnt) {
		kfree(caifd);
		return NULL;
	}
	caifd->netdev = dev;
	dev_hold(dev);
	return caifd;
}

static struct caif_device_entry *caif_get(struct net_device *dev)
{
	struct caif_device_entry_list *caifdevs =
	    caif_device_list(dev_net(dev));
	struct caif_device_entry *caifd;
	if (!caifdevs)
		return NULL;

	list_for_each_entry_rcu(caifd, &caifdevs->list, list) {
		if (caifd->netdev == dev)
			return caifd;
	}
	return NULL;
}

static int transmit(struct cflayer *layer, struct cfpkt *pkt)
{
	int err;
	struct caif_device_entry *caifd =
	    container_of(layer, struct caif_device_entry, layer);
	struct sk_buff *skb;

	skb = cfpkt_tonative(pkt);
	skb->dev = caifd->netdev;
	skb_reset_network_header(skb);
	skb->protocol = htons(ETH_P_CAIF);

	err = dev_queue_xmit(skb);
	if (err > 0)
		err = -EIO;

	return err;
}

/*
 * Stuff received packets into the CAIF stack.
 * On error, returns non-zero and releases the skb.
 */
static int receive(struct sk_buff *skb, struct net_device *dev,
		   struct packet_type *pkttype, struct net_device *orig_dev)
{
	struct cfpkt *pkt;
	struct caif_device_entry *caifd;
	int err;

	pkt = cfpkt_fromnative(CAIF_DIR_IN, skb);

	rcu_read_lock();
	caifd = caif_get(dev);

	if (!caifd || !caifd->layer.up || !caifd->layer.up->receive ||
			!netif_oper_up(caifd->netdev)) {
		rcu_read_unlock();
		kfree_skb(skb);
		return NET_RX_DROP;
	}

	/* Hold reference to netdevice while using CAIF stack */
	caifd_hold(caifd);
	rcu_read_unlock();

	err = caifd->layer.up->receive(caifd->layer.up, pkt);

	/* For -EILSEQ the packet is not freed so so it now */
	if (err == -EILSEQ)
		cfpkt_destroy(pkt);

	/* Release reference to stack upwards */
	caifd_put(caifd);

	if (err != 0)
		err = NET_RX_DROP;
	return err;
}

static struct packet_type caif_packet_type __read_mostly = {
	.type = cpu_to_be16(ETH_P_CAIF),
	.func = receive,
};

static void dev_flowctrl(struct net_device *dev, int on)
{
	struct caif_device_entry *caifd;

	rcu_read_lock();

	caifd = caif_get(dev);
	if (!caifd || !caifd->layer.up || !caifd->layer.up->ctrlcmd) {
		rcu_read_unlock();
		return;
	}

	caifd_hold(caifd);
	rcu_read_unlock();

	caifd->layer.up->ctrlcmd(caifd->layer.up,
				 on ?
				 _CAIF_CTRLCMD_PHYIF_FLOW_ON_IND :
				 _CAIF_CTRLCMD_PHYIF_FLOW_OFF_IND,
				 caifd->layer.id);
	caifd_put(caifd);
}

void caif_enroll_dev(struct net_device *dev, struct caif_dev_common *caifdev,
			struct cflayer *link_support, int head_room,
			struct cflayer **layer, int (**rcv_func)(
				struct sk_buff *, struct net_device *,
				struct packet_type *, struct net_device *))
{
	struct caif_device_entry *caifd;
	enum cfcnfg_phy_preference pref;
	struct cfcnfg *cfg = get_cfcnfg(dev_net(dev));
	struct caif_device_entry_list *caifdevs;

	caifdevs = caif_device_list(dev_net(dev));
	if (!cfg || !caifdevs)
		return;
	caifd = caif_device_alloc(dev);
	if (!caifd)
		return;
	*layer = &caifd->layer;

	switch (caifdev->link_select) {
	case CAIF_LINK_HIGH_BANDW:
		pref = CFPHYPREF_HIGH_BW;
		break;
	case CAIF_LINK_LOW_LATENCY:
		pref = CFPHYPREF_LOW_LAT;
		break;
	default:
		pref = CFPHYPREF_HIGH_BW;
		break;
	}
	mutex_lock(&caifdevs->lock);
	list_add_rcu(&caifd->list, &caifdevs->list);

	strncpy(caifd->layer.name, dev->name,
		sizeof(caifd->layer.name) - 1);
	caifd->layer.name[sizeof(caifd->layer.name) - 1] = 0;
	caifd->layer.transmit = transmit;
	cfcnfg_add_phy_layer(cfg,
				dev,
				&caifd->layer,
				pref,
				link_support,
				caifdev->use_fcs,
				head_room);
	mutex_unlock(&caifdevs->lock);
	if (rcv_func)
		*rcv_func = receive;
}

/* notify Caif of device events */
static int caif_device_notify(struct notifier_block *me, unsigned long what,
			      void *arg)
{
	struct net_device *dev = arg;
	struct caif_device_entry *caifd = NULL;
	struct caif_dev_common *caifdev;
	struct cfcnfg *cfg;
	struct cflayer *layer, *link_support;
	int head_room = 0;
	struct caif_device_entry_list *caifdevs;

	cfg = get_cfcnfg(dev_net(dev));
	caifdevs = caif_device_list(dev_net(dev));
	if (!cfg || !caifdevs)
		return 0;

	caifd = caif_get(dev);
	if (caifd == NULL && dev->type != ARPHRD_CAIF)
		return 0;

	switch (what) {
	case NETDEV_REGISTER:
		if (caifd != NULL)
			break;

		caifdev = netdev_priv(dev);

		link_support = NULL;
		if (caifdev->use_frag) {
			head_room = 1;
			link_support = cfserl_create(dev->ifindex,
							caifdev->use_stx);
			if (!link_support) {
				pr_warn("Out of memory\n");
				break;
			}
		}
		caif_enroll_dev(dev, caifdev, link_support, head_room,
				&layer, NULL);
		caifdev->flowctrl = dev_flowctrl;
		break;

	case NETDEV_UP:
		rcu_read_lock();

		caifd = caif_get(dev);
		if (caifd == NULL) {
			rcu_read_unlock();
			break;
		}

		cfcnfg_set_phy_state(cfg, &caifd->layer, true);
		rcu_read_unlock();

		break;

	case NETDEV_DOWN:
		rcu_read_lock();

		caifd = caif_get(dev);
		if (!caifd || !caifd->layer.up || !caifd->layer.up->ctrlcmd) {
			rcu_read_unlock();
			return -EINVAL;
		}

		cfcnfg_set_phy_state(cfg, &caifd->layer, false);
		caifd_hold(caifd);
		rcu_read_unlock();

		caifd->layer.up->ctrlcmd(caifd->layer.up,
					 _CAIF_CTRLCMD_PHYIF_DOWN_IND,
					 caifd->layer.id);
		caifd_put(caifd);
		break;

	case NETDEV_UNREGISTER:
		mutex_lock(&caifdevs->lock);

		caifd = caif_get(dev);
		if (caifd == NULL) {
			mutex_unlock(&caifdevs->lock);
			break;
		}
		list_del_rcu(&caifd->list);

		/*
		 * NETDEV_UNREGISTER is called repeatedly until all reference
		 * counts for the net-device are released. If references to
		 * caifd is taken, simply ignore NETDEV_UNREGISTER and wait for
		 * the next call to NETDEV_UNREGISTER.
		 *
		 * If any packets are in flight down the CAIF Stack,
		 * cfcnfg_del_phy_layer will return nonzero.
		 * If no packets are in flight, the CAIF Stack associated
		 * with the net-device un-registering is freed.
		 */

		if (caifd_refcnt_read(caifd) != 0 ||
			cfcnfg_del_phy_layer(cfg, &caifd->layer) != 0) {

			pr_info("Wait for device inuse\n");
			/* Enrole device if CAIF Stack is still in use */
			list_add_rcu(&caifd->list, &caifdevs->list);
			mutex_unlock(&caifdevs->lock);
			break;
		}

		synchronize_rcu();
		dev_put(caifd->netdev);
		free_percpu(caifd->pcpu_refcnt);
		kfree(caifd);

		mutex_unlock(&caifdevs->lock);
		break;
	}
	return 0;
}

static struct notifier_block caif_device_notifier = {
	.notifier_call = caif_device_notify,
	.priority = 0,
};

/* Per-namespace Caif devices handling */
static int caif_init_net(struct net *net)
{
	struct caif_net *caifn = net_generic(net, caif_net_id);
	BUG_ON(!caifn);
	INIT_LIST_HEAD(&caifn->caifdevs.list);
	mutex_init(&caifn->caifdevs.lock);

	caifn->cfg = cfcnfg_create();
	if (!caifn->cfg) {
		pr_warn("can't create cfcnfg\n");
		return -ENOMEM;
	}

	return 0;
}

static void caif_exit_net(struct net *net)
{
	struct caif_device_entry *caifd, *tmp;
	struct caif_device_entry_list *caifdevs =
	    caif_device_list(net);
	struct cfcnfg *cfg =  get_cfcnfg(net);

	if (!cfg || !caifdevs)
		return;

	rtnl_lock();
	mutex_lock(&caifdevs->lock);

	list_for_each_entry_safe(caifd, tmp, &caifdevs->list, list) {
		int i = 0;
		list_del_rcu(&caifd->list);
		cfcnfg_set_phy_state(cfg, &caifd->layer, false);

		while (i < 10 &&
			(caifd_refcnt_read(caifd) != 0 ||
			cfcnfg_del_phy_layer(cfg, &caifd->layer) != 0)) {

			pr_info("Wait for device inuse\n");
			msleep(250);
			i++;
		}
		synchronize_rcu();
		dev_put(caifd->netdev);
		free_percpu(caifd->pcpu_refcnt);
		kfree(caifd);
	}
	cfcnfg_remove(cfg);

	mutex_unlock(&caifdevs->lock);
	rtnl_unlock();
}

static struct pernet_operations caif_net_ops = {
	.init = caif_init_net,
	.exit = caif_exit_net,
	.id   = &caif_net_id,
	.size = sizeof(struct caif_net),
};

/* Initialize Caif devices list */
static int __init caif_device_init(void)
{
	int result;

	result = register_pernet_device(&caif_net_ops);

	if (result)
		return result;

	register_netdevice_notifier(&caif_device_notifier);
	dev_add_pack(&caif_packet_type);

	return result;
}

static void __exit caif_device_exit(void)
{
	unregister_pernet_device(&caif_net_ops);
	unregister_netdevice_notifier(&caif_device_notifier);
	dev_remove_pack(&caif_packet_type);
}

module_init(caif_device_init);
module_exit(caif_device_exit);
Commit	Line	Data
c72dfae2 SB	1	/*
	2	* CAIF Interface registration.
	3	* Copyright (C) ST-Ericsson AB 2010
	4	* Author: Sjur Brendeland/sjur.brandeland@stericsson.com
	5	* License terms: GNU General Public License (GPL) version 2
	6	*
	7	* Borrowed heavily from file: pn_dev.c. Thanks to
	8	* Remi Denis-Courmont <remi.denis-courmont@nokia.com>
	9	* and Sakari Ailus <sakari.ailus@nokia.com>
	10	*/
	11
b31fa5ba JP	12	#define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__
b31fa5ba JP	13
c72dfae2 SB	14	#include <linux/kernel.h>
	15	#include <linux/if_arp.h>
	16	#include <linux/net.h>
	17	#include <linux/netdevice.h>
bd30ce4b	18	#include <linux/mutex.h>
3a9a231d	19	#include <linux/module.h>
c72dfae2 SB	20	#include <net/netns/generic.h>
	21	#include <net/net_namespace.h>
	22	#include <net/pkt_sched.h>
	23	#include <net/caif/caif_device.h>
c72dfae2 SB	24	#include <net/caif/caif_layer.h>
	25	#include <net/caif/cfpkt.h>
	26	#include <net/caif/cfcnfg.h>
7c18d220	27	#include <net/caif/cfserl.h>
c72dfae2 SB	28
c72dfae2 SB	29	MODULE_LICENSE("GPL");
c72dfae2 SB	30
	31	/* Used for local tracking of the CAIF net devices */
	32	struct caif_device_entry {
	33	struct cflayer layer;
	34	struct list_head list;
c72dfae2	35	struct net_device *netdev;
bd30ce4b	36	int __percpu *pcpu_refcnt;
c72dfae2 SB	37	};
	38
	39	struct caif_device_entry_list {
	40	struct list_head list;
	41	/* Protects simulanous deletes in list */
bd30ce4b	42	struct mutex lock;
c72dfae2 SB	43	};
	44
	45	struct caif_net {
bee925db	46	struct cfcnfg *cfg;
c72dfae2 SB	47	struct caif_device_entry_list caifdevs;
	48	};
	49
	50	static int caif_net_id;
bee925db	51
	52	struct cfcnfg get_cfcnfg(struct net net)
	53	{
	54	struct caif_net *caifn;
	55	BUG_ON(!net);
	56	caifn = net_generic(net, caif_net_id);
7c18d220	57	if (!caifn)
7c18d220	58	return NULL;
bee925db	59	return caifn->cfg;
	60	}
	61	EXPORT_SYMBOL(get_cfcnfg);
c72dfae2 SB	62
	63	static struct caif_device_entry_list caif_device_list(struct net net)
	64	{
	65	struct caif_net *caifn;
	66	BUG_ON(!net);
	67	caifn = net_generic(net, caif_net_id);
7c18d220	68	if (!caifn)
7c18d220	69	return NULL;
c72dfae2 SB	70	return &caifn->caifdevs;
	71	}
	72
bd30ce4b	73	static void caifd_put(struct caif_device_entry *e)
	74	{
	75	irqsafe_cpu_dec(*e->pcpu_refcnt);
	76	}
	77
	78	static void caifd_hold(struct caif_device_entry *e)
	79	{
	80	irqsafe_cpu_inc(*e->pcpu_refcnt);
	81	}
	82
	83	static int caifd_refcnt_read(struct caif_device_entry *e)
	84	{
	85	int i, refcnt = 0;
	86	for_each_possible_cpu(i)
	87	refcnt += *per_cpu_ptr(e->pcpu_refcnt, i);
	88	return refcnt;
	89	}
	90
c72dfae2 SB	91	/* Allocate new CAIF device. */
	92	static struct caif_device_entry caif_device_alloc(struct net_device dev)
	93	{
	94	struct caif_device_entry_list *caifdevs;
	95	struct caif_device_entry *caifd;
bd30ce4b	96
c72dfae2	97	caifdevs = caif_device_list(dev_net(dev));
7c18d220	98	if (!caifdevs)
7c18d220	99	return NULL;
bd30ce4b	100
4fb66b82	101	caifd = kzalloc(sizeof(*caifd), GFP_KERNEL);
c72dfae2 SB	102	if (!caifd)
c72dfae2 SB	103	return NULL;
bd30ce4b	104	caifd->pcpu_refcnt = alloc_percpu(int);
4fb66b82 ED	105	if (!caifd->pcpu_refcnt) {
	106	kfree(caifd);
	107	return NULL;
	108	}
c72dfae2	109	caifd->netdev = dev;
bd30ce4b	110	dev_hold(dev);
c72dfae2 SB	111	return caifd;
	112	}
	113
	114	static struct caif_device_entry caif_get(struct net_device dev)
	115	{
	116	struct caif_device_entry_list *caifdevs =
	117	caif_device_list(dev_net(dev));
	118	struct caif_device_entry *caifd;
7c18d220	119	if (!caifdevs)
	120	return NULL;
	121
bd30ce4b	122	list_for_each_entry_rcu(caifd, &caifdevs->list, list) {
c72dfae2 SB	123	if (caifd->netdev == dev)
	124	return caifd;
	125	}
	126	return NULL;
	127	}
	128
c72dfae2 SB	129	static int transmit(struct cflayer layer, struct cfpkt pkt)
c72dfae2 SB	130	{
c85c2951	131	int err;
c72dfae2 SB	132	struct caif_device_entry *caifd =
c72dfae2 SB	133	container_of(layer, struct caif_device_entry, layer);
4dd820c0 SB	134	struct sk_buff *skb;
4dd820c0 SB	135
c72dfae2 SB	136	skb = cfpkt_tonative(pkt);
c72dfae2 SB	137	skb->dev = caifd->netdev;
7c18d220	138	skb_reset_network_header(skb);
7c18d220	139	skb->protocol = htons(ETH_P_CAIF);
4dd820c0	140
c85c2951	141	err = dev_queue_xmit(skb);
	142	if (err > 0)
	143	err = -EIO;
c72dfae2	144
c85c2951	145	return err;
c72dfae2 SB	146	}
c72dfae2 SB	147
c72dfae2	148	/*
bd30ce4b	149	* Stuff received packets into the CAIF stack.
c72dfae2 SB	150	* On error, returns non-zero and releases the skb.
	151	*/
	152	static int receive(struct sk_buff skb, struct net_device dev,
	153	struct packet_type pkttype, struct net_device orig_dev)
	154	{
c72dfae2 SB	155	struct cfpkt *pkt;
c72dfae2 SB	156	struct caif_device_entry *caifd;
69c867c9	157	int err;
bd30ce4b	158
c72dfae2	159	pkt = cfpkt_fromnative(CAIF_DIR_IN, skb);
bd30ce4b	160
bd30ce4b	161	rcu_read_lock();
c72dfae2	162	caifd = caif_get(dev);
c72dfae2	163
bd30ce4b	164	if (!caifd \|\| !caifd->layer.up \|\| !caifd->layer.up->receive \|\|
	165	!netif_oper_up(caifd->netdev)) {
	166	rcu_read_unlock();
	167	kfree_skb(skb);
c72dfae2	168	return NET_RX_DROP;
bd30ce4b	169	}
	170
	171	/* Hold reference to netdevice while using CAIF stack */
	172	caifd_hold(caifd);
	173	rcu_read_unlock();
c72dfae2	174
69c867c9	175	err = caifd->layer.up->receive(caifd->layer.up, pkt);
	176
	177	/* For -EILSEQ the packet is not freed so so it now */
	178	if (err == -EILSEQ)
	179	cfpkt_destroy(pkt);
bd30ce4b	180
	181	/* Release reference to stack upwards */
	182	caifd_put(caifd);
7c18d220	183
	184	if (err != 0)
	185	err = NET_RX_DROP;
	186	return err;
c72dfae2 SB	187	}
	188
	189	static struct packet_type caif_packet_type __read_mostly = {
	190	.type = cpu_to_be16(ETH_P_CAIF),
	191	.func = receive,
	192	};
	193
	194	static void dev_flowctrl(struct net_device *dev, int on)
	195	{
bd30ce4b	196	struct caif_device_entry *caifd;
	197
	198	rcu_read_lock();
	199
	200	caifd = caif_get(dev);
	201	if (!caifd \|\| !caifd->layer.up \|\| !caifd->layer.up->ctrlcmd) {
	202	rcu_read_unlock();
c72dfae2	203	return;
bd30ce4b	204	}
	205
	206	caifd_hold(caifd);
	207	rcu_read_unlock();
c72dfae2 SB	208
	209	caifd->layer.up->ctrlcmd(caifd->layer.up,
	210	on ?
	211	_CAIF_CTRLCMD_PHYIF_FLOW_ON_IND :
	212	_CAIF_CTRLCMD_PHYIF_FLOW_OFF_IND,
	213	caifd->layer.id);
bd30ce4b	214	caifd_put(caifd);
c72dfae2 SB	215	}
c72dfae2 SB	216
7c18d220	217	void caif_enroll_dev(struct net_device dev, struct caif_dev_common caifdev,
	218	struct cflayer *link_support, int head_room,
	219	struct cflayer layer, int (rcv_func)(
	220	struct sk_buff , struct net_device ,
	221	struct packet_type , struct net_device ))
	222	{
	223	struct caif_device_entry *caifd;
	224	enum cfcnfg_phy_preference pref;
	225	struct cfcnfg *cfg = get_cfcnfg(dev_net(dev));
	226	struct caif_device_entry_list *caifdevs;
	227
	228	caifdevs = caif_device_list(dev_net(dev));
	229	if (!cfg \|\| !caifdevs)
	230	return;
	231	caifd = caif_device_alloc(dev);
	232	if (!caifd)
	233	return;
	234	*layer = &caifd->layer;
	235
	236	switch (caifdev->link_select) {
	237	case CAIF_LINK_HIGH_BANDW:
	238	pref = CFPHYPREF_HIGH_BW;
	239	break;
	240	case CAIF_LINK_LOW_LATENCY:
	241	pref = CFPHYPREF_LOW_LAT;
	242	break;
	243	default:
	244	pref = CFPHYPREF_HIGH_BW;
	245	break;
	246	}
	247	mutex_lock(&caifdevs->lock);
	248	list_add_rcu(&caifd->list, &caifdevs->list);
	249
	250	strncpy(caifd->layer.name, dev->name,
	251	sizeof(caifd->layer.name) - 1);
	252	caifd->layer.name[sizeof(caifd->layer.name) - 1] = 0;
	253	caifd->layer.transmit = transmit;
	254	cfcnfg_add_phy_layer(cfg,
	255	dev,
	256	&caifd->layer,
	257	pref,
	258	link_support,
	259	caifdev->use_fcs,
	260	head_room);
	261	mutex_unlock(&caifdevs->lock);
	262	if (rcv_func)
	263	*rcv_func = receive;
	264	}
	265
c72dfae2 SB	266	/* notify Caif of device events */
	267	static int caif_device_notify(struct notifier_block *me, unsigned long what,
	268	void *arg)
	269	{
	270	struct net_device *dev = arg;
	271	struct caif_device_entry *caifd = NULL;
	272	struct caif_dev_common *caifdev;
bee925db	273	struct cfcnfg *cfg;
7c18d220	274	struct cflayer layer, link_support;
7c18d220	275	int head_room = 0;
08613e46	276	struct caif_device_entry_list *caifdevs;
c72dfae2	277
bee925db	278	cfg = get_cfcnfg(dev_net(dev));
7c18d220	279	caifdevs = caif_device_list(dev_net(dev));
7c18d220	280	if (!cfg \|\| !caifdevs)
bee925db	281	return 0;
bee925db	282
7c18d220	283	caifd = caif_get(dev);
	284	if (caifd == NULL && dev->type != ARPHRD_CAIF)
	285	return 0;
08613e46	286
c72dfae2 SB	287	switch (what) {
c72dfae2 SB	288	case NETDEV_REGISTER:
7c18d220	289	if (caifd != NULL)
7c18d220	290	break;
bd30ce4b	291
c72dfae2	292	caifdev = netdev_priv(dev);
c72dfae2	293
7c18d220	294	link_support = NULL;
	295	if (caifdev->use_frag) {
	296	head_room = 1;
	297	link_support = cfserl_create(dev->ifindex,
e977b4cf	298	caifdev->use_stx);
7c18d220	299	if (!link_support) {
	300	pr_warn("Out of memory\n");
	301	break;
	302	}
c72dfae2	303	}
7c18d220	304	caif_enroll_dev(dev, caifdev, link_support, head_room,
	305	&layer, NULL);
	306	caifdev->flowctrl = dev_flowctrl;
c72dfae2 SB	307	break;
c72dfae2 SB	308
bd30ce4b	309	case NETDEV_UP:
	310	rcu_read_lock();
	311
c72dfae2	312	caifd = caif_get(dev);
bd30ce4b	313	if (caifd == NULL) {
bd30ce4b	314	rcu_read_unlock();
c72dfae2	315	break;
bd30ce4b	316	}
c72dfae2	317
bd30ce4b	318	cfcnfg_set_phy_state(cfg, &caifd->layer, true);
bd30ce4b	319	rcu_read_unlock();
c72dfae2	320
c72dfae2 SB	321	break;
	322
	323	case NETDEV_DOWN:
bd30ce4b	324	rcu_read_lock();
bd30ce4b	325
c72dfae2	326	caifd = caif_get(dev);
bd30ce4b	327	if (!caifd \|\| !caifd->layer.up \|\| !caifd->layer.up->ctrlcmd) {
	328	rcu_read_unlock();
	329	return -EINVAL;
	330	}
	331
	332	cfcnfg_set_phy_state(cfg, &caifd->layer, false);
	333	caifd_hold(caifd);
	334	rcu_read_unlock();
	335
	336	caifd->layer.up->ctrlcmd(caifd->layer.up,
	337	_CAIF_CTRLCMD_PHYIF_DOWN_IND,
	338	caifd->layer.id);
	339	caifd_put(caifd);
c72dfae2 SB	340	break;
	341
	342	case NETDEV_UNREGISTER:
bd30ce4b	343	mutex_lock(&caifdevs->lock);
bd30ce4b	344
c72dfae2	345	caifd = caif_get(dev);
bd30ce4b	346	if (caifd == NULL) {
bd30ce4b	347	mutex_unlock(&caifdevs->lock);
f2527ec4	348	break;
bd30ce4b	349	}
	350	list_del_rcu(&caifd->list);
	351
	352	/*
	353	* NETDEV_UNREGISTER is called repeatedly until all reference
	354	* counts for the net-device are released. If references to
	355	* caifd is taken, simply ignore NETDEV_UNREGISTER and wait for
	356	* the next call to NETDEV_UNREGISTER.
	357	*
	358	* If any packets are in flight down the CAIF Stack,
	359	* cfcnfg_del_phy_layer will return nonzero.
	360	* If no packets are in flight, the CAIF Stack associated
	361	* with the net-device un-registering is freed.
	362	*/
	363
	364	if (caifd_refcnt_read(caifd) != 0 \|\|
	365	cfcnfg_del_phy_layer(cfg, &caifd->layer) != 0) {
	366
	367	pr_info("Wait for device inuse\n");
	368	/* Enrole device if CAIF Stack is still in use */
	369	list_add_rcu(&caifd->list, &caifdevs->list);
	370	mutex_unlock(&caifdevs->lock);
	371	break;
	372	}
	373
	374	synchronize_rcu();
	375	dev_put(caifd->netdev);
	376	free_percpu(caifd->pcpu_refcnt);
	377	kfree(caifd);
	378
	379	mutex_unlock(&caifdevs->lock);
c72dfae2 SB	380	break;
	381	}
	382	return 0;
	383	}
	384
	385	static struct notifier_block caif_device_notifier = {
	386	.notifier_call = caif_device_notify,
	387	.priority = 0,
	388	};
	389
c72dfae2 SB	390	/* Per-namespace Caif devices handling */
	391	static int caif_init_net(struct net *net)
	392	{
	393	struct caif_net *caifn = net_generic(net, caif_net_id);
bee925db	394	BUG_ON(!caifn);
c72dfae2	395	INIT_LIST_HEAD(&caifn->caifdevs.list);
bd30ce4b	396	mutex_init(&caifn->caifdevs.lock);
bee925db	397
	398	caifn->cfg = cfcnfg_create();
	399	if (!caifn->cfg) {
	400	pr_warn("can't create cfcnfg\n");
	401	return -ENOMEM;
	402	}
	403
c72dfae2 SB	404	return 0;
	405	}
	406
	407	static void caif_exit_net(struct net *net)
	408	{
bd30ce4b	409	struct caif_device_entry caifd, tmp;
	410	struct caif_device_entry_list *caifdevs =
	411	caif_device_list(net);
7c18d220	412	struct cfcnfg *cfg = get_cfcnfg(net);
	413
	414	if (!cfg \|\| !caifdevs)
	415	return;
bd30ce4b	416
c72dfae2	417	rtnl_lock();
bd30ce4b	418	mutex_lock(&caifdevs->lock);
	419
	420	list_for_each_entry_safe(caifd, tmp, &caifdevs->list, list) {
	421	int i = 0;
	422	list_del_rcu(&caifd->list);
	423	cfcnfg_set_phy_state(cfg, &caifd->layer, false);
	424
	425	while (i < 10 &&
	426	(caifd_refcnt_read(caifd) != 0 \|\|
	427	cfcnfg_del_phy_layer(cfg, &caifd->layer) != 0)) {
	428
	429	pr_info("Wait for device inuse\n");
	430	msleep(250);
	431	i++;
	432	}
	433	synchronize_rcu();
	434	dev_put(caifd->netdev);
	435	free_percpu(caifd->pcpu_refcnt);
	436	kfree(caifd);
c72dfae2	437	}
bee925db	438	cfcnfg_remove(cfg);
bd30ce4b	439
bd30ce4b	440	mutex_unlock(&caifdevs->lock);
c72dfae2 SB	441	rtnl_unlock();
	442	}
	443
	444	static struct pernet_operations caif_net_ops = {
	445	.init = caif_init_net,
	446	.exit = caif_exit_net,
	447	.id = &caif_net_id,
	448	.size = sizeof(struct caif_net),
	449	};
	450
	451	/* Initialize Caif devices list */
	452	static int __init caif_device_init(void)
	453	{
	454	int result;
bd30ce4b	455
c72dfae2 SB	456	result = register_pernet_device(&caif_net_ops);
c72dfae2 SB	457
bee925db	458	if (result)
c72dfae2	459	return result;
bee925db	460
c72dfae2	461	register_netdevice_notifier(&caif_device_notifier);
bee925db	462	dev_add_pack(&caif_packet_type);
c72dfae2 SB	463
c72dfae2 SB	464	return result;
c72dfae2 SB	465	}
	466
	467	static void __exit caif_device_exit(void)
	468	{
c72dfae2 SB	469	unregister_pernet_device(&caif_net_ops);
c72dfae2 SB	470	unregister_netdevice_notifier(&caif_device_notifier);
bee925db	471	dev_remove_pack(&caif_packet_type);
c72dfae2 SB	472	}
	473
	474	module_init(caif_device_init);
	475	module_exit(caif_device_exit);