2 * This file is subject to the terms and conditions of the GNU General Public
3 * License. See the file "COPYING" in the main directory of this archive
6 * Copyright (C) 1999,2001-2005 Silicon Graphics, Inc. All rights reserved.
11 * Cross Partition Network Interface (XPNET) support
13 * XPNET provides a virtual network layered on top of the Cross
14 * Partition communication layer.
16 * XPNET provides direct point-to-point and broadcast-like support
17 * for an ethernet-like device. The ethernet broadcast medium is
18 * replaced with a point-to-point message structure which passes
19 * pointers to a DMA-capable block that a remote partition should
20 * retrieve and pass to the upper level networking layer.
25 #include <linux/module.h>
26 #include <linux/kernel.h>
27 #include <linux/pci.h>
28 #include <linux/init.h>
29 #include <linux/ioport.h>
30 #include <linux/netdevice.h>
31 #include <linux/etherdevice.h>
32 #include <linux/delay.h>
33 #include <linux/ethtool.h>
34 #include <linux/mii.h>
35 #include <linux/smp.h>
36 #include <linux/string.h>
37 #include <asm/sn/bte.h>
38 #include <asm/sn/io.h>
39 #include <asm/sn/sn_sal.h>
40 #include <asm/types.h>
41 #include <asm/atomic.h>
42 #include <asm/sn/xp.h>
46 * The message payload transferred by XPC.
48 * buf_pa is the physical address where the DMA should pull from.
50 * NOTE: for performance reasons, buf_pa should _ALWAYS_ begin on a
51 * cacheline boundary. To accomplish this, we record the number of
52 * bytes from the beginning of the first cacheline to the first useful
53 * byte of the skb (leadin_ignore) and the number of bytes from the
54 * last useful byte of the skb to the end of the last cacheline
57 * size is the number of bytes to transfer which includes the skb->len
58 * (useful bytes of the senders skb) plus the leadin and tailout
60 struct xpnet_message
{
61 u16 version
; /* Version for this message */
62 u16 embedded_bytes
; /* #of bytes embedded in XPC message */
63 u32 magic
; /* Special number indicating this is xpnet */
64 u64 buf_pa
; /* phys address of buffer to retrieve */
65 u32 size
; /* #of bytes in buffer */
66 u8 leadin_ignore
; /* #of bytes to ignore at the beginning */
67 u8 tailout_ignore
; /* #of bytes to ignore at the end */
68 unsigned char data
; /* body of small packets */
72 * Determine the size of our message, the cacheline aligned size,
73 * and then the number of message will request from XPC.
75 * XPC expects each message to exist in an individual cacheline.
77 #define XPNET_MSG_SIZE (L1_CACHE_BYTES - XPC_MSG_PAYLOAD_OFFSET)
78 #define XPNET_MSG_DATA_MAX \
79 (XPNET_MSG_SIZE - (u64)(&((struct xpnet_message *)0)->data))
80 #define XPNET_MSG_ALIGNED_SIZE (L1_CACHE_ALIGN(XPNET_MSG_SIZE))
81 #define XPNET_MSG_NENTRIES (PAGE_SIZE / XPNET_MSG_ALIGNED_SIZE)
84 #define XPNET_MAX_KTHREADS (XPNET_MSG_NENTRIES + 1)
85 #define XPNET_MAX_IDLE_KTHREADS (XPNET_MSG_NENTRIES + 1)
88 * Version number of XPNET implementation. XPNET can always talk to versions
89 * with same major #, and never talk to versions with a different version.
91 #define _XPNET_VERSION(_major, _minor) (((_major) << 4) | (_minor))
92 #define XPNET_VERSION_MAJOR(_v) ((_v) >> 4)
93 #define XPNET_VERSION_MINOR(_v) ((_v) & 0xf)
95 #define XPNET_VERSION _XPNET_VERSION(1,0) /* version 1.0 */
96 #define XPNET_VERSION_EMBED _XPNET_VERSION(1,1) /* version 1.1 */
97 #define XPNET_MAGIC 0x88786984 /* "XNET" */
99 #define XPNET_VALID_MSG(_m) \
100 ((XPNET_VERSION_MAJOR(_m->version) == XPNET_VERSION_MAJOR(XPNET_VERSION)) \
101 && (msg->magic == XPNET_MAGIC))
103 #define XPNET_DEVICE_NAME "xp0"
107 * When messages are queued with xpc_send_notify, a kmalloc'd buffer
108 * of the following type is passed as a notification cookie. When the
109 * notification function is called, we use the cookie to decide
110 * whether all outstanding message sends have completed. The skb can
113 struct xpnet_pending_msg
{
114 struct list_head free_list
;
119 /* driver specific structure pointed to by the device structure */
120 struct xpnet_dev_private
{
121 struct net_device_stats stats
;
124 struct net_device
*xpnet_device
;
127 * When we are notified of other partitions activating, we add them to
128 * our bitmask of partitions to which we broadcast.
130 static u64 xpnet_broadcast_partitions
;
132 static DEFINE_SPINLOCK(xpnet_broadcast_lock
);
135 * Since the Block Transfer Engine (BTE) is being used for the transfer
136 * and it relies upon cache-line size transfers, we need to reserve at
137 * least one cache-line for head and tail alignment. The BTE is
138 * limited to 8MB transfers.
140 * Testing has shown that changing MTU to greater than 64KB has no effect
141 * on TCP as the two sides negotiate a Max Segment Size that is limited
142 * to 64K. Other protocols May use packets greater than this, but for
143 * now, the default is 64KB.
145 #define XPNET_MAX_MTU (0x800000UL - L1_CACHE_BYTES)
146 /* 32KB has been determined to be the ideal */
147 #define XPNET_DEF_MTU (0x8000UL)
151 * The partition id is encapsulated in the MAC address. The following
152 * define locates the octet the partid is in.
154 #define XPNET_PARTID_OCTET 1
155 #define XPNET_LICENSE_OCTET 2
159 * Define the XPNET debug device structure that is to be used with dev_dbg(),
160 * dev_err(), dev_warn(), and dev_info().
162 struct device_driver xpnet_dbg_name
= {
166 struct device xpnet_dbg_subname
= {
167 .bus_id
= {0}, /* set to "" */
168 .driver
= &xpnet_dbg_name
171 struct device
*xpnet
= &xpnet_dbg_subname
;
174 * Packet was recevied by XPC and forwarded to us.
177 xpnet_receive(partid_t partid
, int channel
, struct xpnet_message
*msg
)
181 struct xpnet_dev_private
*priv
=
182 (struct xpnet_dev_private
*) xpnet_device
->priv
;
185 if (!XPNET_VALID_MSG(msg
)) {
187 * Packet with a different XPC version. Ignore.
189 xpc_received(partid
, channel
, (void *) msg
);
191 priv
->stats
.rx_errors
++;
195 dev_dbg(xpnet
, "received 0x%lx, %d, %d, %d\n", msg
->buf_pa
, msg
->size
,
196 msg
->leadin_ignore
, msg
->tailout_ignore
);
199 /* reserve an extra cache line */
200 skb
= dev_alloc_skb(msg
->size
+ L1_CACHE_BYTES
);
202 dev_err(xpnet
, "failed on dev_alloc_skb(%d)\n",
203 msg
->size
+ L1_CACHE_BYTES
);
205 xpc_received(partid
, channel
, (void *) msg
);
207 priv
->stats
.rx_errors
++;
213 * The allocated skb has some reserved space.
214 * In order to use bte_copy, we need to get the
215 * skb->data pointer moved forward.
217 skb_reserve(skb
, (L1_CACHE_BYTES
- ((u64
)skb
->data
&
218 (L1_CACHE_BYTES
- 1)) +
219 msg
->leadin_ignore
));
222 * Update the tail pointer to indicate data actually
225 skb_put(skb
, (msg
->size
- msg
->leadin_ignore
- msg
->tailout_ignore
));
228 * Move the data over from the other side.
230 if ((XPNET_VERSION_MINOR(msg
->version
) == 1) &&
231 (msg
->embedded_bytes
!= 0)) {
232 dev_dbg(xpnet
, "copying embedded message. memcpy(0x%p, 0x%p, "
233 "%lu)\n", skb
->data
, &msg
->data
,
234 (size_t) msg
->embedded_bytes
);
236 memcpy(skb
->data
, &msg
->data
, (size_t) msg
->embedded_bytes
);
238 dev_dbg(xpnet
, "transferring buffer to the skb->data area;\n\t"
239 "bte_copy(0x%p, 0x%p, %hu)\n", (void *)msg
->buf_pa
,
240 (void *)__pa((u64
)skb
->data
& ~(L1_CACHE_BYTES
- 1)),
243 bret
= bte_copy(msg
->buf_pa
,
244 __pa((u64
)skb
->data
& ~(L1_CACHE_BYTES
- 1)),
245 msg
->size
, (BTE_NOTIFY
| BTE_WACQUIRE
), NULL
);
247 if (bret
!= BTE_SUCCESS
) {
248 // >>> Need better way of cleaning skb. Currently skb
249 // >>> appears in_use and we can't just call
250 // >>> dev_kfree_skb.
251 dev_err(xpnet
, "bte_copy(0x%p, 0x%p, 0x%hx) returned "
252 "error=0x%x\n", (void *)msg
->buf_pa
,
253 (void *)__pa((u64
)skb
->data
&
254 ~(L1_CACHE_BYTES
- 1)),
257 xpc_received(partid
, channel
, (void *) msg
);
259 priv
->stats
.rx_errors
++;
265 dev_dbg(xpnet
, "<skb->head=0x%p skb->data=0x%p skb->tail=0x%p "
266 "skb->end=0x%p skb->len=%d\n", (void *) skb
->head
,
267 (void *)skb
->data
, skb_tail_pointer(skb
), (void *)skb
->end
,
270 skb
->protocol
= eth_type_trans(skb
, xpnet_device
);
271 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
273 dev_dbg(xpnet
, "passing skb to network layer; \n\tskb->head=0x%p "
274 "skb->data=0x%p skb->tail=0x%p skb->end=0x%p skb->len=%d\n",
275 (void *)skb
->head
, (void *)skb
->data
, skb_tail_pointer(skb
),
276 (void *) skb
->end
, skb
->len
);
279 xpnet_device
->last_rx
= jiffies
;
280 priv
->stats
.rx_packets
++;
281 priv
->stats
.rx_bytes
+= skb
->len
+ ETH_HLEN
;
284 xpc_received(partid
, channel
, (void *) msg
);
289 * This is the handler which XPC calls during any sort of change in
290 * state or message reception on a connection.
293 xpnet_connection_activity(enum xpc_retval reason
, partid_t partid
, int channel
,
294 void *data
, void *key
)
299 DBUG_ON(partid
<= 0 || partid
>= XP_MAX_PARTITIONS
);
300 DBUG_ON(channel
!= XPC_NET_CHANNEL
);
303 case xpcMsgReceived
: /* message received */
304 DBUG_ON(data
== NULL
);
306 xpnet_receive(partid
, channel
, (struct xpnet_message
*) data
);
309 case xpcConnected
: /* connection completed to a partition */
310 spin_lock_bh(&xpnet_broadcast_lock
);
311 xpnet_broadcast_partitions
|= 1UL << (partid
-1 );
312 bp
= xpnet_broadcast_partitions
;
313 spin_unlock_bh(&xpnet_broadcast_lock
);
315 netif_carrier_on(xpnet_device
);
317 dev_dbg(xpnet
, "%s connection created to partition %d; "
318 "xpnet_broadcast_partitions=0x%lx\n",
319 xpnet_device
->name
, partid
, bp
);
323 spin_lock_bh(&xpnet_broadcast_lock
);
324 xpnet_broadcast_partitions
&= ~(1UL << (partid
-1 ));
325 bp
= xpnet_broadcast_partitions
;
326 spin_unlock_bh(&xpnet_broadcast_lock
);
329 netif_carrier_off(xpnet_device
);
332 dev_dbg(xpnet
, "%s disconnected from partition %d; "
333 "xpnet_broadcast_partitions=0x%lx\n",
334 xpnet_device
->name
, partid
, bp
);
342 xpnet_dev_open(struct net_device
*dev
)
347 dev_dbg(xpnet
, "calling xpc_connect(%d, 0x%p, NULL, %ld, %ld, %d, "
348 "%d)\n", XPC_NET_CHANNEL
, xpnet_connection_activity
,
349 XPNET_MSG_SIZE
, XPNET_MSG_NENTRIES
, XPNET_MAX_KTHREADS
,
350 XPNET_MAX_IDLE_KTHREADS
);
352 ret
= xpc_connect(XPC_NET_CHANNEL
, xpnet_connection_activity
, NULL
,
353 XPNET_MSG_SIZE
, XPNET_MSG_NENTRIES
,
354 XPNET_MAX_KTHREADS
, XPNET_MAX_IDLE_KTHREADS
);
355 if (ret
!= xpcSuccess
) {
356 dev_err(xpnet
, "ifconfig up of %s failed on XPC connect, "
357 "ret=%d\n", dev
->name
, ret
);
362 dev_dbg(xpnet
, "ifconfig up of %s; XPC connected\n", dev
->name
);
369 xpnet_dev_stop(struct net_device
*dev
)
371 xpc_disconnect(XPC_NET_CHANNEL
);
373 dev_dbg(xpnet
, "ifconfig down of %s; XPC disconnected\n", dev
->name
);
380 xpnet_dev_change_mtu(struct net_device
*dev
, int new_mtu
)
382 /* 68 comes from min TCP+IP+MAC header */
383 if ((new_mtu
< 68) || (new_mtu
> XPNET_MAX_MTU
)) {
384 dev_err(xpnet
, "ifconfig %s mtu %d failed; value must be "
385 "between 68 and %ld\n", dev
->name
, new_mtu
,
391 dev_dbg(xpnet
, "ifconfig %s mtu set to %d\n", dev
->name
, new_mtu
);
397 * Required for the net_device structure.
400 xpnet_dev_set_config(struct net_device
*dev
, struct ifmap
*new_map
)
407 * Return statistics to the caller.
409 static struct net_device_stats
*
410 xpnet_dev_get_stats(struct net_device
*dev
)
412 struct xpnet_dev_private
*priv
;
415 priv
= (struct xpnet_dev_private
*) dev
->priv
;
422 * Notification that the other end has received the message and
423 * DMA'd the skb information. At this point, they are done with
424 * our side. When all recipients are done processing, we
425 * release the skb and then release our pending message structure.
428 xpnet_send_completed(enum xpc_retval reason
, partid_t partid
, int channel
,
431 struct xpnet_pending_msg
*queued_msg
=
432 (struct xpnet_pending_msg
*) __qm
;
435 DBUG_ON(queued_msg
== NULL
);
437 dev_dbg(xpnet
, "message to %d notified with reason %d\n",
440 if (atomic_dec_return(&queued_msg
->use_count
) == 0) {
441 dev_dbg(xpnet
, "all acks for skb->head=-x%p\n",
442 (void *) queued_msg
->skb
->head
);
444 dev_kfree_skb_any(queued_msg
->skb
);
451 * Network layer has formatted a packet (skb) and is ready to place it
452 * "on the wire". Prepare and send an xpnet_message to all partitions
453 * which have connected with us and are targets of this packet.
455 * MAC-NOTE: For the XPNET driver, the MAC address contains the
456 * destination partition_id. If the destination partition id word
457 * is 0xff, this packet is to broadcast to all partitions.
460 xpnet_dev_hard_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
462 struct xpnet_pending_msg
*queued_msg
;
464 struct xpnet_message
*msg
;
465 u64 start_addr
, end_addr
;
468 partid_t dest_partid
;
469 struct xpnet_dev_private
*priv
;
473 priv
= (struct xpnet_dev_private
*) dev
->priv
;
476 dev_dbg(xpnet
, ">skb->head=0x%p skb->data=0x%p skb->tail=0x%p "
477 "skb->end=0x%p skb->len=%d\n", (void *) skb
->head
,
478 (void *)skb
->data
, skb_tail_pointer(skb
), (void *)skb
->end
,
483 * The xpnet_pending_msg tracks how many outstanding
484 * xpc_send_notifies are relying on this skb. When none
485 * remain, release the skb.
487 queued_msg
= kmalloc(sizeof(struct xpnet_pending_msg
), GFP_ATOMIC
);
488 if (queued_msg
== NULL
) {
489 dev_warn(xpnet
, "failed to kmalloc %ld bytes; dropping "
490 "packet\n", sizeof(struct xpnet_pending_msg
));
492 priv
->stats
.tx_errors
++;
498 /* get the beginning of the first cacheline and end of last */
499 start_addr
= ((u64
) skb
->data
& ~(L1_CACHE_BYTES
- 1));
500 end_addr
= L1_CACHE_ALIGN((u64
)skb_tail_pointer(skb
));
502 /* calculate how many bytes to embed in the XPC message */
504 if (unlikely(skb
->len
<= XPNET_MSG_DATA_MAX
)) {
505 /* skb->data does fit so embed */
506 embedded_bytes
= skb
->len
;
511 * Since the send occurs asynchronously, we set the count to one
512 * and begin sending. Any sends that happen to complete before
513 * we are done sending will not free the skb. We will be left
514 * with that task during exit. This also handles the case of
515 * a packet destined for a partition which is no longer up.
517 atomic_set(&queued_msg
->use_count
, 1);
518 queued_msg
->skb
= skb
;
521 second_mac_octet
= skb
->data
[XPNET_PARTID_OCTET
];
522 if (second_mac_octet
== 0xff) {
523 /* we are being asked to broadcast to all partitions */
524 dp
= xpnet_broadcast_partitions
;
525 } else if (second_mac_octet
!= 0) {
526 dp
= xpnet_broadcast_partitions
&
527 (1UL << (second_mac_octet
- 1));
529 /* 0 is an invalid partid. Ignore */
532 dev_dbg(xpnet
, "destination Partitions mask (dp) = 0x%lx\n", dp
);
535 * If we wanted to allow promiscous mode to work like an
536 * unswitched network, this would be a good point to OR in a
537 * mask of partitions which should be receiving all packets.
543 for (dest_partid
= 1; dp
&& dest_partid
< XP_MAX_PARTITIONS
;
547 if (!(dp
& (1UL << (dest_partid
- 1)))) {
548 /* not destined for this partition */
552 /* remove this partition from the destinations mask */
553 dp
&= ~(1UL << (dest_partid
- 1));
556 /* found a partition to send to */
558 ret
= xpc_allocate(dest_partid
, XPC_NET_CHANNEL
,
559 XPC_NOWAIT
, (void **)&msg
);
560 if (unlikely(ret
!= xpcSuccess
)) {
564 msg
->embedded_bytes
= embedded_bytes
;
565 if (unlikely(embedded_bytes
!= 0)) {
566 msg
->version
= XPNET_VERSION_EMBED
;
567 dev_dbg(xpnet
, "calling memcpy(0x%p, 0x%p, 0x%lx)\n",
568 &msg
->data
, skb
->data
, (size_t) embedded_bytes
);
569 memcpy(&msg
->data
, skb
->data
, (size_t) embedded_bytes
);
571 msg
->version
= XPNET_VERSION
;
573 msg
->magic
= XPNET_MAGIC
;
574 msg
->size
= end_addr
- start_addr
;
575 msg
->leadin_ignore
= (u64
) skb
->data
- start_addr
;
576 msg
->tailout_ignore
= end_addr
- (u64
)skb_tail_pointer(skb
);
577 msg
->buf_pa
= __pa(start_addr
);
579 dev_dbg(xpnet
, "sending XPC message to %d:%d\nmsg->buf_pa="
580 "0x%lx, msg->size=%u, msg->leadin_ignore=%u, "
581 "msg->tailout_ignore=%u\n", dest_partid
,
582 XPC_NET_CHANNEL
, msg
->buf_pa
, msg
->size
,
583 msg
->leadin_ignore
, msg
->tailout_ignore
);
586 atomic_inc(&queued_msg
->use_count
);
588 ret
= xpc_send_notify(dest_partid
, XPC_NET_CHANNEL
, msg
,
589 xpnet_send_completed
, queued_msg
);
590 if (unlikely(ret
!= xpcSuccess
)) {
591 atomic_dec(&queued_msg
->use_count
);
597 if (atomic_dec_return(&queued_msg
->use_count
) == 0) {
598 dev_dbg(xpnet
, "no partitions to receive packet destined for "
599 "%d\n", dest_partid
);
606 priv
->stats
.tx_packets
++;
607 priv
->stats
.tx_bytes
+= skb
->len
;
614 * Deal with transmit timeouts coming from the network layer.
617 xpnet_dev_tx_timeout (struct net_device
*dev
)
619 struct xpnet_dev_private
*priv
;
622 priv
= (struct xpnet_dev_private
*) dev
->priv
;
624 priv
->stats
.tx_errors
++;
634 int result
= -ENOMEM
;
637 if (!ia64_platform_is("sn2")) {
641 dev_info(xpnet
, "registering network device %s\n", XPNET_DEVICE_NAME
);
644 * use ether_setup() to init the majority of our device
645 * structure and then override the necessary pieces.
647 xpnet_device
= alloc_netdev(sizeof(struct xpnet_dev_private
),
648 XPNET_DEVICE_NAME
, ether_setup
);
649 if (xpnet_device
== NULL
) {
653 netif_carrier_off(xpnet_device
);
655 xpnet_device
->mtu
= XPNET_DEF_MTU
;
656 xpnet_device
->change_mtu
= xpnet_dev_change_mtu
;
657 xpnet_device
->open
= xpnet_dev_open
;
658 xpnet_device
->get_stats
= xpnet_dev_get_stats
;
659 xpnet_device
->stop
= xpnet_dev_stop
;
660 xpnet_device
->hard_start_xmit
= xpnet_dev_hard_start_xmit
;
661 xpnet_device
->tx_timeout
= xpnet_dev_tx_timeout
;
662 xpnet_device
->set_config
= xpnet_dev_set_config
;
665 * Multicast assumes the LSB of the first octet is set for multicast
666 * MAC addresses. We chose the first octet of the MAC to be unlikely
667 * to collide with any vendor's officially issued MAC.
669 xpnet_device
->dev_addr
[0] = 0xfe;
670 xpnet_device
->dev_addr
[XPNET_PARTID_OCTET
] = sn_partition_id
;
671 license_num
= sn_partition_serial_number_val();
672 for (i
= 3; i
>= 0; i
--) {
673 xpnet_device
->dev_addr
[XPNET_LICENSE_OCTET
+ i
] =
675 license_num
= license_num
>> 8;
679 * ether_setup() sets this to a multicast device. We are
680 * really not supporting multicast at this time.
682 xpnet_device
->flags
&= ~IFF_MULTICAST
;
685 * No need to checksum as it is a DMA transfer. The BTE will
686 * report an error if the data is not retrievable and the
687 * packet will be dropped.
689 xpnet_device
->features
= NETIF_F_NO_CSUM
;
691 result
= register_netdev(xpnet_device
);
693 free_netdev(xpnet_device
);
698 module_init(xpnet_init
);
704 dev_info(xpnet
, "unregistering network device %s\n",
705 xpnet_device
[0].name
);
707 unregister_netdev(xpnet_device
);
709 free_netdev(xpnet_device
);
711 module_exit(xpnet_exit
);
714 MODULE_AUTHOR("Silicon Graphics, Inc.");
715 MODULE_DESCRIPTION("Cross Partition Network adapter (XPNET)");
716 MODULE_LICENSE("GPL");