2 * eth1394.c -- Ethernet driver for Linux IEEE-1394 Subsystem
4 * Copyright (C) 2001-2003 Ben Collins <bcollins@debian.org>
5 * 2000 Bonin Franck <boninf@free.fr>
6 * 2003 Steve Kinneberg <kinnebergsteve@acmsystems.com>
8 * Mainly based on work by Emanuel Pirker and Andreas E. Bombe
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software Foundation,
22 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
25 /* This driver intends to support RFC 2734, which describes a method for
26 * transporting IPv4 datagrams over IEEE-1394 serial busses. This driver
27 * will ultimately support that method, but currently falls short in
32 * - Add MCAP. Limited Multicast exists only to 224.0.0.1 and 224.0.0.2.
34 * Non-RFC 2734 related:
35 * - Handle fragmented skb's coming from the networking layer.
36 * - Move generic GASP reception to core 1394 code
37 * - Convert kmalloc/kfree for link fragments to use kmem_cache_* instead
38 * - Stability improvements
39 * - Performance enhancements
40 * - Consider garbage collecting old partial datagrams after X amount of time
44 #include <linux/module.h>
46 #include <linux/sched.h>
47 #include <linux/kernel.h>
48 #include <linux/slab.h>
49 #include <linux/errno.h>
50 #include <linux/types.h>
51 #include <linux/delay.h>
52 #include <linux/init.h>
54 #include <linux/netdevice.h>
55 #include <linux/inetdevice.h>
56 #include <linux/etherdevice.h>
57 #include <linux/if_arp.h>
58 #include <linux/if_ether.h>
61 #include <linux/tcp.h>
62 #include <linux/skbuff.h>
63 #include <linux/bitops.h>
64 #include <linux/ethtool.h>
65 #include <asm/uaccess.h>
66 #include <asm/delay.h>
67 #include <asm/semaphore.h>
71 #include "ieee1394_types.h"
72 #include "ieee1394_core.h"
73 #include "ieee1394_transactions.h"
75 #include "highlevel.h"
79 #include "config_roms.h"
81 #define ETH1394_PRINT_G(level, fmt, args...) \
82 printk(level "%s: " fmt, driver_name, ## args)
84 #define ETH1394_PRINT(level, dev_name, fmt, args...) \
85 printk(level "%s: %s: " fmt, driver_name, dev_name, ## args)
87 #define DEBUG(fmt, args...) \
88 printk(KERN_ERR "%s:%s[%d]: " fmt "\n", driver_name, __FUNCTION__, __LINE__, ## args)
89 #define TRACE() printk(KERN_ERR "%s:%s[%d] ---- TRACE\n", driver_name, __FUNCTION__, __LINE__)
91 static char version
[] __devinitdata
=
92 "$Rev: 1224 $ Ben Collins <bcollins@debian.org>";
94 struct fragment_info
{
95 struct list_head list
;
100 struct partial_datagram
{
101 struct list_head list
;
107 struct list_head frag_info
;
111 struct list_head list
; /* partial datagram list per node */
112 unsigned int sz
; /* partial datagram list size per node */
113 spinlock_t lock
; /* partial datagram lock */
116 struct eth1394_host_info
{
117 struct hpsb_host
*host
;
118 struct net_device
*dev
;
121 struct eth1394_node_ref
{
122 struct unit_directory
*ud
;
123 struct list_head list
;
126 struct eth1394_node_info
{
127 u16 maxpayload
; /* Max payload */
128 u8 sspd
; /* Max speed */
129 u64 fifo
; /* FIFO address */
130 struct pdg_list pdg
; /* partial RX datagram lists */
131 int dgl
; /* Outgoing datagram label */
134 /* Our ieee1394 highlevel driver */
135 #define ETH1394_DRIVER_NAME "eth1394"
136 static const char driver_name
[] = ETH1394_DRIVER_NAME
;
138 static kmem_cache_t
*packet_task_cache
;
140 static struct hpsb_highlevel eth1394_highlevel
;
142 /* Use common.lf to determine header len */
143 static const int hdr_type_len
[] = {
144 sizeof (struct eth1394_uf_hdr
),
145 sizeof (struct eth1394_ff_hdr
),
146 sizeof (struct eth1394_sf_hdr
),
147 sizeof (struct eth1394_sf_hdr
)
150 /* Change this to IEEE1394_SPEED_S100 to make testing easier */
151 #define ETH1394_SPEED_DEF IEEE1394_SPEED_MAX
153 /* For now, this needs to be 1500, so that XP works with us */
154 #define ETH1394_DATA_LEN ETH_DATA_LEN
156 static const u16 eth1394_speedto_maxpayload
[] = {
157 /* S100, S200, S400, S800, S1600, S3200 */
158 512, 1024, 2048, 4096, 4096, 4096
161 MODULE_AUTHOR("Ben Collins (bcollins@debian.org)");
162 MODULE_DESCRIPTION("IEEE 1394 IPv4 Driver (IPv4-over-1394 as per RFC 2734)");
163 MODULE_LICENSE("GPL");
165 /* The max_partial_datagrams parameter is the maximum number of fragmented
166 * datagrams per node that eth1394 will keep in memory. Providing an upper
167 * bound allows us to limit the amount of memory that partial datagrams
168 * consume in the event that some partial datagrams are never completed. This
169 * should probably change to a sysctl item or the like if possible.
171 MODULE_PARM(max_partial_datagrams
, "i");
172 MODULE_PARM_DESC(max_partial_datagrams
,
173 "Maximum number of partially received fragmented datagrams "
175 static int max_partial_datagrams
= 25;
178 static int ether1394_header(struct sk_buff
*skb
, struct net_device
*dev
,
179 unsigned short type
, void *daddr
, void *saddr
,
181 static int ether1394_rebuild_header(struct sk_buff
*skb
);
182 static int ether1394_header_parse(struct sk_buff
*skb
, unsigned char *haddr
);
183 static int ether1394_header_cache(struct neighbour
*neigh
, struct hh_cache
*hh
);
184 static void ether1394_header_cache_update(struct hh_cache
*hh
,
185 struct net_device
*dev
,
186 unsigned char * haddr
);
187 static int ether1394_mac_addr(struct net_device
*dev
, void *p
);
189 static inline void purge_partial_datagram(struct list_head
*old
);
190 static int ether1394_tx(struct sk_buff
*skb
, struct net_device
*dev
);
191 static void ether1394_iso(struct hpsb_iso
*iso
);
193 static int ether1394_do_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
);
194 static int ether1394_ethtool_ioctl(struct net_device
*dev
, void __user
*useraddr
);
196 static int ether1394_write(struct hpsb_host
*host
, int srcid
, int destid
,
197 quadlet_t
*data
, u64 addr
, size_t len
, u16 flags
);
198 static void ether1394_add_host (struct hpsb_host
*host
);
199 static void ether1394_remove_host (struct hpsb_host
*host
);
200 static void ether1394_host_reset (struct hpsb_host
*host
);
202 /* Function for incoming 1394 packets */
203 static struct hpsb_address_ops addr_ops
= {
204 .write
= ether1394_write
,
207 /* Ieee1394 highlevel driver functions */
208 static struct hpsb_highlevel eth1394_highlevel
= {
210 .add_host
= ether1394_add_host
,
211 .remove_host
= ether1394_remove_host
,
212 .host_reset
= ether1394_host_reset
,
216 /* This is called after an "ifup" */
217 static int ether1394_open (struct net_device
*dev
)
219 struct eth1394_priv
*priv
= dev
->priv
;
222 /* Something bad happened, don't even try */
223 if (priv
->bc_state
== ETHER1394_BC_ERROR
) {
224 /* we'll try again */
225 priv
->iso
= hpsb_iso_recv_init(priv
->host
,
226 ETHER1394_GASP_BUFFERS
* 2 *
227 (1 << (priv
->host
->csr
.max_rec
+
229 ETHER1394_GASP_BUFFERS
,
230 priv
->broadcast_channel
,
231 HPSB_ISO_DMA_PACKET_PER_BUFFER
,
233 if (priv
->iso
== NULL
) {
234 ETH1394_PRINT(KERN_ERR
, dev
->name
,
235 "Could not allocate isochronous receive "
236 "context for the broadcast channel\n");
237 priv
->bc_state
= ETHER1394_BC_ERROR
;
240 if (hpsb_iso_recv_start(priv
->iso
, -1, (1 << 3), -1) < 0)
241 priv
->bc_state
= ETHER1394_BC_STOPPED
;
243 priv
->bc_state
= ETHER1394_BC_RUNNING
;
250 netif_start_queue (dev
);
254 /* This is called after an "ifdown" */
255 static int ether1394_stop (struct net_device
*dev
)
257 netif_stop_queue (dev
);
261 /* Return statistics to the caller */
262 static struct net_device_stats
*ether1394_stats (struct net_device
*dev
)
264 return &(((struct eth1394_priv
*)dev
->priv
)->stats
);
267 /* What to do if we timeout. I think a host reset is probably in order, so
268 * that's what we do. Should we increment the stat counters too? */
269 static void ether1394_tx_timeout (struct net_device
*dev
)
271 ETH1394_PRINT (KERN_ERR
, dev
->name
, "Timeout, resetting host %s\n",
272 ((struct eth1394_priv
*)(dev
->priv
))->host
->driver
->name
);
274 highlevel_host_reset (((struct eth1394_priv
*)(dev
->priv
))->host
);
276 netif_wake_queue (dev
);
279 static int ether1394_change_mtu(struct net_device
*dev
, int new_mtu
)
281 struct eth1394_priv
*priv
= dev
->priv
;
283 if ((new_mtu
< 68) ||
284 (new_mtu
> min(ETH1394_DATA_LEN
,
285 (int)((1 << (priv
->host
->csr
.max_rec
+ 1)) -
286 (sizeof(union eth1394_hdr
) +
287 ETHER1394_GASP_OVERHEAD
)))))
293 static inline void purge_partial_datagram(struct list_head
*old
)
295 struct partial_datagram
*pd
= list_entry(old
, struct partial_datagram
, list
);
296 struct list_head
*lh
, *n
;
298 list_for_each_safe(lh
, n
, &pd
->frag_info
) {
299 struct fragment_info
*fi
= list_entry(lh
, struct fragment_info
, list
);
308 /******************************************
309 * 1394 bus activity functions
310 ******************************************/
312 static struct eth1394_node_ref
*eth1394_find_node(struct list_head
*inl
,
313 struct unit_directory
*ud
)
315 struct eth1394_node_ref
*node
;
317 list_for_each_entry(node
, inl
, list
)
324 static struct eth1394_node_ref
*eth1394_find_node_guid(struct list_head
*inl
,
327 struct eth1394_node_ref
*node
;
329 list_for_each_entry(node
, inl
, list
)
330 if (node
->ud
->ne
->guid
== guid
)
336 static struct eth1394_node_ref
*eth1394_find_node_nodeid(struct list_head
*inl
,
339 struct eth1394_node_ref
*node
;
340 list_for_each_entry(node
, inl
, list
) {
341 if (node
->ud
->ne
->nodeid
== nodeid
)
348 static int eth1394_probe(struct device
*dev
)
350 struct unit_directory
*ud
;
351 struct eth1394_host_info
*hi
;
352 struct eth1394_priv
*priv
;
353 struct eth1394_node_ref
*new_node
;
354 struct eth1394_node_info
*node_info
;
356 ud
= container_of(dev
, struct unit_directory
, device
);
358 hi
= hpsb_get_hostinfo(ð1394_highlevel
, ud
->ne
->host
);
362 new_node
= kmalloc(sizeof(struct eth1394_node_ref
),
363 in_interrupt() ? GFP_ATOMIC
: GFP_KERNEL
);
367 node_info
= kmalloc(sizeof(struct eth1394_node_info
),
368 in_interrupt() ? GFP_ATOMIC
: GFP_KERNEL
);
374 spin_lock_init(&node_info
->pdg
.lock
);
375 INIT_LIST_HEAD(&node_info
->pdg
.list
);
376 node_info
->pdg
.sz
= 0;
377 node_info
->fifo
= ETHER1394_INVALID_ADDR
;
379 ud
->device
.driver_data
= node_info
;
382 priv
= (struct eth1394_priv
*)hi
->dev
->priv
;
383 list_add_tail(&new_node
->list
, &priv
->ip_node_list
);
388 static int eth1394_remove(struct device
*dev
)
390 struct unit_directory
*ud
;
391 struct eth1394_host_info
*hi
;
392 struct eth1394_priv
*priv
;
393 struct eth1394_node_ref
*old_node
;
394 struct eth1394_node_info
*node_info
;
395 struct list_head
*lh
, *n
;
398 ud
= container_of(dev
, struct unit_directory
, device
);
399 hi
= hpsb_get_hostinfo(ð1394_highlevel
, ud
->ne
->host
);
403 priv
= (struct eth1394_priv
*)hi
->dev
->priv
;
405 old_node
= eth1394_find_node(&priv
->ip_node_list
, ud
);
408 list_del(&old_node
->list
);
411 node_info
= (struct eth1394_node_info
*)ud
->device
.driver_data
;
413 spin_lock_irqsave(&node_info
->pdg
.lock
, flags
);
414 /* The partial datagram list should be empty, but we'll just
415 * make sure anyway... */
416 list_for_each_safe(lh
, n
, &node_info
->pdg
.list
) {
417 purge_partial_datagram(lh
);
419 spin_unlock_irqrestore(&node_info
->pdg
.lock
, flags
);
422 ud
->device
.driver_data
= NULL
;
427 static int eth1394_update(struct unit_directory
*ud
)
429 struct eth1394_host_info
*hi
;
430 struct eth1394_priv
*priv
;
431 struct eth1394_node_ref
*node
;
432 struct eth1394_node_info
*node_info
;
434 hi
= hpsb_get_hostinfo(ð1394_highlevel
, ud
->ne
->host
);
438 priv
= (struct eth1394_priv
*)hi
->dev
->priv
;
440 node
= eth1394_find_node(&priv
->ip_node_list
, ud
);
443 node
= kmalloc(sizeof(struct eth1394_node_ref
),
444 in_interrupt() ? GFP_ATOMIC
: GFP_KERNEL
);
448 node_info
= kmalloc(sizeof(struct eth1394_node_info
),
449 in_interrupt() ? GFP_ATOMIC
: GFP_KERNEL
);
455 spin_lock_init(&node_info
->pdg
.lock
);
456 INIT_LIST_HEAD(&node_info
->pdg
.list
);
457 node_info
->pdg
.sz
= 0;
459 ud
->device
.driver_data
= node_info
;
462 priv
= (struct eth1394_priv
*)hi
->dev
->priv
;
463 list_add_tail(&node
->list
, &priv
->ip_node_list
);
470 static struct ieee1394_device_id eth1394_id_table
[] = {
472 .match_flags
= (IEEE1394_MATCH_SPECIFIER_ID
|
473 IEEE1394_MATCH_VERSION
),
474 .specifier_id
= ETHER1394_GASP_SPECIFIER_ID
,
475 .version
= ETHER1394_GASP_VERSION
,
480 MODULE_DEVICE_TABLE(ieee1394
, eth1394_id_table
);
482 static struct hpsb_protocol_driver eth1394_proto_driver
= {
483 .name
= "IPv4 over 1394 Driver",
484 .id_table
= eth1394_id_table
,
485 .update
= eth1394_update
,
487 .name
= ETH1394_DRIVER_NAME
,
488 .bus
= &ieee1394_bus_type
,
489 .probe
= eth1394_probe
,
490 .remove
= eth1394_remove
,
495 static void ether1394_reset_priv (struct net_device
*dev
, int set_mtu
)
499 struct eth1394_priv
*priv
= dev
->priv
;
500 struct hpsb_host
*host
= priv
->host
;
501 u64 guid
= *((u64
*)&(host
->csr
.rom
->bus_info_data
[3]));
502 u16 maxpayload
= 1 << (host
->csr
.max_rec
+ 1);
503 int max_speed
= IEEE1394_SPEED_MAX
;
505 spin_lock_irqsave (&priv
->lock
, flags
);
507 memset(priv
->ud_list
, 0, sizeof(struct node_entry
*) * ALL_NODES
);
508 priv
->bc_maxpayload
= 512;
510 /* Determine speed limit */
511 for (i
= 0; i
< host
->node_count
; i
++)
512 if (max_speed
> host
->speed_map
[NODEID_TO_NODE(host
->node_id
) *
514 max_speed
= host
->speed_map
[NODEID_TO_NODE(host
->node_id
) *
516 priv
->bc_sspd
= max_speed
;
518 /* We'll use our maxpayload as the default mtu */
520 dev
->mtu
= min(ETH1394_DATA_LEN
,
522 (sizeof(union eth1394_hdr
) +
523 ETHER1394_GASP_OVERHEAD
)));
525 /* Set our hardware address while we're at it */
526 *(u64
*)dev
->dev_addr
= guid
;
527 *(u64
*)dev
->broadcast
= ~0x0ULL
;
530 spin_unlock_irqrestore (&priv
->lock
, flags
);
533 /* This function is called right before register_netdev */
534 static void ether1394_init_dev (struct net_device
*dev
)
537 dev
->open
= ether1394_open
;
538 dev
->stop
= ether1394_stop
;
539 dev
->hard_start_xmit
= ether1394_tx
;
540 dev
->get_stats
= ether1394_stats
;
541 dev
->tx_timeout
= ether1394_tx_timeout
;
542 dev
->change_mtu
= ether1394_change_mtu
;
544 dev
->hard_header
= ether1394_header
;
545 dev
->rebuild_header
= ether1394_rebuild_header
;
546 dev
->hard_header_cache
= ether1394_header_cache
;
547 dev
->header_cache_update
= ether1394_header_cache_update
;
548 dev
->hard_header_parse
= ether1394_header_parse
;
549 dev
->set_mac_address
= ether1394_mac_addr
;
550 dev
->do_ioctl
= ether1394_do_ioctl
;
553 dev
->watchdog_timeo
= ETHER1394_TIMEOUT
;
554 dev
->flags
= IFF_BROADCAST
| IFF_MULTICAST
;
555 dev
->features
= NETIF_F_HIGHDMA
;
556 dev
->addr_len
= ETH1394_ALEN
;
557 dev
->hard_header_len
= ETH1394_HLEN
;
558 dev
->type
= ARPHRD_IEEE1394
;
560 ether1394_reset_priv (dev
, 1);
564 * This function is called every time a card is found. It is generally called
565 * when the module is installed. This is where we add all of our ethernet
566 * devices. One for each host.
568 static void ether1394_add_host (struct hpsb_host
*host
)
570 struct eth1394_host_info
*hi
= NULL
;
571 struct net_device
*dev
= NULL
;
572 struct eth1394_priv
*priv
;
573 static int version_printed
= 0;
576 if (!(host
->config_roms
& HPSB_CONFIG_ROM_ENTRY_IP1394
))
579 fifo_addr
= hpsb_allocate_and_register_addrspace(ð1394_highlevel
,
582 ETHER1394_REGION_ADDR_LEN
,
583 ETHER1394_REGION_ADDR_LEN
,
585 if (fifo_addr
== ~0ULL)
588 if (version_printed
++ == 0)
589 ETH1394_PRINT_G (KERN_INFO
, "%s\n", version
);
591 /* We should really have our own alloc_hpsbdev() function in
592 * net_init.c instead of calling the one for ethernet then hijacking
593 * it for ourselves. That way we'd be a real networking device. */
594 dev
= alloc_etherdev(sizeof (struct eth1394_priv
));
597 ETH1394_PRINT_G (KERN_ERR
, "Out of memory trying to allocate "
598 "etherdevice for IEEE 1394 device %s-%d\n",
599 host
->driver
->name
, host
->id
);
603 SET_MODULE_OWNER(dev
);
605 priv
= (struct eth1394_priv
*)dev
->priv
;
607 INIT_LIST_HEAD(&priv
->ip_node_list
);
609 spin_lock_init(&priv
->lock
);
611 priv
->local_fifo
= fifo_addr
;
613 hi
= hpsb_create_hostinfo(ð1394_highlevel
, host
, sizeof(*hi
));
616 ETH1394_PRINT_G (KERN_ERR
, "Out of memory trying to create "
617 "hostinfo for IEEE 1394 device %s-%d\n",
618 host
->driver
->name
, host
->id
);
622 ether1394_init_dev(dev
);
624 if (register_netdev (dev
)) {
625 ETH1394_PRINT (KERN_ERR
, dev
->name
, "Error registering network driver\n");
629 ETH1394_PRINT (KERN_ERR
, dev
->name
, "IEEE-1394 IPv4 over 1394 Ethernet (fw-host%d)\n",
635 /* Ignore validity in hopes that it will be set in the future. It'll
636 * be checked when the eth device is opened. */
637 priv
->broadcast_channel
= host
->csr
.broadcast_channel
& 0x3f;
639 priv
->iso
= hpsb_iso_recv_init(host
, (ETHER1394_GASP_BUFFERS
* 2 *
640 (1 << (host
->csr
.max_rec
+ 1))),
641 ETHER1394_GASP_BUFFERS
,
642 priv
->broadcast_channel
,
643 HPSB_ISO_DMA_PACKET_PER_BUFFER
,
645 if (priv
->iso
== NULL
) {
646 ETH1394_PRINT(KERN_ERR
, dev
->name
,
647 "Could not allocate isochronous receive context "
648 "for the broadcast channel\n");
649 priv
->bc_state
= ETHER1394_BC_ERROR
;
651 if (hpsb_iso_recv_start(priv
->iso
, -1, (1 << 3), -1) < 0)
652 priv
->bc_state
= ETHER1394_BC_STOPPED
;
654 priv
->bc_state
= ETHER1394_BC_RUNNING
;
663 hpsb_destroy_hostinfo(ð1394_highlevel
, host
);
668 /* Remove a card from our list */
669 static void ether1394_remove_host (struct hpsb_host
*host
)
671 struct eth1394_host_info
*hi
;
673 hi
= hpsb_get_hostinfo(ð1394_highlevel
, host
);
675 struct eth1394_priv
*priv
= (struct eth1394_priv
*)hi
->dev
->priv
;
677 hpsb_unregister_addrspace(ð1394_highlevel
, host
,
680 if (priv
->iso
!= NULL
)
681 hpsb_iso_shutdown(priv
->iso
);
684 unregister_netdev (hi
->dev
);
685 free_netdev(hi
->dev
);
692 /* A reset has just arisen */
693 static void ether1394_host_reset (struct hpsb_host
*host
)
695 struct eth1394_host_info
*hi
;
696 struct eth1394_priv
*priv
;
697 struct net_device
*dev
;
698 struct list_head
*lh
, *n
;
699 struct eth1394_node_ref
*node
;
700 struct eth1394_node_info
*node_info
;
703 hi
= hpsb_get_hostinfo(ð1394_highlevel
, host
);
705 /* This can happen for hosts that we don't use */
710 priv
= (struct eth1394_priv
*)dev
->priv
;
712 /* Reset our private host data, but not our mtu */
713 netif_stop_queue (dev
);
714 ether1394_reset_priv (dev
, 0);
716 list_for_each_entry(node
, &priv
->ip_node_list
, list
) {
717 node_info
= (struct eth1394_node_info
*)node
->ud
->device
.driver_data
;
719 spin_lock_irqsave(&node_info
->pdg
.lock
, flags
);
721 list_for_each_safe(lh
, n
, &node_info
->pdg
.list
) {
722 purge_partial_datagram(lh
);
725 INIT_LIST_HEAD(&(node_info
->pdg
.list
));
726 node_info
->pdg
.sz
= 0;
728 spin_unlock_irqrestore(&node_info
->pdg
.lock
, flags
);
731 netif_wake_queue (dev
);
734 /******************************************
735 * HW Header net device functions
736 ******************************************/
737 /* These functions have been adapted from net/ethernet/eth.c */
740 /* Create a fake MAC header for an arbitrary protocol layer.
741 * saddr=NULL means use device source address
742 * daddr=NULL means leave destination address (eg unresolved arp). */
743 static int ether1394_header(struct sk_buff
*skb
, struct net_device
*dev
,
744 unsigned short type
, void *daddr
, void *saddr
,
747 struct eth1394hdr
*eth
= (struct eth1394hdr
*)skb_push(skb
, ETH1394_HLEN
);
749 eth
->h_proto
= htons(type
);
751 if (dev
->flags
& (IFF_LOOPBACK
|IFF_NOARP
)) {
752 memset(eth
->h_dest
, 0, dev
->addr_len
);
753 return(dev
->hard_header_len
);
757 memcpy(eth
->h_dest
,daddr
,dev
->addr_len
);
758 return dev
->hard_header_len
;
761 return -dev
->hard_header_len
;
766 /* Rebuild the faked MAC header. This is called after an ARP
767 * (or in future other address resolution) has completed on this
768 * sk_buff. We now let ARP fill in the other fields.
770 * This routine CANNOT use cached dst->neigh!
771 * Really, it is used only when dst->neigh is wrong.
773 static int ether1394_rebuild_header(struct sk_buff
*skb
)
775 struct eth1394hdr
*eth
= (struct eth1394hdr
*)skb
->data
;
776 struct net_device
*dev
= skb
->dev
;
778 switch (eth
->h_proto
) {
781 case __constant_htons(ETH_P_IP
):
782 return arp_find((unsigned char*)ð
->h_dest
, skb
);
785 ETH1394_PRINT(KERN_DEBUG
, dev
->name
,
786 "unable to resolve type %04x addresses.\n",
794 static int ether1394_header_parse(struct sk_buff
*skb
, unsigned char *haddr
)
796 struct net_device
*dev
= skb
->dev
;
797 memcpy(haddr
, dev
->dev_addr
, ETH1394_ALEN
);
802 static int ether1394_header_cache(struct neighbour
*neigh
, struct hh_cache
*hh
)
804 unsigned short type
= hh
->hh_type
;
805 struct eth1394hdr
*eth
= (struct eth1394hdr
*)(((u8
*)hh
->hh_data
) +
806 (16 - ETH1394_HLEN
));
807 struct net_device
*dev
= neigh
->dev
;
809 if (type
== __constant_htons(ETH_P_802_3
)) {
814 memcpy(eth
->h_dest
, neigh
->ha
, dev
->addr_len
);
816 hh
->hh_len
= ETH1394_HLEN
;
820 /* Called by Address Resolution module to notify changes in address. */
821 static void ether1394_header_cache_update(struct hh_cache
*hh
,
822 struct net_device
*dev
,
823 unsigned char * haddr
)
825 memcpy(((u8
*)hh
->hh_data
) + (16 - ETH1394_HLEN
), haddr
, dev
->addr_len
);
828 static int ether1394_mac_addr(struct net_device
*dev
, void *p
)
830 if (netif_running(dev
))
833 /* Not going to allow setting the MAC address, we really need to use
834 * the real one supplied by the hardware */
840 /******************************************
841 * Datagram reception code
842 ******************************************/
844 /* Copied from net/ethernet/eth.c */
845 static inline u16
ether1394_type_trans(struct sk_buff
*skb
,
846 struct net_device
*dev
)
848 struct eth1394hdr
*eth
;
851 skb
->mac
.raw
= skb
->data
;
852 skb_pull (skb
, ETH1394_HLEN
);
853 eth
= eth1394_hdr(skb
);
855 if (*eth
->h_dest
& 1) {
856 if (memcmp(eth
->h_dest
, dev
->broadcast
, dev
->addr_len
)==0)
857 skb
->pkt_type
= PACKET_BROADCAST
;
860 skb
->pkt_type
= PACKET_MULTICAST
;
863 if (memcmp(eth
->h_dest
, dev
->dev_addr
, dev
->addr_len
))
864 skb
->pkt_type
= PACKET_OTHERHOST
;
867 if (ntohs (eth
->h_proto
) >= 1536)
872 if (*(unsigned short *)rawp
== 0xFFFF)
873 return htons (ETH_P_802_3
);
875 return htons (ETH_P_802_2
);
878 /* Parse an encapsulated IP1394 header into an ethernet frame packet.
879 * We also perform ARP translation here, if need be. */
880 static inline u16
ether1394_parse_encap(struct sk_buff
*skb
,
881 struct net_device
*dev
,
882 nodeid_t srcid
, nodeid_t destid
,
885 struct eth1394_priv
*priv
= dev
->priv
;
887 unsigned short ret
= 0;
889 /* Setup our hw addresses. We use these to build the
890 * ethernet header. */
891 if (destid
== (LOCAL_BUS
| ALL_NODES
))
892 dest_hw
= ~0ULL; /* broadcast */
894 dest_hw
= cpu_to_be64((((u64
)priv
->host
->csr
.guid_hi
) << 32) |
895 priv
->host
->csr
.guid_lo
);
897 /* If this is an ARP packet, convert it. First, we want to make
898 * use of some of the fields, since they tell us a little bit
899 * about the sending machine. */
900 if (ether_type
== __constant_htons (ETH_P_ARP
)) {
901 struct eth1394_arp
*arp1394
= (struct eth1394_arp
*)skb
->data
;
902 struct arphdr
*arp
= (struct arphdr
*)skb
->data
;
903 unsigned char *arp_ptr
= (unsigned char *)(arp
+ 1);
904 u64 fifo_addr
= (u64
)ntohs(arp1394
->fifo_hi
) << 32 |
905 ntohl(arp1394
->fifo_lo
);
906 u8 max_rec
= min(priv
->host
->csr
.max_rec
,
907 (u8
)(arp1394
->max_rec
));
908 int sspd
= arp1394
->sspd
;
910 struct eth1394_node_ref
*node
;
911 struct eth1394_node_info
*node_info
;
913 /* Sanity check. MacOSX seems to be sending us 131 in this
914 * field (atleast on my Panther G5). Not sure why. */
915 if (sspd
> 5 || sspd
< 0)
918 maxpayload
= min(eth1394_speedto_maxpayload
[sspd
], (u16
)(1 << (max_rec
+ 1)));
920 node
= eth1394_find_node_guid(&priv
->ip_node_list
,
921 be64_to_cpu(arp1394
->s_uniq_id
));
926 node_info
= (struct eth1394_node_info
*)node
->ud
->device
.driver_data
;
928 /* Update our speed/payload/fifo_offset table */
929 node_info
->maxpayload
= maxpayload
;
930 node_info
->sspd
= sspd
;
931 node_info
->fifo
= fifo_addr
;
933 /* Now that we're done with the 1394 specific stuff, we'll
934 * need to alter some of the data. Believe it or not, all
935 * that needs to be done is sender_IP_address needs to be
936 * moved, the destination hardware address get stuffed
937 * in and the hardware address length set to 8.
939 * IMPORTANT: The code below overwrites 1394 specific data
940 * needed above so keep the munging of the data for the
941 * higher level IP stack last. */
944 arp_ptr
+= arp
->ar_hln
; /* skip over sender unique id */
945 *(u32
*)arp_ptr
= arp1394
->sip
; /* move sender IP addr */
946 arp_ptr
+= arp
->ar_pln
; /* skip over sender IP addr */
949 /* just set ARP req target unique ID to 0 */
950 *((u64
*)arp_ptr
) = 0;
952 *((u64
*)arp_ptr
) = *((u64
*)dev
->dev_addr
);
955 /* Now add the ethernet header. */
956 if (dev
->hard_header (skb
, dev
, __constant_ntohs (ether_type
),
957 &dest_hw
, NULL
, skb
->len
) >= 0)
958 ret
= ether1394_type_trans(skb
, dev
);
963 static inline int fragment_overlap(struct list_head
*frag_list
, int offset
, int len
)
965 struct fragment_info
*fi
;
967 list_for_each_entry(fi
, frag_list
, list
) {
968 if ( ! ((offset
> (fi
->offset
+ fi
->len
- 1)) ||
969 ((offset
+ len
- 1) < fi
->offset
)))
975 static inline struct list_head
*find_partial_datagram(struct list_head
*pdgl
, int dgl
)
977 struct partial_datagram
*pd
;
979 list_for_each_entry(pd
, pdgl
, list
) {
986 /* Assumes that new fragment does not overlap any existing fragments */
987 static inline int new_fragment(struct list_head
*frag_info
, int offset
, int len
)
989 struct list_head
*lh
;
990 struct fragment_info
*fi
, *fi2
, *new;
992 list_for_each(lh
, frag_info
) {
993 fi
= list_entry(lh
, struct fragment_info
, list
);
994 if ((fi
->offset
+ fi
->len
) == offset
) {
995 /* The new fragment can be tacked on to the end */
997 /* Did the new fragment plug a hole? */
998 fi2
= list_entry(lh
->next
, struct fragment_info
, list
);
999 if ((fi
->offset
+ fi
->len
) == fi2
->offset
) {
1000 /* glue fragments together */
1001 fi
->len
+= fi2
->len
;
1006 } else if ((offset
+ len
) == fi
->offset
) {
1007 /* The new fragment can be tacked on to the beginning */
1008 fi
->offset
= offset
;
1010 /* Did the new fragment plug a hole? */
1011 fi2
= list_entry(lh
->prev
, struct fragment_info
, list
);
1012 if ((fi2
->offset
+ fi2
->len
) == fi
->offset
) {
1013 /* glue fragments together */
1014 fi2
->len
+= fi
->len
;
1019 } else if (offset
> (fi
->offset
+ fi
->len
)) {
1021 } else if ((offset
+ len
) < fi
->offset
) {
1027 new = kmalloc(sizeof(struct fragment_info
), GFP_ATOMIC
);
1031 new->offset
= offset
;
1034 list_add(&new->list
, lh
);
1039 static inline int new_partial_datagram(struct net_device
*dev
,
1040 struct list_head
*pdgl
, int dgl
,
1041 int dg_size
, char *frag_buf
,
1042 int frag_off
, int frag_len
)
1044 struct partial_datagram
*new;
1046 new = kmalloc(sizeof(struct partial_datagram
), GFP_ATOMIC
);
1050 INIT_LIST_HEAD(&new->frag_info
);
1052 if (new_fragment(&new->frag_info
, frag_off
, frag_len
) < 0) {
1058 new->dg_size
= dg_size
;
1060 new->skb
= dev_alloc_skb(dg_size
+ dev
->hard_header_len
+ 15);
1062 struct fragment_info
*fi
= list_entry(new->frag_info
.next
,
1063 struct fragment_info
,
1070 skb_reserve(new->skb
, (dev
->hard_header_len
+ 15) & ~15);
1071 new->pbuf
= skb_put(new->skb
, dg_size
);
1072 memcpy(new->pbuf
+ frag_off
, frag_buf
, frag_len
);
1074 list_add(&new->list
, pdgl
);
1079 static inline int update_partial_datagram(struct list_head
*pdgl
, struct list_head
*lh
,
1080 char *frag_buf
, int frag_off
, int frag_len
)
1082 struct partial_datagram
*pd
= list_entry(lh
, struct partial_datagram
, list
);
1084 if (new_fragment(&pd
->frag_info
, frag_off
, frag_len
) < 0) {
1088 memcpy(pd
->pbuf
+ frag_off
, frag_buf
, frag_len
);
1090 /* Move list entry to beginnig of list so that oldest partial
1091 * datagrams percolate to the end of the list */
1098 static inline int is_datagram_complete(struct list_head
*lh
, int dg_size
)
1100 struct partial_datagram
*pd
= list_entry(lh
, struct partial_datagram
, list
);
1101 struct fragment_info
*fi
= list_entry(pd
->frag_info
.next
,
1102 struct fragment_info
, list
);
1104 return (fi
->len
== dg_size
);
1107 /* Packet reception. We convert the IP1394 encapsulation header to an
1108 * ethernet header, and fill it with some of our other fields. This is
1109 * an incoming packet from the 1394 bus. */
1110 static int ether1394_data_handler(struct net_device
*dev
, int srcid
, int destid
,
1113 struct sk_buff
*skb
;
1114 unsigned long flags
;
1115 struct eth1394_priv
*priv
= (struct eth1394_priv
*)dev
->priv
;
1116 union eth1394_hdr
*hdr
= (union eth1394_hdr
*)buf
;
1117 u16 ether_type
= 0; /* initialized to clear warning */
1119 struct unit_directory
*ud
= priv
->ud_list
[NODEID_TO_NODE(srcid
)];
1120 struct eth1394_node_info
*node_info
;
1123 struct eth1394_node_ref
*node
;
1124 node
= eth1394_find_node_nodeid(&priv
->ip_node_list
, srcid
);
1126 HPSB_PRINT(KERN_ERR
, "ether1394 rx: sender nodeid "
1127 "lookup failure: " NODE_BUS_FMT
,
1128 NODE_BUS_ARGS(priv
->host
, srcid
));
1129 priv
->stats
.rx_dropped
++;
1134 priv
->ud_list
[NODEID_TO_NODE(srcid
)] = ud
;
1137 node_info
= (struct eth1394_node_info
*)ud
->device
.driver_data
;
1139 /* First, did we receive a fragmented or unfragmented datagram? */
1140 hdr
->words
.word1
= ntohs(hdr
->words
.word1
);
1142 hdr_len
= hdr_type_len
[hdr
->common
.lf
];
1144 if (hdr
->common
.lf
== ETH1394_HDR_LF_UF
) {
1145 /* An unfragmented datagram has been received by the ieee1394
1146 * bus. Build an skbuff around it so we can pass it to the
1147 * high level network layer. */
1149 skb
= dev_alloc_skb(len
+ dev
->hard_header_len
+ 15);
1151 HPSB_PRINT (KERN_ERR
, "ether1394 rx: low on mem\n");
1152 priv
->stats
.rx_dropped
++;
1155 skb_reserve(skb
, (dev
->hard_header_len
+ 15) & ~15);
1156 memcpy(skb_put(skb
, len
- hdr_len
), buf
+ hdr_len
, len
- hdr_len
);
1157 ether_type
= hdr
->uf
.ether_type
;
1159 /* A datagram fragment has been received, now the fun begins. */
1161 struct list_head
*pdgl
, *lh
;
1162 struct partial_datagram
*pd
;
1164 int fg_len
= len
- hdr_len
;
1168 struct pdg_list
*pdg
= &(node_info
->pdg
);
1170 hdr
->words
.word3
= ntohs(hdr
->words
.word3
);
1171 /* The 4th header word is reserved so no need to do ntohs() */
1173 if (hdr
->common
.lf
== ETH1394_HDR_LF_FF
) {
1174 ether_type
= hdr
->ff
.ether_type
;
1176 dg_size
= hdr
->ff
.dg_size
+ 1;
1179 hdr
->words
.word2
= ntohs(hdr
->words
.word2
);
1181 dg_size
= hdr
->sf
.dg_size
+ 1;
1182 fg_off
= hdr
->sf
.fg_off
;
1184 spin_lock_irqsave(&pdg
->lock
, flags
);
1186 pdgl
= &(pdg
->list
);
1187 lh
= find_partial_datagram(pdgl
, dgl
);
1190 if (pdg
->sz
== max_partial_datagrams
) {
1191 /* remove the oldest */
1192 purge_partial_datagram(pdgl
->prev
);
1196 retval
= new_partial_datagram(dev
, pdgl
, dgl
, dg_size
,
1197 buf
+ hdr_len
, fg_off
,
1200 spin_unlock_irqrestore(&pdg
->lock
, flags
);
1204 lh
= find_partial_datagram(pdgl
, dgl
);
1206 struct partial_datagram
*pd
;
1208 pd
= list_entry(lh
, struct partial_datagram
, list
);
1210 if (fragment_overlap(&pd
->frag_info
, fg_off
, fg_len
)) {
1211 /* Overlapping fragments, obliterate old
1212 * datagram and start new one. */
1213 purge_partial_datagram(lh
);
1214 retval
= new_partial_datagram(dev
, pdgl
, dgl
,
1220 spin_unlock_irqrestore(&pdg
->lock
, flags
);
1224 retval
= update_partial_datagram(pdgl
, lh
,
1228 /* Couldn't save off fragment anyway
1229 * so might as well obliterate the
1231 purge_partial_datagram(lh
);
1233 spin_unlock_irqrestore(&pdg
->lock
, flags
);
1236 } /* fragment overlap */
1237 } /* new datagram or add to existing one */
1239 pd
= list_entry(lh
, struct partial_datagram
, list
);
1241 if (hdr
->common
.lf
== ETH1394_HDR_LF_FF
) {
1242 pd
->ether_type
= ether_type
;
1245 if (is_datagram_complete(lh
, dg_size
)) {
1246 ether_type
= pd
->ether_type
;
1248 skb
= skb_get(pd
->skb
);
1249 purge_partial_datagram(lh
);
1250 spin_unlock_irqrestore(&pdg
->lock
, flags
);
1252 /* Datagram is not complete, we're done for the
1254 spin_unlock_irqrestore(&pdg
->lock
, flags
);
1257 } /* unframgented datagram or fragmented one */
1259 /* Write metadata, and then pass to the receive level */
1261 skb
->ip_summed
= CHECKSUM_UNNECESSARY
; /* don't check it */
1263 /* Parse the encapsulation header. This actually does the job of
1264 * converting to an ethernet frame header, aswell as arp
1265 * conversion if needed. ARP conversion is easier in this
1266 * direction, since we are using ethernet as our backend. */
1267 skb
->protocol
= ether1394_parse_encap(skb
, dev
, srcid
, destid
,
1271 spin_lock_irqsave(&priv
->lock
, flags
);
1272 if (!skb
->protocol
) {
1273 priv
->stats
.rx_errors
++;
1274 priv
->stats
.rx_dropped
++;
1275 dev_kfree_skb_any(skb
);
1279 if (netif_rx(skb
) == NET_RX_DROP
) {
1280 priv
->stats
.rx_errors
++;
1281 priv
->stats
.rx_dropped
++;
1286 priv
->stats
.rx_packets
++;
1287 priv
->stats
.rx_bytes
+= skb
->len
;
1290 if (netif_queue_stopped(dev
))
1291 netif_wake_queue(dev
);
1292 spin_unlock_irqrestore(&priv
->lock
, flags
);
1294 dev
->last_rx
= jiffies
;
1299 static int ether1394_write(struct hpsb_host
*host
, int srcid
, int destid
,
1300 quadlet_t
*data
, u64 addr
, size_t len
, u16 flags
)
1302 struct eth1394_host_info
*hi
;
1304 hi
= hpsb_get_hostinfo(ð1394_highlevel
, host
);
1306 ETH1394_PRINT_G(KERN_ERR
, "Could not find net device for host %s\n",
1307 host
->driver
->name
);
1308 return RCODE_ADDRESS_ERROR
;
1311 if (ether1394_data_handler(hi
->dev
, srcid
, destid
, (char*)data
, len
))
1312 return RCODE_ADDRESS_ERROR
;
1314 return RCODE_COMPLETE
;
1317 static void ether1394_iso(struct hpsb_iso
*iso
)
1321 struct eth1394_host_info
*hi
;
1322 struct net_device
*dev
;
1323 struct eth1394_priv
*priv
;
1330 hi
= hpsb_get_hostinfo(ð1394_highlevel
, iso
->host
);
1332 ETH1394_PRINT_G(KERN_ERR
, "Could not find net device for host %s\n",
1333 iso
->host
->driver
->name
);
1339 nready
= hpsb_iso_n_ready(iso
);
1340 for (i
= 0; i
< nready
; i
++) {
1341 struct hpsb_iso_packet_info
*info
=
1342 &iso
->infos
[(iso
->first_packet
+ i
) % iso
->buf_packets
];
1343 data
= (quadlet_t
*) (iso
->data_buf
.kvirt
+ info
->offset
);
1345 /* skip over GASP header */
1346 buf
= (char *)data
+ 8;
1347 len
= info
->len
- 8;
1349 specifier_id
= (((be32_to_cpu(data
[0]) & 0xffff) << 8) |
1350 ((be32_to_cpu(data
[1]) & 0xff000000) >> 24));
1351 source_id
= be32_to_cpu(data
[0]) >> 16;
1353 priv
= (struct eth1394_priv
*)dev
->priv
;
1355 if (info
->channel
!= (iso
->host
->csr
.broadcast_channel
& 0x3f) ||
1356 specifier_id
!= ETHER1394_GASP_SPECIFIER_ID
) {
1357 /* This packet is not for us */
1360 ether1394_data_handler(dev
, source_id
, LOCAL_BUS
| ALL_NODES
,
1364 hpsb_iso_recv_release_packets(iso
, i
);
1366 dev
->last_rx
= jiffies
;
1369 /******************************************
1370 * Datagram transmission code
1371 ******************************************/
1373 /* Convert a standard ARP packet to 1394 ARP. The first 8 bytes (the entire
1374 * arphdr) is the same format as the ip1394 header, so they overlap. The rest
1375 * needs to be munged a bit. The remainder of the arphdr is formatted based
1376 * on hwaddr len and ipaddr len. We know what they'll be, so it's easy to
1379 * Now that the EUI is used for the hardware address all we need to do to make
1380 * this work for 1394 is to insert 2 quadlets that contain max_rec size,
1381 * speed, and unicast FIFO address information between the sender_unique_id
1382 * and the IP addresses.
1384 static inline void ether1394_arp_to_1394arp(struct sk_buff
*skb
,
1385 struct net_device
*dev
)
1387 struct eth1394_priv
*priv
= (struct eth1394_priv
*)(dev
->priv
);
1389 struct arphdr
*arp
= (struct arphdr
*)skb
->data
;
1390 unsigned char *arp_ptr
= (unsigned char *)(arp
+ 1);
1391 struct eth1394_arp
*arp1394
= (struct eth1394_arp
*)skb
->data
;
1393 /* Believe it or not, all that need to happen is sender IP get moved
1394 * and set hw_addr_len, max_rec, sspd, fifo_hi and fifo_lo. */
1395 arp1394
->hw_addr_len
= 16;
1396 arp1394
->sip
= *(u32
*)(arp_ptr
+ ETH1394_ALEN
);
1397 arp1394
->max_rec
= priv
->host
->csr
.max_rec
;
1398 arp1394
->sspd
= priv
->host
->csr
.lnk_spd
;
1399 arp1394
->fifo_hi
= htons (priv
->local_fifo
>> 32);
1400 arp1394
->fifo_lo
= htonl (priv
->local_fifo
& ~0x0);
1405 /* We need to encapsulate the standard header with our own. We use the
1406 * ethernet header's proto for our own. */
1407 static inline unsigned int ether1394_encapsulate_prep(unsigned int max_payload
,
1409 union eth1394_hdr
*hdr
,
1410 u16 dg_size
, u16 dgl
)
1412 unsigned int adj_max_payload
= max_payload
- hdr_type_len
[ETH1394_HDR_LF_UF
];
1414 /* Does it all fit in one packet? */
1415 if (dg_size
<= adj_max_payload
) {
1416 hdr
->uf
.lf
= ETH1394_HDR_LF_UF
;
1417 hdr
->uf
.ether_type
= proto
;
1419 hdr
->ff
.lf
= ETH1394_HDR_LF_FF
;
1420 hdr
->ff
.ether_type
= proto
;
1421 hdr
->ff
.dg_size
= dg_size
- 1;
1423 adj_max_payload
= max_payload
- hdr_type_len
[ETH1394_HDR_LF_FF
];
1425 return((dg_size
+ (adj_max_payload
- 1)) / adj_max_payload
);
1428 static inline unsigned int ether1394_encapsulate(struct sk_buff
*skb
,
1429 unsigned int max_payload
,
1430 union eth1394_hdr
*hdr
)
1432 union eth1394_hdr
*bufhdr
;
1433 int ftype
= hdr
->common
.lf
;
1434 int hdrsz
= hdr_type_len
[ftype
];
1435 unsigned int adj_max_payload
= max_payload
- hdrsz
;
1438 case ETH1394_HDR_LF_UF
:
1439 bufhdr
= (union eth1394_hdr
*)skb_push(skb
, hdrsz
);
1440 bufhdr
->words
.word1
= htons(hdr
->words
.word1
);
1441 bufhdr
->words
.word2
= hdr
->words
.word2
;
1444 case ETH1394_HDR_LF_FF
:
1445 bufhdr
= (union eth1394_hdr
*)skb_push(skb
, hdrsz
);
1446 bufhdr
->words
.word1
= htons(hdr
->words
.word1
);
1447 bufhdr
->words
.word2
= hdr
->words
.word2
;
1448 bufhdr
->words
.word3
= htons(hdr
->words
.word3
);
1449 bufhdr
->words
.word4
= 0;
1451 /* Set frag type here for future interior fragments */
1452 hdr
->common
.lf
= ETH1394_HDR_LF_IF
;
1457 hdr
->sf
.fg_off
+= adj_max_payload
;
1458 bufhdr
= (union eth1394_hdr
*)skb_pull(skb
, adj_max_payload
);
1459 if (max_payload
>= skb
->len
)
1460 hdr
->common
.lf
= ETH1394_HDR_LF_LF
;
1461 bufhdr
->words
.word1
= htons(hdr
->words
.word1
);
1462 bufhdr
->words
.word2
= htons(hdr
->words
.word2
);
1463 bufhdr
->words
.word3
= htons(hdr
->words
.word3
);
1464 bufhdr
->words
.word4
= 0;
1467 return min(max_payload
, skb
->len
);
1470 static inline struct hpsb_packet
*ether1394_alloc_common_packet(struct hpsb_host
*host
)
1472 struct hpsb_packet
*p
;
1474 p
= hpsb_alloc_packet(0);
1477 p
->generation
= get_hpsb_generation(host
);
1478 p
->type
= hpsb_async
;
1483 static inline int ether1394_prep_write_packet(struct hpsb_packet
*p
,
1484 struct hpsb_host
*host
,
1485 nodeid_t node
, u64 addr
,
1486 void * data
, int tx_len
)
1491 p
->tcode
= TCODE_WRITEB
;
1492 p
->header
[1] = (host
->node_id
<< 16) | (addr
>> 32);
1493 p
->header
[2] = addr
& 0xffffffff;
1495 p
->header_size
= 16;
1496 p
->expect_response
= 1;
1498 if (hpsb_get_tlabel(p
)) {
1499 ETH1394_PRINT_G(KERN_ERR
, "No more tlabels left while sending "
1500 "to node " NODE_BUS_FMT
"\n", NODE_BUS_ARGS(host
, node
));
1503 p
->header
[0] = (p
->node_id
<< 16) | (p
->tlabel
<< 10)
1504 | (1 << 8) | (TCODE_WRITEB
<< 4);
1506 p
->header
[3] = tx_len
<< 16;
1507 p
->data_size
= (tx_len
+ 3) & ~3;
1508 p
->data
= (quadlet_t
*)data
;
1513 static inline void ether1394_prep_gasp_packet(struct hpsb_packet
*p
,
1514 struct eth1394_priv
*priv
,
1515 struct sk_buff
*skb
, int length
)
1518 p
->tcode
= TCODE_STREAM_DATA
;
1520 p
->header
[0] = (length
<< 16) | (3 << 14)
1521 | ((priv
->broadcast_channel
) << 8)
1522 | (TCODE_STREAM_DATA
<< 4);
1523 p
->data_size
= length
;
1524 p
->data
= ((quadlet_t
*)skb
->data
) - 2;
1525 p
->data
[0] = cpu_to_be32((priv
->host
->node_id
<< 16) |
1526 ETHER1394_GASP_SPECIFIER_ID_HI
);
1527 p
->data
[1] = __constant_cpu_to_be32((ETHER1394_GASP_SPECIFIER_ID_LO
<< 24) |
1528 ETHER1394_GASP_VERSION
);
1530 /* Setting the node id to ALL_NODES (not LOCAL_BUS | ALL_NODES)
1531 * prevents hpsb_send_packet() from setting the speed to an arbitrary
1532 * value based on packet->node_id if packet->node_id is not set. */
1533 p
->node_id
= ALL_NODES
;
1534 p
->speed_code
= priv
->bc_sspd
;
1537 static inline void ether1394_free_packet(struct hpsb_packet
*packet
)
1539 if (packet
->tcode
!= TCODE_STREAM_DATA
)
1540 hpsb_free_tlabel(packet
);
1541 hpsb_free_packet(packet
);
1544 static void ether1394_complete_cb(void *__ptask
);
1546 static int ether1394_send_packet(struct packet_task
*ptask
, unsigned int tx_len
)
1548 struct eth1394_priv
*priv
= ptask
->priv
;
1549 struct hpsb_packet
*packet
= NULL
;
1551 packet
= ether1394_alloc_common_packet(priv
->host
);
1555 if (ptask
->tx_type
== ETH1394_GASP
) {
1556 int length
= tx_len
+ (2 * sizeof(quadlet_t
));
1558 ether1394_prep_gasp_packet(packet
, priv
, ptask
->skb
, length
);
1559 } else if (ether1394_prep_write_packet(packet
, priv
->host
,
1561 ptask
->addr
, ptask
->skb
->data
,
1563 hpsb_free_packet(packet
);
1567 ptask
->packet
= packet
;
1568 hpsb_set_packet_complete_task(ptask
->packet
, ether1394_complete_cb
,
1571 if (hpsb_send_packet(packet
) < 0) {
1572 ether1394_free_packet(packet
);
1580 /* Task function to be run when a datagram transmission is completed */
1581 static inline void ether1394_dg_complete(struct packet_task
*ptask
, int fail
)
1583 struct sk_buff
*skb
= ptask
->skb
;
1584 struct net_device
*dev
= skb
->dev
;
1585 struct eth1394_priv
*priv
= dev
->priv
;
1586 unsigned long flags
;
1589 spin_lock_irqsave(&priv
->lock
, flags
);
1591 priv
->stats
.tx_dropped
++;
1592 priv
->stats
.tx_errors
++;
1594 priv
->stats
.tx_bytes
+= skb
->len
;
1595 priv
->stats
.tx_packets
++;
1597 spin_unlock_irqrestore(&priv
->lock
, flags
);
1599 dev_kfree_skb_any(skb
);
1600 kmem_cache_free(packet_task_cache
, ptask
);
1604 /* Callback for when a packet has been sent and the status of that packet is
1606 static void ether1394_complete_cb(void *__ptask
)
1608 struct packet_task
*ptask
= (struct packet_task
*)__ptask
;
1609 struct hpsb_packet
*packet
= ptask
->packet
;
1612 if (packet
->tcode
!= TCODE_STREAM_DATA
)
1613 fail
= hpsb_packet_success(packet
);
1615 ether1394_free_packet(packet
);
1617 ptask
->outstanding_pkts
--;
1618 if (ptask
->outstanding_pkts
> 0 && !fail
) {
1621 /* Add the encapsulation header to the fragment */
1622 tx_len
= ether1394_encapsulate(ptask
->skb
, ptask
->max_payload
,
1624 if (ether1394_send_packet(ptask
, tx_len
))
1625 ether1394_dg_complete(ptask
, 1);
1627 ether1394_dg_complete(ptask
, fail
);
1633 /* Transmit a packet (called by kernel) */
1634 static int ether1394_tx (struct sk_buff
*skb
, struct net_device
*dev
)
1636 int kmflags
= in_interrupt() ? GFP_ATOMIC
: GFP_KERNEL
;
1637 struct eth1394hdr
*eth
;
1638 struct eth1394_priv
*priv
= dev
->priv
;
1640 unsigned long flags
;
1642 eth1394_tx_type tx_type
;
1644 unsigned int tx_len
;
1645 unsigned int max_payload
;
1648 struct packet_task
*ptask
;
1649 struct eth1394_node_ref
*node
;
1650 struct eth1394_node_info
*node_info
= NULL
;
1652 ptask
= kmem_cache_alloc(packet_task_cache
, kmflags
);
1653 if (ptask
== NULL
) {
1658 /* XXX Ignore this for now. Noticed that when MacOSX is the IRM,
1659 * it does not set our validity bit. We need to compensate for
1660 * that somewhere else, but not in eth1394. */
1662 if ((priv
->host
->csr
.broadcast_channel
& 0xc0000000) != 0xc0000000) {
1668 if ((skb
= skb_share_check (skb
, kmflags
)) == NULL
) {
1673 /* Get rid of the fake eth1394 header, but save a pointer */
1674 eth
= (struct eth1394hdr
*)skb
->data
;
1675 skb_pull(skb
, ETH1394_HLEN
);
1677 proto
= eth
->h_proto
;
1680 /* Set the transmission type for the packet. ARP packets and IP
1681 * broadcast packets are sent via GASP. */
1682 if (memcmp(eth
->h_dest
, dev
->broadcast
, ETH1394_ALEN
) == 0 ||
1683 proto
== __constant_htons(ETH_P_ARP
) ||
1684 (proto
== __constant_htons(ETH_P_IP
) &&
1685 IN_MULTICAST(__constant_ntohl(skb
->nh
.iph
->daddr
)))) {
1686 tx_type
= ETH1394_GASP
;
1687 dest_node
= LOCAL_BUS
| ALL_NODES
;
1688 max_payload
= priv
->bc_maxpayload
- ETHER1394_GASP_OVERHEAD
;
1689 BUG_ON(max_payload
< (512 - ETHER1394_GASP_OVERHEAD
));
1691 if (max_payload
< dg_size
+ hdr_type_len
[ETH1394_HDR_LF_UF
])
1694 node
= eth1394_find_node_guid(&priv
->ip_node_list
,
1695 be64_to_cpu(*(u64
*)eth
->h_dest
));
1700 node_info
= (struct eth1394_node_info
*)node
->ud
->device
.driver_data
;
1701 if (node_info
->fifo
== ETHER1394_INVALID_ADDR
) {
1706 dest_node
= node
->ud
->ne
->nodeid
;
1707 max_payload
= node_info
->maxpayload
;
1708 BUG_ON(max_payload
< (512 - ETHER1394_GASP_OVERHEAD
));
1710 dgl
= node_info
->dgl
;
1711 if (max_payload
< dg_size
+ hdr_type_len
[ETH1394_HDR_LF_UF
])
1713 tx_type
= ETH1394_WRREQ
;
1716 /* If this is an ARP packet, convert it */
1717 if (proto
== __constant_htons (ETH_P_ARP
))
1718 ether1394_arp_to_1394arp (skb
, dev
);
1720 ptask
->hdr
.words
.word1
= 0;
1721 ptask
->hdr
.words
.word2
= 0;
1722 ptask
->hdr
.words
.word3
= 0;
1723 ptask
->hdr
.words
.word4
= 0;
1726 ptask
->tx_type
= tx_type
;
1728 if (tx_type
!= ETH1394_GASP
) {
1731 spin_lock_irqsave(&priv
->lock
, flags
);
1732 addr
= node_info
->fifo
;
1733 spin_unlock_irqrestore(&priv
->lock
, flags
);
1736 ptask
->dest_node
= dest_node
;
1739 ptask
->tx_type
= tx_type
;
1740 ptask
->max_payload
= max_payload
;
1741 ptask
->outstanding_pkts
= ether1394_encapsulate_prep(max_payload
, proto
,
1742 &ptask
->hdr
, dg_size
,
1745 /* Add the encapsulation header to the fragment */
1746 tx_len
= ether1394_encapsulate(skb
, max_payload
, &ptask
->hdr
);
1747 dev
->trans_start
= jiffies
;
1748 if (ether1394_send_packet(ptask
, tx_len
))
1751 netif_wake_queue(dev
);
1755 kmem_cache_free(packet_task_cache
, ptask
);
1760 spin_lock_irqsave (&priv
->lock
, flags
);
1761 priv
->stats
.tx_dropped
++;
1762 priv
->stats
.tx_errors
++;
1763 spin_unlock_irqrestore (&priv
->lock
, flags
);
1765 if (netif_queue_stopped(dev
))
1766 netif_wake_queue(dev
);
1768 return 0; /* returning non-zero causes serious problems */
1771 static int ether1394_do_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
)
1775 return ether1394_ethtool_ioctl(dev
, ifr
->ifr_data
);
1777 case SIOCGMIIPHY
: /* Get address of MII PHY in use. */
1778 case SIOCGMIIREG
: /* Read MII PHY register. */
1779 case SIOCSMIIREG
: /* Write MII PHY register. */
1787 static int ether1394_ethtool_ioctl(struct net_device
*dev
, void __user
*useraddr
)
1791 if (get_user(ethcmd
, (u32 __user
*)useraddr
))
1795 case ETHTOOL_GDRVINFO
: {
1796 struct ethtool_drvinfo info
= { ETHTOOL_GDRVINFO
};
1797 strcpy (info
.driver
, driver_name
);
1798 strcpy (info
.version
, "$Rev: 1224 $");
1799 /* FIXME XXX provide sane businfo */
1800 strcpy (info
.bus_info
, "ieee1394");
1801 if (copy_to_user (useraddr
, &info
, sizeof (info
)))
1807 case ETHTOOL_NWAY_RST
:
1809 case ETHTOOL_GMSGLVL
:
1810 case ETHTOOL_SMSGLVL
:
1819 static int __init
ether1394_init_module (void)
1821 packet_task_cache
= kmem_cache_create("packet_task", sizeof(struct packet_task
),
1824 /* Register ourselves as a highlevel driver */
1825 hpsb_register_highlevel(ð1394_highlevel
);
1827 return hpsb_register_protocol(ð1394_proto_driver
);
1830 static void __exit
ether1394_exit_module (void)
1832 hpsb_unregister_protocol(ð1394_proto_driver
);
1833 hpsb_unregister_highlevel(ð1394_highlevel
);
1834 kmem_cache_destroy(packet_task_cache
);
1837 module_init(ether1394_init_module
);
1838 module_exit(ether1394_exit_module
);