]>
Commit | Line | Data |
---|---|---|
2874c5fd | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
f89efd52 MP |
2 | /* |
3 | * rionet - Ethernet driver over RapidIO messaging services | |
4 | * | |
5 | * Copyright 2005 MontaVista Software, Inc. | |
6 | * Matt Porter <mporter@kernel.crashing.org> | |
f89efd52 MP |
7 | */ |
8 | ||
9 | #include <linux/module.h> | |
10 | #include <linux/kernel.h> | |
11 | #include <linux/dma-mapping.h> | |
12 | #include <linux/delay.h> | |
13 | #include <linux/rio.h> | |
14 | #include <linux/rio_drv.h> | |
5a0e3ad6 | 15 | #include <linux/slab.h> |
f89efd52 MP |
16 | #include <linux/rio_ids.h> |
17 | ||
18 | #include <linux/netdevice.h> | |
19 | #include <linux/etherdevice.h> | |
20 | #include <linux/skbuff.h> | |
21 | #include <linux/crc32.h> | |
22 | #include <linux/ethtool.h> | |
f41e2472 | 23 | #include <linux/reboot.h> |
f89efd52 MP |
24 | |
25 | #define DRV_NAME "rionet" | |
2fb717ec | 26 | #define DRV_VERSION "0.3" |
f89efd52 MP |
27 | #define DRV_AUTHOR "Matt Porter <mporter@kernel.crashing.org>" |
28 | #define DRV_DESC "Ethernet over RapidIO" | |
29 | ||
30 | MODULE_AUTHOR(DRV_AUTHOR); | |
31 | MODULE_DESCRIPTION(DRV_DESC); | |
32 | MODULE_LICENSE("GPL"); | |
33 | ||
34 | #define RIONET_DEFAULT_MSGLEVEL \ | |
35 | (NETIF_MSG_DRV | \ | |
36 | NETIF_MSG_LINK | \ | |
37 | NETIF_MSG_RX_ERR | \ | |
38 | NETIF_MSG_TX_ERR) | |
39 | ||
40 | #define RIONET_DOORBELL_JOIN 0x1000 | |
41 | #define RIONET_DOORBELL_LEAVE 0x1001 | |
42 | ||
43 | #define RIONET_MAILBOX 0 | |
44 | ||
45 | #define RIONET_TX_RING_SIZE CONFIG_RIONET_TX_SIZE | |
46 | #define RIONET_RX_RING_SIZE CONFIG_RIONET_RX_SIZE | |
2fb717ec | 47 | #define RIONET_MAX_NETS 8 |
92444bb3 AJ |
48 | #define RIONET_MSG_SIZE RIO_MAX_MSG_SIZE |
49 | #define RIONET_MAX_MTU (RIONET_MSG_SIZE - ETH_HLEN) | |
f89efd52 MP |
50 | |
51 | struct rionet_private { | |
52 | struct rio_mport *mport; | |
53 | struct sk_buff *rx_skb[RIONET_RX_RING_SIZE]; | |
54 | struct sk_buff *tx_skb[RIONET_TX_RING_SIZE]; | |
f89efd52 MP |
55 | int rx_slot; |
56 | int tx_slot; | |
57 | int tx_cnt; | |
58 | int ack_slot; | |
59 | spinlock_t lock; | |
60 | spinlock_t tx_lock; | |
61 | u32 msg_enable; | |
34ed2ebb | 62 | bool open; |
f89efd52 MP |
63 | }; |
64 | ||
65 | struct rionet_peer { | |
66 | struct list_head node; | |
67 | struct rio_dev *rdev; | |
68 | struct resource *res; | |
69 | }; | |
70 | ||
2fb717ec AB |
71 | struct rionet_net { |
72 | struct net_device *ndev; | |
73 | struct list_head peers; | |
34ed2ebb | 74 | spinlock_t lock; /* net info access lock */ |
2fb717ec AB |
75 | struct rio_dev **active; |
76 | int nact; /* number of active peers */ | |
77 | }; | |
f89efd52 | 78 | |
2fb717ec | 79 | static struct rionet_net nets[RIONET_MAX_NETS]; |
f89efd52 | 80 | |
284fb68d AB |
81 | #define is_rionet_capable(src_ops, dst_ops) \ |
82 | ((src_ops & RIO_SRC_OPS_DATA_MSG) && \ | |
83 | (dst_ops & RIO_DST_OPS_DATA_MSG) && \ | |
f89efd52 MP |
84 | (src_ops & RIO_SRC_OPS_DOORBELL) && \ |
85 | (dst_ops & RIO_DST_OPS_DOORBELL)) | |
86 | #define dev_rionet_capable(dev) \ | |
284fb68d | 87 | is_rionet_capable(dev->src_ops, dev->dst_ops) |
f89efd52 | 88 | |
e0c87bd9 AB |
89 | #define RIONET_MAC_MATCH(x) (!memcmp((x), "\00\01\00\01", 4)) |
90 | #define RIONET_GET_DESTID(x) ((*((u8 *)x + 4) << 8) | *((u8 *)x + 5)) | |
f89efd52 | 91 | |
f89efd52 MP |
92 | static int rionet_rx_clean(struct net_device *ndev) |
93 | { | |
94 | int i; | |
95 | int error = 0; | |
4cf1653a | 96 | struct rionet_private *rnet = netdev_priv(ndev); |
f89efd52 MP |
97 | void *data; |
98 | ||
99 | i = rnet->rx_slot; | |
100 | ||
101 | do { | |
102 | if (!rnet->rx_skb[i]) | |
103 | continue; | |
104 | ||
105 | if (!(data = rio_get_inb_message(rnet->mport, RIONET_MAILBOX))) | |
106 | break; | |
107 | ||
108 | rnet->rx_skb[i]->data = data; | |
109 | skb_put(rnet->rx_skb[i], RIO_MAX_MSG_SIZE); | |
f89efd52 MP |
110 | rnet->rx_skb[i]->protocol = |
111 | eth_type_trans(rnet->rx_skb[i], ndev); | |
112 | error = netif_rx(rnet->rx_skb[i]); | |
113 | ||
114 | if (error == NET_RX_DROP) { | |
09f75cd7 | 115 | ndev->stats.rx_dropped++; |
f89efd52 | 116 | } else { |
09f75cd7 JG |
117 | ndev->stats.rx_packets++; |
118 | ndev->stats.rx_bytes += RIO_MAX_MSG_SIZE; | |
f89efd52 MP |
119 | } |
120 | ||
121 | } while ((i = (i + 1) % RIONET_RX_RING_SIZE) != rnet->rx_slot); | |
122 | ||
123 | return i; | |
124 | } | |
125 | ||
126 | static void rionet_rx_fill(struct net_device *ndev, int end) | |
127 | { | |
128 | int i; | |
4cf1653a | 129 | struct rionet_private *rnet = netdev_priv(ndev); |
f89efd52 MP |
130 | |
131 | i = rnet->rx_slot; | |
132 | do { | |
133 | rnet->rx_skb[i] = dev_alloc_skb(RIO_MAX_MSG_SIZE); | |
134 | ||
135 | if (!rnet->rx_skb[i]) | |
136 | break; | |
137 | ||
138 | rio_add_inb_buffer(rnet->mport, RIONET_MAILBOX, | |
139 | rnet->rx_skb[i]->data); | |
140 | } while ((i = (i + 1) % RIONET_RX_RING_SIZE) != end); | |
141 | ||
142 | rnet->rx_slot = i; | |
143 | } | |
144 | ||
145 | static int rionet_queue_tx_msg(struct sk_buff *skb, struct net_device *ndev, | |
146 | struct rio_dev *rdev) | |
147 | { | |
4cf1653a | 148 | struct rionet_private *rnet = netdev_priv(ndev); |
f89efd52 MP |
149 | |
150 | rio_add_outb_message(rnet->mport, rdev, 0, skb->data, skb->len); | |
151 | rnet->tx_skb[rnet->tx_slot] = skb; | |
152 | ||
09f75cd7 JG |
153 | ndev->stats.tx_packets++; |
154 | ndev->stats.tx_bytes += skb->len; | |
f89efd52 MP |
155 | |
156 | if (++rnet->tx_cnt == RIONET_TX_RING_SIZE) | |
157 | netif_stop_queue(ndev); | |
158 | ||
159 | ++rnet->tx_slot; | |
160 | rnet->tx_slot &= (RIONET_TX_RING_SIZE - 1); | |
161 | ||
162 | if (netif_msg_tx_queued(rnet)) | |
8df8a475 DM |
163 | printk(KERN_INFO "%s: queued skb len %8.8x\n", DRV_NAME, |
164 | skb->len); | |
f89efd52 MP |
165 | |
166 | return 0; | |
167 | } | |
168 | ||
169 | static int rionet_start_xmit(struct sk_buff *skb, struct net_device *ndev) | |
170 | { | |
171 | int i; | |
4cf1653a | 172 | struct rionet_private *rnet = netdev_priv(ndev); |
f89efd52 MP |
173 | struct ethhdr *eth = (struct ethhdr *)skb->data; |
174 | u16 destid; | |
175 | unsigned long flags; | |
7c4a6106 | 176 | int add_num = 1; |
f89efd52 | 177 | |
a6086a89 | 178 | spin_lock_irqsave(&rnet->tx_lock, flags); |
f89efd52 | 179 | |
7c4a6106 | 180 | if (is_multicast_ether_addr(eth->h_dest)) |
2fb717ec | 181 | add_num = nets[rnet->mport->id].nact; |
7c4a6106 AB |
182 | |
183 | if ((rnet->tx_cnt + add_num) > RIONET_TX_RING_SIZE) { | |
f89efd52 MP |
184 | netif_stop_queue(ndev); |
185 | spin_unlock_irqrestore(&rnet->tx_lock, flags); | |
186 | printk(KERN_ERR "%s: BUG! Tx Ring full when queue awake!\n", | |
187 | ndev->name); | |
188 | return NETDEV_TX_BUSY; | |
189 | } | |
190 | ||
abfc89c7 | 191 | if (is_multicast_ether_addr(eth->h_dest)) { |
7c4a6106 | 192 | int count = 0; |
2fb717ec | 193 | |
e0423236 ZW |
194 | for (i = 0; i < RIO_MAX_ROUTE_ENTRIES(rnet->mport->sys_size); |
195 | i++) | |
2fb717ec | 196 | if (nets[rnet->mport->id].active[i]) { |
f89efd52 | 197 | rionet_queue_tx_msg(skb, ndev, |
2fb717ec | 198 | nets[rnet->mport->id].active[i]); |
7c4a6106 | 199 | if (count) |
63354797 | 200 | refcount_inc(&skb->users); |
7c4a6106 AB |
201 | count++; |
202 | } | |
f89efd52 MP |
203 | } else if (RIONET_MAC_MATCH(eth->h_dest)) { |
204 | destid = RIONET_GET_DESTID(eth->h_dest); | |
2fb717ec AB |
205 | if (nets[rnet->mport->id].active[destid]) |
206 | rionet_queue_tx_msg(skb, ndev, | |
207 | nets[rnet->mport->id].active[destid]); | |
e6161d64 AB |
208 | else { |
209 | /* | |
210 | * If the target device was removed from the list of | |
211 | * active peers but we still have TX packets targeting | |
212 | * it just report sending a packet to the target | |
213 | * (without actual packet transfer). | |
214 | */ | |
e6161d64 AB |
215 | ndev->stats.tx_packets++; |
216 | ndev->stats.tx_bytes += skb->len; | |
cfc43519 | 217 | dev_kfree_skb_any(skb); |
e6161d64 | 218 | } |
f89efd52 MP |
219 | } |
220 | ||
221 | spin_unlock_irqrestore(&rnet->tx_lock, flags); | |
222 | ||
6ed10654 | 223 | return NETDEV_TX_OK; |
f89efd52 MP |
224 | } |
225 | ||
226 | static void rionet_dbell_event(struct rio_mport *mport, void *dev_id, u16 sid, u16 tid, | |
227 | u16 info) | |
228 | { | |
229 | struct net_device *ndev = dev_id; | |
4cf1653a | 230 | struct rionet_private *rnet = netdev_priv(ndev); |
f89efd52 | 231 | struct rionet_peer *peer; |
34ed2ebb | 232 | unsigned char netid = rnet->mport->id; |
f89efd52 MP |
233 | |
234 | if (netif_msg_intr(rnet)) | |
235 | printk(KERN_INFO "%s: doorbell sid %4.4x tid %4.4x info %4.4x", | |
236 | DRV_NAME, sid, tid, info); | |
237 | if (info == RIONET_DOORBELL_JOIN) { | |
34ed2ebb AB |
238 | if (!nets[netid].active[sid]) { |
239 | spin_lock(&nets[netid].lock); | |
240 | list_for_each_entry(peer, &nets[netid].peers, node) { | |
7c4a6106 | 241 | if (peer->rdev->destid == sid) { |
34ed2ebb AB |
242 | nets[netid].active[sid] = peer->rdev; |
243 | nets[netid].nact++; | |
7c4a6106 | 244 | } |
f89efd52 | 245 | } |
34ed2ebb AB |
246 | spin_unlock(&nets[netid].lock); |
247 | ||
f89efd52 MP |
248 | rio_mport_send_doorbell(mport, sid, |
249 | RIONET_DOORBELL_JOIN); | |
250 | } | |
251 | } else if (info == RIONET_DOORBELL_LEAVE) { | |
34ed2ebb AB |
252 | spin_lock(&nets[netid].lock); |
253 | if (nets[netid].active[sid]) { | |
254 | nets[netid].active[sid] = NULL; | |
255 | nets[netid].nact--; | |
256 | } | |
257 | spin_unlock(&nets[netid].lock); | |
f89efd52 MP |
258 | } else { |
259 | if (netif_msg_intr(rnet)) | |
260 | printk(KERN_WARNING "%s: unhandled doorbell\n", | |
261 | DRV_NAME); | |
262 | } | |
263 | } | |
264 | ||
265 | static void rionet_inb_msg_event(struct rio_mport *mport, void *dev_id, int mbox, int slot) | |
266 | { | |
267 | int n; | |
268 | struct net_device *ndev = dev_id; | |
4cf1653a | 269 | struct rionet_private *rnet = netdev_priv(ndev); |
f89efd52 MP |
270 | |
271 | if (netif_msg_intr(rnet)) | |
272 | printk(KERN_INFO "%s: inbound message event, mbox %d slot %d\n", | |
273 | DRV_NAME, mbox, slot); | |
274 | ||
275 | spin_lock(&rnet->lock); | |
276 | if ((n = rionet_rx_clean(ndev)) != rnet->rx_slot) | |
277 | rionet_rx_fill(ndev, n); | |
278 | spin_unlock(&rnet->lock); | |
279 | } | |
280 | ||
281 | static void rionet_outb_msg_event(struct rio_mport *mport, void *dev_id, int mbox, int slot) | |
282 | { | |
283 | struct net_device *ndev = dev_id; | |
4cf1653a | 284 | struct rionet_private *rnet = netdev_priv(ndev); |
f89efd52 | 285 | |
36915976 | 286 | spin_lock(&rnet->tx_lock); |
f89efd52 MP |
287 | |
288 | if (netif_msg_intr(rnet)) | |
289 | printk(KERN_INFO | |
290 | "%s: outbound message event, mbox %d slot %d\n", | |
291 | DRV_NAME, mbox, slot); | |
292 | ||
293 | while (rnet->tx_cnt && (rnet->ack_slot != slot)) { | |
294 | /* dma unmap single */ | |
295 | dev_kfree_skb_irq(rnet->tx_skb[rnet->ack_slot]); | |
296 | rnet->tx_skb[rnet->ack_slot] = NULL; | |
297 | ++rnet->ack_slot; | |
298 | rnet->ack_slot &= (RIONET_TX_RING_SIZE - 1); | |
299 | rnet->tx_cnt--; | |
300 | } | |
301 | ||
302 | if (rnet->tx_cnt < RIONET_TX_RING_SIZE) | |
303 | netif_wake_queue(ndev); | |
304 | ||
36915976 | 305 | spin_unlock(&rnet->tx_lock); |
f89efd52 MP |
306 | } |
307 | ||
308 | static int rionet_open(struct net_device *ndev) | |
309 | { | |
310 | int i, rc = 0; | |
34ed2ebb | 311 | struct rionet_peer *peer; |
4cf1653a | 312 | struct rionet_private *rnet = netdev_priv(ndev); |
34ed2ebb AB |
313 | unsigned char netid = rnet->mport->id; |
314 | unsigned long flags; | |
f89efd52 MP |
315 | |
316 | if (netif_msg_ifup(rnet)) | |
317 | printk(KERN_INFO "%s: open\n", DRV_NAME); | |
318 | ||
319 | if ((rc = rio_request_inb_dbell(rnet->mport, | |
320 | (void *)ndev, | |
321 | RIONET_DOORBELL_JOIN, | |
322 | RIONET_DOORBELL_LEAVE, | |
323 | rionet_dbell_event)) < 0) | |
324 | goto out; | |
325 | ||
326 | if ((rc = rio_request_inb_mbox(rnet->mport, | |
327 | (void *)ndev, | |
328 | RIONET_MAILBOX, | |
329 | RIONET_RX_RING_SIZE, | |
330 | rionet_inb_msg_event)) < 0) | |
331 | goto out; | |
332 | ||
333 | if ((rc = rio_request_outb_mbox(rnet->mport, | |
334 | (void *)ndev, | |
335 | RIONET_MAILBOX, | |
336 | RIONET_TX_RING_SIZE, | |
337 | rionet_outb_msg_event)) < 0) | |
338 | goto out; | |
339 | ||
340 | /* Initialize inbound message ring */ | |
341 | for (i = 0; i < RIONET_RX_RING_SIZE; i++) | |
342 | rnet->rx_skb[i] = NULL; | |
343 | rnet->rx_slot = 0; | |
344 | rionet_rx_fill(ndev, 0); | |
345 | ||
346 | rnet->tx_slot = 0; | |
347 | rnet->tx_cnt = 0; | |
348 | rnet->ack_slot = 0; | |
349 | ||
350 | netif_carrier_on(ndev); | |
351 | netif_start_queue(ndev); | |
352 | ||
34ed2ebb AB |
353 | spin_lock_irqsave(&nets[netid].lock, flags); |
354 | list_for_each_entry(peer, &nets[netid].peers, node) { | |
284fb68d AB |
355 | /* Send a join message */ |
356 | rio_send_doorbell(peer->rdev, RIONET_DOORBELL_JOIN); | |
f89efd52 | 357 | } |
34ed2ebb AB |
358 | spin_unlock_irqrestore(&nets[netid].lock, flags); |
359 | rnet->open = true; | |
f89efd52 MP |
360 | |
361 | out: | |
362 | return rc; | |
363 | } | |
364 | ||
365 | static int rionet_close(struct net_device *ndev) | |
366 | { | |
4cf1653a | 367 | struct rionet_private *rnet = netdev_priv(ndev); |
34ed2ebb AB |
368 | struct rionet_peer *peer; |
369 | unsigned char netid = rnet->mport->id; | |
370 | unsigned long flags; | |
f89efd52 MP |
371 | int i; |
372 | ||
373 | if (netif_msg_ifup(rnet)) | |
2fb717ec | 374 | printk(KERN_INFO "%s: close %s\n", DRV_NAME, ndev->name); |
f89efd52 MP |
375 | |
376 | netif_stop_queue(ndev); | |
377 | netif_carrier_off(ndev); | |
34ed2ebb | 378 | rnet->open = false; |
f89efd52 MP |
379 | |
380 | for (i = 0; i < RIONET_RX_RING_SIZE; i++) | |
aaff1e19 | 381 | kfree_skb(rnet->rx_skb[i]); |
f89efd52 | 382 | |
34ed2ebb AB |
383 | spin_lock_irqsave(&nets[netid].lock, flags); |
384 | list_for_each_entry(peer, &nets[netid].peers, node) { | |
385 | if (nets[netid].active[peer->rdev->destid]) { | |
f89efd52 | 386 | rio_send_doorbell(peer->rdev, RIONET_DOORBELL_LEAVE); |
34ed2ebb | 387 | nets[netid].active[peer->rdev->destid] = NULL; |
f89efd52 | 388 | } |
34ed2ebb AB |
389 | if (peer->res) |
390 | rio_release_outb_dbell(peer->rdev, peer->res); | |
f89efd52 | 391 | } |
34ed2ebb | 392 | spin_unlock_irqrestore(&nets[netid].lock, flags); |
f89efd52 MP |
393 | |
394 | rio_release_inb_dbell(rnet->mport, RIONET_DOORBELL_JOIN, | |
395 | RIONET_DOORBELL_LEAVE); | |
396 | rio_release_inb_mbox(rnet->mport, RIONET_MAILBOX); | |
397 | rio_release_outb_mbox(rnet->mport, RIONET_MAILBOX); | |
398 | ||
399 | return 0; | |
400 | } | |
401 | ||
71db87ba | 402 | static void rionet_remove_dev(struct device *dev, struct subsys_interface *sif) |
f89efd52 | 403 | { |
e6161d64 | 404 | struct rio_dev *rdev = to_rio_dev(dev); |
2fb717ec | 405 | unsigned char netid = rdev->net->hport->id; |
34ed2ebb AB |
406 | struct rionet_peer *peer; |
407 | int state, found = 0; | |
408 | unsigned long flags; | |
f89efd52 | 409 | |
34ed2ebb AB |
410 | if (!dev_rionet_capable(rdev)) |
411 | return; | |
412 | ||
413 | spin_lock_irqsave(&nets[netid].lock, flags); | |
414 | list_for_each_entry(peer, &nets[netid].peers, node) { | |
415 | if (peer->rdev == rdev) { | |
416 | list_del(&peer->node); | |
417 | if (nets[netid].active[rdev->destid]) { | |
418 | state = atomic_read(&rdev->state); | |
419 | if (state != RIO_DEVICE_GONE && | |
420 | state != RIO_DEVICE_INITIALIZING) { | |
421 | rio_send_doorbell(rdev, | |
422 | RIONET_DOORBELL_LEAVE); | |
e6161d64 | 423 | } |
34ed2ebb AB |
424 | nets[netid].active[rdev->destid] = NULL; |
425 | nets[netid].nact--; | |
e6161d64 | 426 | } |
34ed2ebb AB |
427 | found = 1; |
428 | break; | |
e6161d64 | 429 | } |
f89efd52 | 430 | } |
34ed2ebb AB |
431 | spin_unlock_irqrestore(&nets[netid].lock, flags); |
432 | ||
433 | if (found) { | |
434 | if (peer->res) | |
435 | rio_release_outb_dbell(rdev, peer->res); | |
436 | kfree(peer); | |
437 | } | |
f89efd52 MP |
438 | } |
439 | ||
440 | static void rionet_get_drvinfo(struct net_device *ndev, | |
441 | struct ethtool_drvinfo *info) | |
442 | { | |
4cf1653a | 443 | struct rionet_private *rnet = netdev_priv(ndev); |
f89efd52 | 444 | |
7826d43f JP |
445 | strlcpy(info->driver, DRV_NAME, sizeof(info->driver)); |
446 | strlcpy(info->version, DRV_VERSION, sizeof(info->version)); | |
447 | strlcpy(info->fw_version, "n/a", sizeof(info->fw_version)); | |
448 | strlcpy(info->bus_info, rnet->mport->name, sizeof(info->bus_info)); | |
f89efd52 MP |
449 | } |
450 | ||
451 | static u32 rionet_get_msglevel(struct net_device *ndev) | |
452 | { | |
4cf1653a | 453 | struct rionet_private *rnet = netdev_priv(ndev); |
f89efd52 MP |
454 | |
455 | return rnet->msg_enable; | |
456 | } | |
457 | ||
458 | static void rionet_set_msglevel(struct net_device *ndev, u32 value) | |
459 | { | |
4cf1653a | 460 | struct rionet_private *rnet = netdev_priv(ndev); |
f89efd52 MP |
461 | |
462 | rnet->msg_enable = value; | |
463 | } | |
464 | ||
7282d491 | 465 | static const struct ethtool_ops rionet_ethtool_ops = { |
f89efd52 MP |
466 | .get_drvinfo = rionet_get_drvinfo, |
467 | .get_msglevel = rionet_get_msglevel, | |
468 | .set_msglevel = rionet_set_msglevel, | |
469 | .get_link = ethtool_op_get_link, | |
470 | }; | |
471 | ||
a33a2bb3 AB |
472 | static const struct net_device_ops rionet_netdev_ops = { |
473 | .ndo_open = rionet_open, | |
474 | .ndo_stop = rionet_close, | |
475 | .ndo_start_xmit = rionet_start_xmit, | |
a33a2bb3 AB |
476 | .ndo_validate_addr = eth_validate_addr, |
477 | .ndo_set_mac_address = eth_mac_addr, | |
478 | }; | |
479 | ||
55caa924 | 480 | static int rionet_setup_netdev(struct rio_mport *mport, struct net_device *ndev) |
f89efd52 MP |
481 | { |
482 | int rc = 0; | |
f89efd52 MP |
483 | struct rionet_private *rnet; |
484 | u16 device_id; | |
acc65632 AM |
485 | const size_t rionet_active_bytes = sizeof(void *) * |
486 | RIO_MAX_ROUTE_ENTRIES(mport->sys_size); | |
f89efd52 | 487 | |
2fb717ec AB |
488 | nets[mport->id].active = (struct rio_dev **)__get_free_pages(GFP_KERNEL, |
489 | get_order(rionet_active_bytes)); | |
490 | if (!nets[mport->id].active) { | |
e0423236 ZW |
491 | rc = -ENOMEM; |
492 | goto out; | |
493 | } | |
2fb717ec | 494 | memset((void *)nets[mport->id].active, 0, rionet_active_bytes); |
e0423236 | 495 | |
f89efd52 | 496 | /* Set up private area */ |
4cf1653a | 497 | rnet = netdev_priv(ndev); |
f89efd52 | 498 | rnet->mport = mport; |
34ed2ebb | 499 | rnet->open = false; |
f89efd52 MP |
500 | |
501 | /* Set the default MAC address */ | |
502 | device_id = rio_local_get_device_id(mport); | |
503 | ndev->dev_addr[0] = 0x00; | |
504 | ndev->dev_addr[1] = 0x01; | |
505 | ndev->dev_addr[2] = 0x00; | |
506 | ndev->dev_addr[3] = 0x01; | |
507 | ndev->dev_addr[4] = device_id >> 8; | |
508 | ndev->dev_addr[5] = device_id & 0xff; | |
509 | ||
a33a2bb3 | 510 | ndev->netdev_ops = &rionet_netdev_ops; |
92444bb3 | 511 | ndev->mtu = RIONET_MAX_MTU; |
b3e3893e JW |
512 | /* MTU range: 68 - 4082 */ |
513 | ndev->min_mtu = ETH_MIN_MTU; | |
514 | ndev->max_mtu = RIONET_MAX_MTU; | |
f89efd52 | 515 | ndev->features = NETIF_F_LLTX; |
2aaf308b | 516 | SET_NETDEV_DEV(ndev, &mport->dev); |
7ad24ea4 | 517 | ndev->ethtool_ops = &rionet_ethtool_ops; |
f89efd52 | 518 | |
f89efd52 MP |
519 | spin_lock_init(&rnet->lock); |
520 | spin_lock_init(&rnet->tx_lock); | |
521 | ||
522 | rnet->msg_enable = RIONET_DEFAULT_MSGLEVEL; | |
523 | ||
524 | rc = register_netdev(ndev); | |
34ed2ebb AB |
525 | if (rc != 0) { |
526 | free_pages((unsigned long)nets[mport->id].active, | |
527 | get_order(rionet_active_bytes)); | |
f89efd52 | 528 | goto out; |
34ed2ebb | 529 | } |
f89efd52 | 530 | |
2fb717ec | 531 | printk(KERN_INFO "%s: %s %s Version %s, MAC %pM, %s\n", |
f89efd52 MP |
532 | ndev->name, |
533 | DRV_NAME, | |
534 | DRV_DESC, | |
535 | DRV_VERSION, | |
2fb717ec AB |
536 | ndev->dev_addr, |
537 | mport->name); | |
f89efd52 MP |
538 | |
539 | out: | |
540 | return rc; | |
541 | } | |
542 | ||
e6161d64 | 543 | static int rionet_add_dev(struct device *dev, struct subsys_interface *sif) |
f89efd52 MP |
544 | { |
545 | int rc = -ENODEV; | |
284fb68d | 546 | u32 lsrc_ops, ldst_ops; |
f89efd52 | 547 | struct rionet_peer *peer; |
55caa924 | 548 | struct net_device *ndev = NULL; |
e6161d64 | 549 | struct rio_dev *rdev = to_rio_dev(dev); |
2fb717ec | 550 | unsigned char netid = rdev->net->hport->id; |
f89efd52 | 551 | |
2fb717ec AB |
552 | if (netid >= RIONET_MAX_NETS) |
553 | return rc; | |
f89efd52 MP |
554 | |
555 | /* | |
e6161d64 AB |
556 | * If first time through this net, make sure local device is rionet |
557 | * capable and setup netdev (this step will be skipped in later probes | |
558 | * on the same net). | |
f89efd52 | 559 | */ |
34ed2ebb | 560 | if (!nets[netid].ndev) { |
f89efd52 MP |
561 | rio_local_read_config_32(rdev->net->hport, RIO_SRC_OPS_CAR, |
562 | &lsrc_ops); | |
563 | rio_local_read_config_32(rdev->net->hport, RIO_DST_OPS_CAR, | |
564 | &ldst_ops); | |
284fb68d | 565 | if (!is_rionet_capable(lsrc_ops, ldst_ops)) { |
f89efd52 | 566 | printk(KERN_ERR |
2fb717ec AB |
567 | "%s: local device %s is not network capable\n", |
568 | DRV_NAME, rdev->net->hport->name); | |
f89efd52 MP |
569 | goto out; |
570 | } | |
571 | ||
2fb717ec AB |
572 | /* Allocate our net_device structure */ |
573 | ndev = alloc_etherdev(sizeof(struct rionet_private)); | |
574 | if (ndev == NULL) { | |
575 | rc = -ENOMEM; | |
576 | goto out; | |
577 | } | |
34ed2ebb | 578 | |
55caa924 | 579 | rc = rionet_setup_netdev(rdev->net->hport, ndev); |
e6161d64 AB |
580 | if (rc) { |
581 | printk(KERN_ERR "%s: failed to setup netdev (rc=%d)\n", | |
582 | DRV_NAME, rc); | |
34ed2ebb | 583 | free_netdev(ndev); |
e6161d64 AB |
584 | goto out; |
585 | } | |
586 | ||
2fb717ec | 587 | INIT_LIST_HEAD(&nets[netid].peers); |
34ed2ebb | 588 | spin_lock_init(&nets[netid].lock); |
2fb717ec | 589 | nets[netid].nact = 0; |
34ed2ebb AB |
590 | nets[netid].ndev = ndev; |
591 | } | |
f89efd52 MP |
592 | |
593 | /* | |
594 | * If the remote device has mailbox/doorbell capabilities, | |
595 | * add it to the peer list. | |
596 | */ | |
597 | if (dev_rionet_capable(rdev)) { | |
34ed2ebb AB |
598 | struct rionet_private *rnet; |
599 | unsigned long flags; | |
600 | ||
601 | rnet = netdev_priv(nets[netid].ndev); | |
602 | ||
603 | peer = kzalloc(sizeof(*peer), GFP_KERNEL); | |
604 | if (!peer) { | |
f89efd52 MP |
605 | rc = -ENOMEM; |
606 | goto out; | |
607 | } | |
608 | peer->rdev = rdev; | |
34ed2ebb AB |
609 | peer->res = rio_request_outb_dbell(peer->rdev, |
610 | RIONET_DOORBELL_JOIN, | |
611 | RIONET_DOORBELL_LEAVE); | |
612 | if (!peer->res) { | |
613 | pr_err("%s: error requesting doorbells\n", DRV_NAME); | |
614 | kfree(peer); | |
615 | rc = -ENOMEM; | |
616 | goto out; | |
617 | } | |
618 | ||
619 | spin_lock_irqsave(&nets[netid].lock, flags); | |
2fb717ec | 620 | list_add_tail(&peer->node, &nets[netid].peers); |
34ed2ebb AB |
621 | spin_unlock_irqrestore(&nets[netid].lock, flags); |
622 | pr_debug("%s: %s add peer %s\n", | |
623 | DRV_NAME, __func__, rio_name(rdev)); | |
624 | ||
625 | /* If netdev is already opened, send join request to new peer */ | |
626 | if (rnet->open) | |
627 | rio_send_doorbell(peer->rdev, RIONET_DOORBELL_JOIN); | |
f89efd52 MP |
628 | } |
629 | ||
e6161d64 AB |
630 | return 0; |
631 | out: | |
f89efd52 MP |
632 | return rc; |
633 | } | |
634 | ||
f41e2472 AB |
635 | static int rionet_shutdown(struct notifier_block *nb, unsigned long code, |
636 | void *unused) | |
637 | { | |
34ed2ebb AB |
638 | struct rionet_peer *peer; |
639 | unsigned long flags; | |
f41e2472 AB |
640 | int i; |
641 | ||
642 | pr_debug("%s: %s\n", DRV_NAME, __func__); | |
643 | ||
644 | for (i = 0; i < RIONET_MAX_NETS; i++) { | |
645 | if (!nets[i].ndev) | |
646 | continue; | |
647 | ||
34ed2ebb AB |
648 | spin_lock_irqsave(&nets[i].lock, flags); |
649 | list_for_each_entry(peer, &nets[i].peers, node) { | |
f41e2472 AB |
650 | if (nets[i].active[peer->rdev->destid]) { |
651 | rio_send_doorbell(peer->rdev, | |
652 | RIONET_DOORBELL_LEAVE); | |
653 | nets[i].active[peer->rdev->destid] = NULL; | |
654 | } | |
655 | } | |
34ed2ebb | 656 | spin_unlock_irqrestore(&nets[i].lock, flags); |
f41e2472 AB |
657 | } |
658 | ||
659 | return NOTIFY_DONE; | |
660 | } | |
661 | ||
b7dfca8b AB |
662 | static void rionet_remove_mport(struct device *dev, |
663 | struct class_interface *class_intf) | |
664 | { | |
665 | struct rio_mport *mport = to_rio_mport(dev); | |
666 | struct net_device *ndev; | |
667 | int id = mport->id; | |
668 | ||
669 | pr_debug("%s %s\n", __func__, mport->name); | |
670 | ||
671 | WARN(nets[id].nact, "%s called when connected to %d peers\n", | |
672 | __func__, nets[id].nact); | |
673 | WARN(!nets[id].ndev, "%s called for mport without NDEV\n", | |
674 | __func__); | |
675 | ||
676 | if (nets[id].ndev) { | |
677 | ndev = nets[id].ndev; | |
678 | netif_stop_queue(ndev); | |
679 | unregister_netdev(ndev); | |
680 | ||
681 | free_pages((unsigned long)nets[id].active, | |
682 | get_order(sizeof(void *) * | |
683 | RIO_MAX_ROUTE_ENTRIES(mport->sys_size))); | |
684 | nets[id].active = NULL; | |
685 | free_netdev(ndev); | |
686 | nets[id].ndev = NULL; | |
687 | } | |
688 | } | |
689 | ||
e6161d64 | 690 | #ifdef MODULE |
f89efd52 | 691 | static struct rio_device_id rionet_id_table[] = { |
e6161d64 AB |
692 | {RIO_DEVICE(RIO_ANY_ID, RIO_ANY_ID)}, |
693 | { 0, } /* terminate list */ | |
f89efd52 MP |
694 | }; |
695 | ||
e6161d64 AB |
696 | MODULE_DEVICE_TABLE(rapidio, rionet_id_table); |
697 | #endif | |
698 | ||
699 | static struct subsys_interface rionet_interface = { | |
700 | .name = "rionet", | |
701 | .subsys = &rio_bus_type, | |
702 | .add_dev = rionet_add_dev, | |
703 | .remove_dev = rionet_remove_dev, | |
f89efd52 MP |
704 | }; |
705 | ||
f41e2472 AB |
706 | static struct notifier_block rionet_notifier = { |
707 | .notifier_call = rionet_shutdown, | |
708 | }; | |
709 | ||
b7dfca8b AB |
710 | /* the rio_mport_interface is used to handle local mport devices */ |
711 | static struct class_interface rio_mport_interface __refdata = { | |
712 | .class = &rio_mport_class, | |
713 | .add_dev = NULL, | |
714 | .remove_dev = rionet_remove_mport, | |
715 | }; | |
716 | ||
f89efd52 MP |
717 | static int __init rionet_init(void) |
718 | { | |
f41e2472 AB |
719 | int ret; |
720 | ||
721 | ret = register_reboot_notifier(&rionet_notifier); | |
722 | if (ret) { | |
723 | pr_err("%s: failed to register reboot notifier (err=%d)\n", | |
724 | DRV_NAME, ret); | |
725 | return ret; | |
726 | } | |
b7dfca8b AB |
727 | |
728 | ret = class_interface_register(&rio_mport_interface); | |
729 | if (ret) { | |
730 | pr_err("%s: class_interface_register error: %d\n", | |
731 | DRV_NAME, ret); | |
732 | return ret; | |
733 | } | |
734 | ||
e6161d64 | 735 | return subsys_interface_register(&rionet_interface); |
f89efd52 MP |
736 | } |
737 | ||
738 | static void __exit rionet_exit(void) | |
739 | { | |
f41e2472 | 740 | unregister_reboot_notifier(&rionet_notifier); |
e6161d64 | 741 | subsys_interface_unregister(&rionet_interface); |
b7dfca8b | 742 | class_interface_unregister(&rio_mport_interface); |
f89efd52 MP |
743 | } |
744 | ||
2f809985 | 745 | late_initcall(rionet_init); |
f89efd52 | 746 | module_exit(rionet_exit); |