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