Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 1 | /* |
| 2 | * CAIF Interface registration. |
| 3 | * Copyright (C) ST-Ericsson AB 2010 |
sjur.brandeland@stericsson.com | 26ee65e | 2013-04-22 23:57:01 +0000 | [diff] [blame] | 4 | * Author: Sjur Brendeland |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 5 | * License terms: GNU General Public License (GPL) version 2 |
| 6 | * |
Rémi Denis-Courmont | 31fdc55 | 2012-06-13 22:29:03 +0000 | [diff] [blame] | 7 | * Borrowed heavily from file: pn_dev.c. Thanks to Remi Denis-Courmont |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 8 | * and Sakari Ailus <sakari.ailus@nokia.com> |
| 9 | */ |
| 10 | |
Joe Perches | b31fa5b | 2010-09-05 21:31:11 +0000 | [diff] [blame] | 11 | #define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__ |
| 12 | |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 13 | #include <linux/kernel.h> |
| 14 | #include <linux/if_arp.h> |
| 15 | #include <linux/net.h> |
| 16 | #include <linux/netdevice.h> |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 17 | #include <linux/mutex.h> |
Paul Gortmaker | 3a9a231 | 2011-05-27 09:12:25 -0400 | [diff] [blame] | 18 | #include <linux/module.h> |
sjur.brandeland@stericsson.com | 0e4c7d8 | 2011-12-04 11:22:54 +0000 | [diff] [blame] | 19 | #include <linux/spinlock.h> |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 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> |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 24 | #include <net/caif/caif_layer.h> |
| 25 | #include <net/caif/cfpkt.h> |
| 26 | #include <net/caif/cfcnfg.h> |
sjur.brandeland@stericsson.com | 7c18d22 | 2011-11-30 09:22:47 +0000 | [diff] [blame] | 27 | #include <net/caif/cfserl.h> |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 28 | |
| 29 | MODULE_LICENSE("GPL"); |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 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; |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 35 | struct net_device *netdev; |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 36 | int __percpu *pcpu_refcnt; |
sjur.brandeland@stericsson.com | 0e4c7d8 | 2011-12-04 11:22:54 +0000 | [diff] [blame] | 37 | spinlock_t flow_lock; |
sjur.brandeland@stericsson.com | 7d31130 | 2011-12-04 11:22:55 +0000 | [diff] [blame] | 38 | struct sk_buff *xoff_skb; |
| 39 | void (*xoff_skb_dtor)(struct sk_buff *skb); |
sjur.brandeland@stericsson.com | 0e4c7d8 | 2011-12-04 11:22:54 +0000 | [diff] [blame] | 40 | bool xoff; |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 41 | }; |
| 42 | |
| 43 | struct caif_device_entry_list { |
| 44 | struct list_head list; |
| 45 | /* Protects simulanous deletes in list */ |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 46 | struct mutex lock; |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 47 | }; |
| 48 | |
| 49 | struct caif_net { |
sjur.brandeland@stericsson.com | bee925d | 2011-05-13 02:44:05 +0000 | [diff] [blame] | 50 | struct cfcnfg *cfg; |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 51 | struct caif_device_entry_list caifdevs; |
| 52 | }; |
| 53 | |
| 54 | static int caif_net_id; |
sjur.brandeland@stericsson.com | 0e4c7d8 | 2011-12-04 11:22:54 +0000 | [diff] [blame] | 55 | static int q_high = 50; /* Percent */ |
sjur.brandeland@stericsson.com | bee925d | 2011-05-13 02:44:05 +0000 | [diff] [blame] | 56 | |
| 57 | struct cfcnfg *get_cfcnfg(struct net *net) |
| 58 | { |
| 59 | struct caif_net *caifn; |
sjur.brandeland@stericsson.com | bee925d | 2011-05-13 02:44:05 +0000 | [diff] [blame] | 60 | caifn = net_generic(net, caif_net_id); |
sjur.brandeland@stericsson.com | bee925d | 2011-05-13 02:44:05 +0000 | [diff] [blame] | 61 | return caifn->cfg; |
| 62 | } |
| 63 | EXPORT_SYMBOL(get_cfcnfg); |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 64 | |
| 65 | static struct caif_device_entry_list *caif_device_list(struct net *net) |
| 66 | { |
| 67 | struct caif_net *caifn; |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 68 | caifn = net_generic(net, caif_net_id); |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 69 | return &caifn->caifdevs; |
| 70 | } |
| 71 | |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 72 | static void caifd_put(struct caif_device_entry *e) |
| 73 | { |
Christoph Lameter | 933393f | 2011-12-22 11:58:51 -0600 | [diff] [blame] | 74 | this_cpu_dec(*e->pcpu_refcnt); |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 75 | } |
| 76 | |
| 77 | static void caifd_hold(struct caif_device_entry *e) |
| 78 | { |
Christoph Lameter | 933393f | 2011-12-22 11:58:51 -0600 | [diff] [blame] | 79 | this_cpu_inc(*e->pcpu_refcnt); |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 80 | } |
| 81 | |
| 82 | static int caifd_refcnt_read(struct caif_device_entry *e) |
| 83 | { |
| 84 | int i, refcnt = 0; |
| 85 | for_each_possible_cpu(i) |
| 86 | refcnt += *per_cpu_ptr(e->pcpu_refcnt, i); |
| 87 | return refcnt; |
| 88 | } |
| 89 | |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 90 | /* Allocate new CAIF device. */ |
| 91 | static struct caif_device_entry *caif_device_alloc(struct net_device *dev) |
| 92 | { |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 93 | struct caif_device_entry *caifd; |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 94 | |
Eric Dumazet | 4fb66b8 | 2011-09-02 02:19:23 +0000 | [diff] [blame] | 95 | caifd = kzalloc(sizeof(*caifd), GFP_KERNEL); |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 96 | if (!caifd) |
| 97 | return NULL; |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 98 | caifd->pcpu_refcnt = alloc_percpu(int); |
Eric Dumazet | 4fb66b8 | 2011-09-02 02:19:23 +0000 | [diff] [blame] | 99 | if (!caifd->pcpu_refcnt) { |
| 100 | kfree(caifd); |
| 101 | return NULL; |
| 102 | } |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 103 | caifd->netdev = dev; |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 104 | dev_hold(dev); |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 105 | return caifd; |
| 106 | } |
| 107 | |
| 108 | static struct caif_device_entry *caif_get(struct net_device *dev) |
| 109 | { |
| 110 | struct caif_device_entry_list *caifdevs = |
| 111 | caif_device_list(dev_net(dev)); |
| 112 | struct caif_device_entry *caifd; |
sjur.brandeland@stericsson.com | 7c18d22 | 2011-11-30 09:22:47 +0000 | [diff] [blame] | 113 | |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 114 | list_for_each_entry_rcu(caifd, &caifdevs->list, list) { |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 115 | if (caifd->netdev == dev) |
| 116 | return caifd; |
| 117 | } |
| 118 | return NULL; |
| 119 | } |
| 120 | |
Silviu-Mihai Popescu | d6e89c0 | 2013-03-02 09:45:19 +0000 | [diff] [blame] | 121 | static void caif_flow_cb(struct sk_buff *skb) |
sjur.brandeland@stericsson.com | 0e4c7d8 | 2011-12-04 11:22:54 +0000 | [diff] [blame] | 122 | { |
| 123 | struct caif_device_entry *caifd; |
sjur.brandeland@stericsson.com | 7d31130 | 2011-12-04 11:22:55 +0000 | [diff] [blame] | 124 | void (*dtor)(struct sk_buff *skb) = NULL; |
sjur.brandeland@stericsson.com | 0e4c7d8 | 2011-12-04 11:22:54 +0000 | [diff] [blame] | 125 | bool send_xoff; |
| 126 | |
| 127 | WARN_ON(skb->dev == NULL); |
| 128 | |
| 129 | rcu_read_lock(); |
| 130 | caifd = caif_get(skb->dev); |
Kim Lilliestierna XX | c95567c | 2012-06-25 07:49:34 +0000 | [diff] [blame] | 131 | |
| 132 | WARN_ON(caifd == NULL); |
| 133 | if (caifd == NULL) |
| 134 | return; |
| 135 | |
sjur.brandeland@stericsson.com | 0e4c7d8 | 2011-12-04 11:22:54 +0000 | [diff] [blame] | 136 | caifd_hold(caifd); |
| 137 | rcu_read_unlock(); |
| 138 | |
| 139 | spin_lock_bh(&caifd->flow_lock); |
| 140 | send_xoff = caifd->xoff; |
| 141 | caifd->xoff = 0; |
sjur.brandeland@stericsson.com | 59f608d | 2012-01-17 03:03:14 +0000 | [diff] [blame] | 142 | dtor = caifd->xoff_skb_dtor; |
| 143 | |
| 144 | if (WARN_ON(caifd->xoff_skb != skb)) |
| 145 | skb = NULL; |
| 146 | |
| 147 | caifd->xoff_skb = NULL; |
| 148 | caifd->xoff_skb_dtor = NULL; |
| 149 | |
sjur.brandeland@stericsson.com | 0e4c7d8 | 2011-12-04 11:22:54 +0000 | [diff] [blame] | 150 | spin_unlock_bh(&caifd->flow_lock); |
| 151 | |
sjur.brandeland@stericsson.com | 59f608d | 2012-01-17 03:03:14 +0000 | [diff] [blame] | 152 | if (dtor && skb) |
sjur.brandeland@stericsson.com | 7d31130 | 2011-12-04 11:22:55 +0000 | [diff] [blame] | 153 | dtor(skb); |
| 154 | |
sjur.brandeland@stericsson.com | 0e4c7d8 | 2011-12-04 11:22:54 +0000 | [diff] [blame] | 155 | if (send_xoff) |
| 156 | caifd->layer.up-> |
| 157 | ctrlcmd(caifd->layer.up, |
| 158 | _CAIF_CTRLCMD_PHYIF_FLOW_ON_IND, |
| 159 | caifd->layer.id); |
| 160 | caifd_put(caifd); |
| 161 | } |
| 162 | |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 163 | static int transmit(struct cflayer *layer, struct cfpkt *pkt) |
| 164 | { |
sjur.brandeland@stericsson.com | 0e4c7d8 | 2011-12-04 11:22:54 +0000 | [diff] [blame] | 165 | int err, high = 0, qlen = 0; |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 166 | struct caif_device_entry *caifd = |
| 167 | container_of(layer, struct caif_device_entry, layer); |
Sjur Brændeland | 4dd820c | 2011-04-11 10:43:51 +0000 | [diff] [blame] | 168 | struct sk_buff *skb; |
sjur.brandeland@stericsson.com | 0e4c7d8 | 2011-12-04 11:22:54 +0000 | [diff] [blame] | 169 | struct netdev_queue *txq; |
| 170 | |
| 171 | rcu_read_lock_bh(); |
Sjur Brændeland | 4dd820c | 2011-04-11 10:43:51 +0000 | [diff] [blame] | 172 | |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 173 | skb = cfpkt_tonative(pkt); |
| 174 | skb->dev = caifd->netdev; |
sjur.brandeland@stericsson.com | 7c18d22 | 2011-11-30 09:22:47 +0000 | [diff] [blame] | 175 | skb_reset_network_header(skb); |
| 176 | skb->protocol = htons(ETH_P_CAIF); |
sjur.brandeland@stericsson.com | 0e4c7d8 | 2011-12-04 11:22:54 +0000 | [diff] [blame] | 177 | |
| 178 | /* Check if we need to handle xoff */ |
| 179 | if (likely(caifd->netdev->tx_queue_len == 0)) |
| 180 | goto noxoff; |
| 181 | |
| 182 | if (unlikely(caifd->xoff)) |
| 183 | goto noxoff; |
| 184 | |
| 185 | if (likely(!netif_queue_stopped(caifd->netdev))) { |
| 186 | /* If we run with a TX queue, check if the queue is too long*/ |
| 187 | txq = netdev_get_tx_queue(skb->dev, 0); |
| 188 | qlen = qdisc_qlen(rcu_dereference_bh(txq->qdisc)); |
| 189 | |
| 190 | if (likely(qlen == 0)) |
| 191 | goto noxoff; |
| 192 | |
| 193 | high = (caifd->netdev->tx_queue_len * q_high) / 100; |
| 194 | if (likely(qlen < high)) |
| 195 | goto noxoff; |
| 196 | } |
| 197 | |
| 198 | /* Hold lock while accessing xoff */ |
| 199 | spin_lock_bh(&caifd->flow_lock); |
| 200 | if (caifd->xoff) { |
| 201 | spin_unlock_bh(&caifd->flow_lock); |
| 202 | goto noxoff; |
| 203 | } |
| 204 | |
| 205 | /* |
| 206 | * Handle flow off, we do this by temporary hi-jacking this |
| 207 | * skb's destructor function, and replace it with our own |
| 208 | * flow-on callback. The callback will set flow-on and call |
| 209 | * the original destructor. |
| 210 | */ |
| 211 | |
| 212 | pr_debug("queue has stopped(%d) or is full (%d > %d)\n", |
| 213 | netif_queue_stopped(caifd->netdev), |
| 214 | qlen, high); |
| 215 | caifd->xoff = 1; |
sjur.brandeland@stericsson.com | 7d31130 | 2011-12-04 11:22:55 +0000 | [diff] [blame] | 216 | caifd->xoff_skb = skb; |
| 217 | caifd->xoff_skb_dtor = skb->destructor; |
| 218 | skb->destructor = caif_flow_cb; |
sjur.brandeland@stericsson.com | 0e4c7d8 | 2011-12-04 11:22:54 +0000 | [diff] [blame] | 219 | spin_unlock_bh(&caifd->flow_lock); |
sjur.brandeland@stericsson.com | 0e4c7d8 | 2011-12-04 11:22:54 +0000 | [diff] [blame] | 220 | |
| 221 | caifd->layer.up->ctrlcmd(caifd->layer.up, |
| 222 | _CAIF_CTRLCMD_PHYIF_FLOW_OFF_IND, |
| 223 | caifd->layer.id); |
| 224 | noxoff: |
| 225 | rcu_read_unlock_bh(); |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 226 | |
sjur.brandeland@stericsson.com | c85c295 | 2011-05-13 02:44:06 +0000 | [diff] [blame] | 227 | err = dev_queue_xmit(skb); |
| 228 | if (err > 0) |
| 229 | err = -EIO; |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 230 | |
sjur.brandeland@stericsson.com | c85c295 | 2011-05-13 02:44:06 +0000 | [diff] [blame] | 231 | return err; |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 232 | } |
| 233 | |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 234 | /* |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 235 | * Stuff received packets into the CAIF stack. |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 236 | * On error, returns non-zero and releases the skb. |
| 237 | */ |
| 238 | static int receive(struct sk_buff *skb, struct net_device *dev, |
| 239 | struct packet_type *pkttype, struct net_device *orig_dev) |
| 240 | { |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 241 | struct cfpkt *pkt; |
| 242 | struct caif_device_entry *caifd; |
sjur.brandeland@stericsson.com | 69c867c9 | 2011-05-22 11:18:54 +0000 | [diff] [blame] | 243 | int err; |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 244 | |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 245 | pkt = cfpkt_fromnative(CAIF_DIR_IN, skb); |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 246 | |
| 247 | rcu_read_lock(); |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 248 | caifd = caif_get(dev); |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 249 | |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 250 | if (!caifd || !caifd->layer.up || !caifd->layer.up->receive || |
| 251 | !netif_oper_up(caifd->netdev)) { |
| 252 | rcu_read_unlock(); |
| 253 | kfree_skb(skb); |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 254 | return NET_RX_DROP; |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 255 | } |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 256 | |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 257 | /* Hold reference to netdevice while using CAIF stack */ |
| 258 | caifd_hold(caifd); |
| 259 | rcu_read_unlock(); |
| 260 | |
sjur.brandeland@stericsson.com | 69c867c9 | 2011-05-22 11:18:54 +0000 | [diff] [blame] | 261 | err = caifd->layer.up->receive(caifd->layer.up, pkt); |
| 262 | |
| 263 | /* For -EILSEQ the packet is not freed so so it now */ |
| 264 | if (err == -EILSEQ) |
| 265 | cfpkt_destroy(pkt); |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 266 | |
| 267 | /* Release reference to stack upwards */ |
| 268 | caifd_put(caifd); |
sjur.brandeland@stericsson.com | 7c18d22 | 2011-11-30 09:22:47 +0000 | [diff] [blame] | 269 | |
| 270 | if (err != 0) |
| 271 | err = NET_RX_DROP; |
| 272 | return err; |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 273 | } |
| 274 | |
| 275 | static struct packet_type caif_packet_type __read_mostly = { |
| 276 | .type = cpu_to_be16(ETH_P_CAIF), |
| 277 | .func = receive, |
| 278 | }; |
| 279 | |
| 280 | static void dev_flowctrl(struct net_device *dev, int on) |
| 281 | { |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 282 | struct caif_device_entry *caifd; |
| 283 | |
| 284 | rcu_read_lock(); |
| 285 | |
| 286 | caifd = caif_get(dev); |
| 287 | if (!caifd || !caifd->layer.up || !caifd->layer.up->ctrlcmd) { |
| 288 | rcu_read_unlock(); |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 289 | return; |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 290 | } |
| 291 | |
| 292 | caifd_hold(caifd); |
| 293 | rcu_read_unlock(); |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 294 | |
| 295 | caifd->layer.up->ctrlcmd(caifd->layer.up, |
| 296 | on ? |
| 297 | _CAIF_CTRLCMD_PHYIF_FLOW_ON_IND : |
| 298 | _CAIF_CTRLCMD_PHYIF_FLOW_OFF_IND, |
| 299 | caifd->layer.id); |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 300 | caifd_put(caifd); |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 301 | } |
| 302 | |
sjur.brandeland@stericsson.com | 7c18d22 | 2011-11-30 09:22:47 +0000 | [diff] [blame] | 303 | void caif_enroll_dev(struct net_device *dev, struct caif_dev_common *caifdev, |
Silviu-Mihai Popescu | 3bffc47 | 2013-03-06 19:39:57 +0000 | [diff] [blame] | 304 | struct cflayer *link_support, int head_room, |
| 305 | struct cflayer **layer, |
| 306 | int (**rcv_func)(struct sk_buff *, struct net_device *, |
| 307 | struct packet_type *, |
| 308 | struct net_device *)) |
sjur.brandeland@stericsson.com | 7c18d22 | 2011-11-30 09:22:47 +0000 | [diff] [blame] | 309 | { |
| 310 | struct caif_device_entry *caifd; |
| 311 | enum cfcnfg_phy_preference pref; |
| 312 | struct cfcnfg *cfg = get_cfcnfg(dev_net(dev)); |
| 313 | struct caif_device_entry_list *caifdevs; |
| 314 | |
| 315 | caifdevs = caif_device_list(dev_net(dev)); |
sjur.brandeland@stericsson.com | 7c18d22 | 2011-11-30 09:22:47 +0000 | [diff] [blame] | 316 | caifd = caif_device_alloc(dev); |
| 317 | if (!caifd) |
| 318 | return; |
| 319 | *layer = &caifd->layer; |
sjur.brandeland@stericsson.com | 0e4c7d8 | 2011-12-04 11:22:54 +0000 | [diff] [blame] | 320 | spin_lock_init(&caifd->flow_lock); |
sjur.brandeland@stericsson.com | 7c18d22 | 2011-11-30 09:22:47 +0000 | [diff] [blame] | 321 | |
| 322 | switch (caifdev->link_select) { |
| 323 | case CAIF_LINK_HIGH_BANDW: |
| 324 | pref = CFPHYPREF_HIGH_BW; |
| 325 | break; |
| 326 | case CAIF_LINK_LOW_LATENCY: |
| 327 | pref = CFPHYPREF_LOW_LAT; |
| 328 | break; |
| 329 | default: |
| 330 | pref = CFPHYPREF_HIGH_BW; |
| 331 | break; |
| 332 | } |
| 333 | mutex_lock(&caifdevs->lock); |
| 334 | list_add_rcu(&caifd->list, &caifdevs->list); |
| 335 | |
| 336 | strncpy(caifd->layer.name, dev->name, |
| 337 | sizeof(caifd->layer.name) - 1); |
| 338 | caifd->layer.name[sizeof(caifd->layer.name) - 1] = 0; |
| 339 | caifd->layer.transmit = transmit; |
| 340 | cfcnfg_add_phy_layer(cfg, |
| 341 | dev, |
| 342 | &caifd->layer, |
| 343 | pref, |
| 344 | link_support, |
| 345 | caifdev->use_fcs, |
| 346 | head_room); |
| 347 | mutex_unlock(&caifdevs->lock); |
| 348 | if (rcv_func) |
| 349 | *rcv_func = receive; |
| 350 | } |
sjur.brandeland@stericsson.com | 7ad65bf | 2011-12-04 11:22:53 +0000 | [diff] [blame] | 351 | EXPORT_SYMBOL(caif_enroll_dev); |
sjur.brandeland@stericsson.com | 7c18d22 | 2011-11-30 09:22:47 +0000 | [diff] [blame] | 352 | |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 353 | /* notify Caif of device events */ |
| 354 | static int caif_device_notify(struct notifier_block *me, unsigned long what, |
Jiri Pirko | 351638e | 2013-05-28 01:30:21 +0000 | [diff] [blame^] | 355 | void *ptr) |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 356 | { |
Jiri Pirko | 351638e | 2013-05-28 01:30:21 +0000 | [diff] [blame^] | 357 | struct net_device *dev = netdev_notifier_info_to_dev(ptr); |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 358 | struct caif_device_entry *caifd = NULL; |
| 359 | struct caif_dev_common *caifdev; |
sjur.brandeland@stericsson.com | bee925d | 2011-05-13 02:44:05 +0000 | [diff] [blame] | 360 | struct cfcnfg *cfg; |
sjur.brandeland@stericsson.com | 7c18d22 | 2011-11-30 09:22:47 +0000 | [diff] [blame] | 361 | struct cflayer *layer, *link_support; |
| 362 | int head_room = 0; |
David Woodhouse | 08613e4 | 2011-10-24 21:25:21 +0000 | [diff] [blame] | 363 | struct caif_device_entry_list *caifdevs; |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 364 | |
sjur.brandeland@stericsson.com | bee925d | 2011-05-13 02:44:05 +0000 | [diff] [blame] | 365 | cfg = get_cfcnfg(dev_net(dev)); |
sjur.brandeland@stericsson.com | 7c18d22 | 2011-11-30 09:22:47 +0000 | [diff] [blame] | 366 | caifdevs = caif_device_list(dev_net(dev)); |
sjur.brandeland@stericsson.com | bee925d | 2011-05-13 02:44:05 +0000 | [diff] [blame] | 367 | |
sjur.brandeland@stericsson.com | 7c18d22 | 2011-11-30 09:22:47 +0000 | [diff] [blame] | 368 | caifd = caif_get(dev); |
| 369 | if (caifd == NULL && dev->type != ARPHRD_CAIF) |
| 370 | return 0; |
David Woodhouse | 08613e4 | 2011-10-24 21:25:21 +0000 | [diff] [blame] | 371 | |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 372 | switch (what) { |
| 373 | case NETDEV_REGISTER: |
sjur.brandeland@stericsson.com | 7c18d22 | 2011-11-30 09:22:47 +0000 | [diff] [blame] | 374 | if (caifd != NULL) |
| 375 | break; |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 376 | |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 377 | caifdev = netdev_priv(dev); |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 378 | |
sjur.brandeland@stericsson.com | 7c18d22 | 2011-11-30 09:22:47 +0000 | [diff] [blame] | 379 | link_support = NULL; |
| 380 | if (caifdev->use_frag) { |
| 381 | head_room = 1; |
| 382 | link_support = cfserl_create(dev->ifindex, |
sjur.brandeland@stericsson.com | e977b4c | 2011-11-30 09:22:48 +0000 | [diff] [blame] | 383 | caifdev->use_stx); |
sjur.brandeland@stericsson.com | 7c18d22 | 2011-11-30 09:22:47 +0000 | [diff] [blame] | 384 | if (!link_support) { |
| 385 | pr_warn("Out of memory\n"); |
| 386 | break; |
| 387 | } |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 388 | } |
sjur.brandeland@stericsson.com | 7c18d22 | 2011-11-30 09:22:47 +0000 | [diff] [blame] | 389 | caif_enroll_dev(dev, caifdev, link_support, head_room, |
| 390 | &layer, NULL); |
| 391 | caifdev->flowctrl = dev_flowctrl; |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 392 | break; |
| 393 | |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 394 | case NETDEV_UP: |
| 395 | rcu_read_lock(); |
| 396 | |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 397 | caifd = caif_get(dev); |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 398 | if (caifd == NULL) { |
| 399 | rcu_read_unlock(); |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 400 | break; |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 401 | } |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 402 | |
sjur.brandeland@stericsson.com | 0e4c7d8 | 2011-12-04 11:22:54 +0000 | [diff] [blame] | 403 | caifd->xoff = 0; |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 404 | cfcnfg_set_phy_state(cfg, &caifd->layer, true); |
| 405 | rcu_read_unlock(); |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 406 | |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 407 | break; |
| 408 | |
| 409 | case NETDEV_DOWN: |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 410 | rcu_read_lock(); |
| 411 | |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 412 | caifd = caif_get(dev); |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 413 | if (!caifd || !caifd->layer.up || !caifd->layer.up->ctrlcmd) { |
| 414 | rcu_read_unlock(); |
| 415 | return -EINVAL; |
| 416 | } |
| 417 | |
| 418 | cfcnfg_set_phy_state(cfg, &caifd->layer, false); |
| 419 | caifd_hold(caifd); |
| 420 | rcu_read_unlock(); |
| 421 | |
| 422 | caifd->layer.up->ctrlcmd(caifd->layer.up, |
| 423 | _CAIF_CTRLCMD_PHYIF_DOWN_IND, |
| 424 | caifd->layer.id); |
sjur.brandeland@stericsson.com | 7d31130 | 2011-12-04 11:22:55 +0000 | [diff] [blame] | 425 | |
| 426 | spin_lock_bh(&caifd->flow_lock); |
| 427 | |
| 428 | /* |
| 429 | * Replace our xoff-destructor with original destructor. |
| 430 | * We trust that skb->destructor *always* is called before |
| 431 | * the skb reference is invalid. The hijacked SKB destructor |
| 432 | * takes the flow_lock so manipulating the skb->destructor here |
| 433 | * should be safe. |
| 434 | */ |
| 435 | if (caifd->xoff_skb_dtor != NULL && caifd->xoff_skb != NULL) |
| 436 | caifd->xoff_skb->destructor = caifd->xoff_skb_dtor; |
| 437 | |
| 438 | caifd->xoff = 0; |
| 439 | caifd->xoff_skb_dtor = NULL; |
| 440 | caifd->xoff_skb = NULL; |
| 441 | |
| 442 | spin_unlock_bh(&caifd->flow_lock); |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 443 | caifd_put(caifd); |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 444 | break; |
| 445 | |
| 446 | case NETDEV_UNREGISTER: |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 447 | mutex_lock(&caifdevs->lock); |
| 448 | |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 449 | caifd = caif_get(dev); |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 450 | if (caifd == NULL) { |
| 451 | mutex_unlock(&caifdevs->lock); |
André Carvalho de Matos | f2527ec | 2010-11-01 11:52:47 +0000 | [diff] [blame] | 452 | break; |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 453 | } |
| 454 | list_del_rcu(&caifd->list); |
| 455 | |
| 456 | /* |
| 457 | * NETDEV_UNREGISTER is called repeatedly until all reference |
| 458 | * counts for the net-device are released. If references to |
| 459 | * caifd is taken, simply ignore NETDEV_UNREGISTER and wait for |
| 460 | * the next call to NETDEV_UNREGISTER. |
| 461 | * |
| 462 | * If any packets are in flight down the CAIF Stack, |
| 463 | * cfcnfg_del_phy_layer will return nonzero. |
| 464 | * If no packets are in flight, the CAIF Stack associated |
| 465 | * with the net-device un-registering is freed. |
| 466 | */ |
| 467 | |
| 468 | if (caifd_refcnt_read(caifd) != 0 || |
| 469 | cfcnfg_del_phy_layer(cfg, &caifd->layer) != 0) { |
| 470 | |
| 471 | pr_info("Wait for device inuse\n"); |
| 472 | /* Enrole device if CAIF Stack is still in use */ |
| 473 | list_add_rcu(&caifd->list, &caifdevs->list); |
| 474 | mutex_unlock(&caifdevs->lock); |
| 475 | break; |
| 476 | } |
| 477 | |
| 478 | synchronize_rcu(); |
| 479 | dev_put(caifd->netdev); |
| 480 | free_percpu(caifd->pcpu_refcnt); |
| 481 | kfree(caifd); |
| 482 | |
| 483 | mutex_unlock(&caifdevs->lock); |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 484 | break; |
| 485 | } |
| 486 | return 0; |
| 487 | } |
| 488 | |
| 489 | static struct notifier_block caif_device_notifier = { |
| 490 | .notifier_call = caif_device_notify, |
| 491 | .priority = 0, |
| 492 | }; |
| 493 | |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 494 | /* Per-namespace Caif devices handling */ |
| 495 | static int caif_init_net(struct net *net) |
| 496 | { |
| 497 | struct caif_net *caifn = net_generic(net, caif_net_id); |
| 498 | INIT_LIST_HEAD(&caifn->caifdevs.list); |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 499 | mutex_init(&caifn->caifdevs.lock); |
sjur.brandeland@stericsson.com | bee925d | 2011-05-13 02:44:05 +0000 | [diff] [blame] | 500 | |
| 501 | caifn->cfg = cfcnfg_create(); |
Roar Førde | f84ea77 | 2011-12-06 12:15:44 +0000 | [diff] [blame] | 502 | if (!caifn->cfg) |
sjur.brandeland@stericsson.com | bee925d | 2011-05-13 02:44:05 +0000 | [diff] [blame] | 503 | return -ENOMEM; |
sjur.brandeland@stericsson.com | bee925d | 2011-05-13 02:44:05 +0000 | [diff] [blame] | 504 | |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 505 | return 0; |
| 506 | } |
| 507 | |
| 508 | static void caif_exit_net(struct net *net) |
| 509 | { |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 510 | struct caif_device_entry *caifd, *tmp; |
| 511 | struct caif_device_entry_list *caifdevs = |
| 512 | caif_device_list(net); |
sjur.brandeland@stericsson.com | 7c18d22 | 2011-11-30 09:22:47 +0000 | [diff] [blame] | 513 | struct cfcnfg *cfg = get_cfcnfg(net); |
| 514 | |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 515 | rtnl_lock(); |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 516 | mutex_lock(&caifdevs->lock); |
| 517 | |
| 518 | list_for_each_entry_safe(caifd, tmp, &caifdevs->list, list) { |
| 519 | int i = 0; |
| 520 | list_del_rcu(&caifd->list); |
| 521 | cfcnfg_set_phy_state(cfg, &caifd->layer, false); |
| 522 | |
| 523 | while (i < 10 && |
| 524 | (caifd_refcnt_read(caifd) != 0 || |
| 525 | cfcnfg_del_phy_layer(cfg, &caifd->layer) != 0)) { |
| 526 | |
| 527 | pr_info("Wait for device inuse\n"); |
| 528 | msleep(250); |
| 529 | i++; |
| 530 | } |
| 531 | synchronize_rcu(); |
| 532 | dev_put(caifd->netdev); |
| 533 | free_percpu(caifd->pcpu_refcnt); |
| 534 | kfree(caifd); |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 535 | } |
sjur.brandeland@stericsson.com | bee925d | 2011-05-13 02:44:05 +0000 | [diff] [blame] | 536 | cfcnfg_remove(cfg); |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 537 | |
| 538 | mutex_unlock(&caifdevs->lock); |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 539 | rtnl_unlock(); |
| 540 | } |
| 541 | |
| 542 | static struct pernet_operations caif_net_ops = { |
| 543 | .init = caif_init_net, |
| 544 | .exit = caif_exit_net, |
| 545 | .id = &caif_net_id, |
| 546 | .size = sizeof(struct caif_net), |
| 547 | }; |
| 548 | |
| 549 | /* Initialize Caif devices list */ |
| 550 | static int __init caif_device_init(void) |
| 551 | { |
| 552 | int result; |
sjur.brandeland@stericsson.com | bd30ce4 | 2011-05-13 02:44:00 +0000 | [diff] [blame] | 553 | |
Eric W. Biederman | 8a8ee9a | 2012-01-26 14:04:53 +0000 | [diff] [blame] | 554 | result = register_pernet_subsys(&caif_net_ops); |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 555 | |
sjur.brandeland@stericsson.com | bee925d | 2011-05-13 02:44:05 +0000 | [diff] [blame] | 556 | if (result) |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 557 | return result; |
sjur.brandeland@stericsson.com | bee925d | 2011-05-13 02:44:05 +0000 | [diff] [blame] | 558 | |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 559 | register_netdevice_notifier(&caif_device_notifier); |
sjur.brandeland@stericsson.com | bee925d | 2011-05-13 02:44:05 +0000 | [diff] [blame] | 560 | dev_add_pack(&caif_packet_type); |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 561 | |
| 562 | return result; |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 563 | } |
| 564 | |
| 565 | static void __exit caif_device_exit(void) |
| 566 | { |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 567 | unregister_netdevice_notifier(&caif_device_notifier); |
sjur.brandeland@stericsson.com | bee925d | 2011-05-13 02:44:05 +0000 | [diff] [blame] | 568 | dev_remove_pack(&caif_packet_type); |
Sjur Brændeland | 96f80d1 | 2012-07-15 10:10:14 +0000 | [diff] [blame] | 569 | unregister_pernet_subsys(&caif_net_ops); |
Sjur Braendeland | c72dfae | 2010-03-30 13:56:25 +0000 | [diff] [blame] | 570 | } |
| 571 | |
| 572 | module_init(caif_device_init); |
| 573 | module_exit(caif_device_exit); |