2 * eth1394.c -- IPv4 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.
26 * This driver intends to support RFC 2734, which describes a method for
27 * transporting IPv4 datagrams over IEEE-1394 serial busses.
31 * - Add MCAP. Limited Multicast exists only to 224.0.0.1 and 224.0.0.2.
33 * Non-RFC 2734 related:
34 * - Handle fragmented skb's coming from the networking layer.
35 * - Move generic GASP reception to core 1394 code
36 * - Convert kmalloc/kfree for link fragments to use kmem_cache_* instead
37 * - Stability improvements
38 * - Performance enhancements
39 * - Consider garbage collecting old partial datagrams after X amount of time
42 #include <linux/module.h>
44 #include <linux/kernel.h>
45 #include <linux/slab.h>
46 #include <linux/errno.h>
47 #include <linux/types.h>
48 #include <linux/delay.h>
49 #include <linux/init.h>
50 #include <linux/workqueue.h>
52 #include <linux/netdevice.h>
53 #include <linux/inetdevice.h>
54 #include <linux/if_arp.h>
55 #include <linux/if_ether.h>
58 #include <linux/tcp.h>
59 #include <linux/skbuff.h>
60 #include <linux/bitops.h>
61 #include <linux/ethtool.h>
62 #include <asm/uaccess.h>
63 #include <asm/delay.h>
64 #include <asm/unaligned.h>
67 #include "config_roms.h"
70 #include "highlevel.h"
72 #include "ieee1394_core.h"
73 #include "ieee1394_hotplug.h"
74 #include "ieee1394_transactions.h"
75 #include "ieee1394_types.h"
79 #define ETH1394_PRINT_G(level, fmt, args...) \
80 printk(level "%s: " fmt, driver_name, ## args)
82 #define ETH1394_PRINT(level, dev_name, fmt, args...) \
83 printk(level "%s: %s: " fmt, driver_name, dev_name, ## args)
85 struct fragment_info
{
86 struct list_head list
;
91 struct partial_datagram
{
92 struct list_head list
;
98 struct list_head frag_info
;
102 struct list_head list
; /* partial datagram list per node */
103 unsigned int sz
; /* partial datagram list size per node */
104 spinlock_t lock
; /* partial datagram lock */
107 struct eth1394_host_info
{
108 struct hpsb_host
*host
;
109 struct net_device
*dev
;
112 struct eth1394_node_ref
{
113 struct unit_directory
*ud
;
114 struct list_head list
;
117 struct eth1394_node_info
{
118 u16 maxpayload
; /* max payload */
119 u8 sspd
; /* max speed */
120 u64 fifo
; /* FIFO address */
121 struct pdg_list pdg
; /* partial RX datagram lists */
122 int dgl
; /* outgoing datagram label */
125 static const char driver_name
[] = "eth1394";
127 static struct kmem_cache
*packet_task_cache
;
129 static struct hpsb_highlevel eth1394_highlevel
;
131 /* Use common.lf to determine header len */
132 static const int hdr_type_len
[] = {
133 sizeof(struct eth1394_uf_hdr
),
134 sizeof(struct eth1394_ff_hdr
),
135 sizeof(struct eth1394_sf_hdr
),
136 sizeof(struct eth1394_sf_hdr
)
139 static const u16 eth1394_speedto_maxpayload
[] = {
140 /* S100, S200, S400, S800, S1600, S3200 */
141 512, 1024, 2048, 4096, 4096, 4096
144 MODULE_AUTHOR("Ben Collins (bcollins@debian.org)");
145 MODULE_DESCRIPTION("IEEE 1394 IPv4 Driver (IPv4-over-1394 as per RFC 2734)");
146 MODULE_LICENSE("GPL");
149 * The max_partial_datagrams parameter is the maximum number of fragmented
150 * datagrams per node that eth1394 will keep in memory. Providing an upper
151 * bound allows us to limit the amount of memory that partial datagrams
152 * consume in the event that some partial datagrams are never completed.
154 static int max_partial_datagrams
= 25;
155 module_param(max_partial_datagrams
, int, S_IRUGO
| S_IWUSR
);
156 MODULE_PARM_DESC(max_partial_datagrams
,
157 "Maximum number of partially received fragmented datagrams "
161 static int ether1394_header(struct sk_buff
*skb
, struct net_device
*dev
,
162 unsigned short type
, const void *daddr
,
163 const void *saddr
, unsigned len
);
164 static int ether1394_rebuild_header(struct sk_buff
*skb
);
165 static int ether1394_header_parse(const struct sk_buff
*skb
,
166 unsigned char *haddr
);
167 static int ether1394_header_cache(const struct neighbour
*neigh
,
168 struct hh_cache
*hh
);
169 static void ether1394_header_cache_update(struct hh_cache
*hh
,
170 const struct net_device
*dev
,
171 const unsigned char *haddr
);
172 static int ether1394_tx(struct sk_buff
*skb
, struct net_device
*dev
);
173 static void ether1394_iso(struct hpsb_iso
*iso
);
175 static struct ethtool_ops ethtool_ops
;
177 static int ether1394_write(struct hpsb_host
*host
, int srcid
, int destid
,
178 quadlet_t
*data
, u64 addr
, size_t len
, u16 flags
);
179 static void ether1394_add_host(struct hpsb_host
*host
);
180 static void ether1394_remove_host(struct hpsb_host
*host
);
181 static void ether1394_host_reset(struct hpsb_host
*host
);
183 /* Function for incoming 1394 packets */
184 static struct hpsb_address_ops addr_ops
= {
185 .write
= ether1394_write
,
188 /* Ieee1394 highlevel driver functions */
189 static struct hpsb_highlevel eth1394_highlevel
= {
191 .add_host
= ether1394_add_host
,
192 .remove_host
= ether1394_remove_host
,
193 .host_reset
= ether1394_host_reset
,
196 static int ether1394_recv_init(struct eth1394_priv
*priv
)
198 unsigned int iso_buf_size
;
200 /* FIXME: rawiso limits us to PAGE_SIZE */
201 iso_buf_size
= min((unsigned int)PAGE_SIZE
,
202 2 * (1U << (priv
->host
->csr
.max_rec
+ 1)));
204 priv
->iso
= hpsb_iso_recv_init(priv
->host
,
205 ETHER1394_GASP_BUFFERS
* iso_buf_size
,
206 ETHER1394_GASP_BUFFERS
,
207 priv
->broadcast_channel
,
208 HPSB_ISO_DMA_PACKET_PER_BUFFER
,
210 if (priv
->iso
== NULL
) {
211 ETH1394_PRINT_G(KERN_ERR
, "Failed to allocate IR context\n");
212 priv
->bc_state
= ETHER1394_BC_ERROR
;
216 if (hpsb_iso_recv_start(priv
->iso
, -1, (1 << 3), -1) < 0)
217 priv
->bc_state
= ETHER1394_BC_STOPPED
;
219 priv
->bc_state
= ETHER1394_BC_RUNNING
;
223 /* This is called after an "ifup" */
224 static int ether1394_open(struct net_device
*dev
)
226 struct eth1394_priv
*priv
= netdev_priv(dev
);
229 if (priv
->bc_state
== ETHER1394_BC_ERROR
) {
230 ret
= ether1394_recv_init(priv
);
234 netif_start_queue(dev
);
238 /* This is called after an "ifdown" */
239 static int ether1394_stop(struct net_device
*dev
)
241 /* flush priv->wake */
242 flush_scheduled_work();
244 netif_stop_queue(dev
);
248 /* Return statistics to the caller */
249 static struct net_device_stats
*ether1394_stats(struct net_device
*dev
)
251 return &(((struct eth1394_priv
*)netdev_priv(dev
))->stats
);
254 /* FIXME: What to do if we timeout? I think a host reset is probably in order,
255 * so that's what we do. Should we increment the stat counters too? */
256 static void ether1394_tx_timeout(struct net_device
*dev
)
258 struct hpsb_host
*host
=
259 ((struct eth1394_priv
*)netdev_priv(dev
))->host
;
261 ETH1394_PRINT(KERN_ERR
, dev
->name
, "Timeout, resetting host\n");
262 ether1394_host_reset(host
);
265 static inline int ether1394_max_mtu(struct hpsb_host
* host
)
267 return (1 << (host
->csr
.max_rec
+ 1))
268 - sizeof(union eth1394_hdr
) - ETHER1394_GASP_OVERHEAD
;
271 static int ether1394_change_mtu(struct net_device
*dev
, int new_mtu
)
278 max_mtu
= ether1394_max_mtu(
279 ((struct eth1394_priv
*)netdev_priv(dev
))->host
);
280 if (new_mtu
> max_mtu
) {
281 ETH1394_PRINT(KERN_INFO
, dev
->name
,
282 "Local node constrains MTU to %d\n", max_mtu
);
290 static void purge_partial_datagram(struct list_head
*old
)
292 struct partial_datagram
*pd
;
293 struct list_head
*lh
, *n
;
294 struct fragment_info
*fi
;
296 pd
= list_entry(old
, struct partial_datagram
, list
);
298 list_for_each_safe(lh
, n
, &pd
->frag_info
) {
299 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
;
341 list_for_each_entry(node
, inl
, list
)
342 if (node
->ud
->ne
->nodeid
== nodeid
)
348 static int eth1394_new_node(struct eth1394_host_info
*hi
,
349 struct unit_directory
*ud
)
351 struct eth1394_priv
*priv
;
352 struct eth1394_node_ref
*new_node
;
353 struct eth1394_node_info
*node_info
;
355 new_node
= kmalloc(sizeof(*new_node
), GFP_KERNEL
);
359 node_info
= kmalloc(sizeof(*node_info
), GFP_KERNEL
);
365 spin_lock_init(&node_info
->pdg
.lock
);
366 INIT_LIST_HEAD(&node_info
->pdg
.list
);
367 node_info
->pdg
.sz
= 0;
368 node_info
->fifo
= CSR1212_INVALID_ADDR_SPACE
;
370 ud
->device
.driver_data
= node_info
;
373 priv
= netdev_priv(hi
->dev
);
374 list_add_tail(&new_node
->list
, &priv
->ip_node_list
);
378 static int eth1394_probe(struct device
*dev
)
380 struct unit_directory
*ud
;
381 struct eth1394_host_info
*hi
;
383 ud
= container_of(dev
, struct unit_directory
, device
);
384 hi
= hpsb_get_hostinfo(ð1394_highlevel
, ud
->ne
->host
);
388 return eth1394_new_node(hi
, ud
);
391 static int eth1394_remove(struct device
*dev
)
393 struct unit_directory
*ud
;
394 struct eth1394_host_info
*hi
;
395 struct eth1394_priv
*priv
;
396 struct eth1394_node_ref
*old_node
;
397 struct eth1394_node_info
*node_info
;
398 struct list_head
*lh
, *n
;
401 ud
= container_of(dev
, struct unit_directory
, device
);
402 hi
= hpsb_get_hostinfo(ð1394_highlevel
, ud
->ne
->host
);
406 priv
= netdev_priv(hi
->dev
);
408 old_node
= eth1394_find_node(&priv
->ip_node_list
, ud
);
412 list_del(&old_node
->list
);
415 node_info
= (struct eth1394_node_info
*)ud
->device
.driver_data
;
417 spin_lock_irqsave(&node_info
->pdg
.lock
, flags
);
418 /* The partial datagram list should be empty, but we'll just
419 * make sure anyway... */
420 list_for_each_safe(lh
, n
, &node_info
->pdg
.list
)
421 purge_partial_datagram(lh
);
422 spin_unlock_irqrestore(&node_info
->pdg
.lock
, flags
);
425 ud
->device
.driver_data
= NULL
;
429 static int eth1394_update(struct unit_directory
*ud
)
431 struct eth1394_host_info
*hi
;
432 struct eth1394_priv
*priv
;
433 struct eth1394_node_ref
*node
;
435 hi
= hpsb_get_hostinfo(ð1394_highlevel
, ud
->ne
->host
);
439 priv
= netdev_priv(hi
->dev
);
440 node
= eth1394_find_node(&priv
->ip_node_list
, ud
);
444 return eth1394_new_node(hi
, ud
);
447 static struct ieee1394_device_id eth1394_id_table
[] = {
449 .match_flags
= (IEEE1394_MATCH_SPECIFIER_ID
|
450 IEEE1394_MATCH_VERSION
),
451 .specifier_id
= ETHER1394_GASP_SPECIFIER_ID
,
452 .version
= ETHER1394_GASP_VERSION
,
457 MODULE_DEVICE_TABLE(ieee1394
, eth1394_id_table
);
459 static struct hpsb_protocol_driver eth1394_proto_driver
= {
461 .id_table
= eth1394_id_table
,
462 .update
= eth1394_update
,
464 .probe
= eth1394_probe
,
465 .remove
= eth1394_remove
,
469 static void ether1394_reset_priv(struct net_device
*dev
, int set_mtu
)
473 struct eth1394_priv
*priv
= netdev_priv(dev
);
474 struct hpsb_host
*host
= priv
->host
;
475 u64 guid
= get_unaligned((u64
*)&(host
->csr
.rom
->bus_info_data
[3]));
476 int max_speed
= IEEE1394_SPEED_MAX
;
478 spin_lock_irqsave(&priv
->lock
, flags
);
480 memset(priv
->ud_list
, 0, sizeof(priv
->ud_list
));
481 priv
->bc_maxpayload
= 512;
483 /* Determine speed limit */
484 /* FIXME: This is broken for nodes with link speed < PHY speed,
485 * and it is suboptimal for S200B...S800B hardware.
486 * The result of nodemgr's speed probe should be used somehow. */
487 for (i
= 0; i
< host
->node_count
; i
++) {
488 /* take care of S100B...S400B PHY ports */
489 if (host
->speed
[i
] == SELFID_SPEED_UNKNOWN
) {
490 max_speed
= IEEE1394_SPEED_100
;
493 if (max_speed
> host
->speed
[i
])
494 max_speed
= host
->speed
[i
];
496 priv
->bc_sspd
= max_speed
;
499 /* Use the RFC 2734 default 1500 octets or the maximum payload
501 dev
->mtu
= min(1500, ether1394_max_mtu(host
));
503 /* Set our hardware address while we're at it */
504 memcpy(dev
->dev_addr
, &guid
, sizeof(u64
));
505 memset(dev
->broadcast
, 0xff, sizeof(u64
));
508 spin_unlock_irqrestore(&priv
->lock
, flags
);
511 static const struct header_ops ether1394_header_ops
= {
512 .create
= ether1394_header
,
513 .rebuild
= ether1394_rebuild_header
,
514 .cache
= ether1394_header_cache
,
515 .cache_update
= ether1394_header_cache_update
,
516 .parse
= ether1394_header_parse
,
519 static const struct net_device_ops ether1394_netdev_ops
= {
520 .ndo_open
= ether1394_open
,
521 .ndo_stop
= ether1394_stop
,
522 .ndo_start_xmit
= ether1394_tx
,
523 .ndo_get_stats
= ether1394_stats
,
524 .ndo_tx_timeout
= ether1394_tx_timeout
,
525 .ndo_change_mtu
= ether1394_change_mtu
,
528 static void ether1394_init_dev(struct net_device
*dev
)
531 dev
->header_ops
= ðer1394_header_ops
;
532 dev
->netdev_ops
= ðer1394_netdev_ops
;
534 SET_ETHTOOL_OPS(dev
, ðtool_ops
);
536 dev
->watchdog_timeo
= ETHER1394_TIMEOUT
;
537 dev
->flags
= IFF_BROADCAST
| IFF_MULTICAST
;
538 dev
->features
= NETIF_F_HIGHDMA
;
539 dev
->addr_len
= ETH1394_ALEN
;
540 dev
->hard_header_len
= ETH1394_HLEN
;
541 dev
->type
= ARPHRD_IEEE1394
;
543 /* FIXME: This value was copied from ether_setup(). Is it too much? */
544 dev
->tx_queue_len
= 1000;
548 * Wake the queue up after commonly encountered transmit failure conditions are
549 * hopefully over. Currently only tlabel exhaustion is accounted for.
551 static void ether1394_wake_queue(struct work_struct
*work
)
553 struct eth1394_priv
*priv
;
554 struct hpsb_packet
*packet
;
556 priv
= container_of(work
, struct eth1394_priv
, wake
);
557 packet
= hpsb_alloc_packet(0);
559 /* This is really bad, but unjam the queue anyway. */
563 packet
->host
= priv
->host
;
564 packet
->node_id
= priv
->wake_node
;
566 * A transaction label is all we really want. If we get one, it almost
567 * always means we can get a lot more because the ieee1394 core recycled
568 * a whole batch of tlabels, at last.
570 if (hpsb_get_tlabel(packet
) == 0)
571 hpsb_free_tlabel(packet
);
573 hpsb_free_packet(packet
);
575 netif_wake_queue(priv
->wake_dev
);
579 * This function is called every time a card is found. It is generally called
580 * when the module is installed. This is where we add all of our ethernet
581 * devices. One for each host.
583 static void ether1394_add_host(struct hpsb_host
*host
)
585 struct eth1394_host_info
*hi
= NULL
;
586 struct net_device
*dev
= NULL
;
587 struct eth1394_priv
*priv
;
590 if (hpsb_config_rom_ip1394_add(host
) != 0) {
591 ETH1394_PRINT_G(KERN_ERR
, "Can't add IP-over-1394 ROM entry\n");
595 fifo_addr
= hpsb_allocate_and_register_addrspace(
596 ð1394_highlevel
, host
, &addr_ops
,
597 ETHER1394_REGION_ADDR_LEN
, ETHER1394_REGION_ADDR_LEN
,
598 CSR1212_INVALID_ADDR_SPACE
, CSR1212_INVALID_ADDR_SPACE
);
599 if (fifo_addr
== CSR1212_INVALID_ADDR_SPACE
) {
600 ETH1394_PRINT_G(KERN_ERR
, "Cannot register CSR space\n");
601 hpsb_config_rom_ip1394_remove(host
);
605 dev
= alloc_netdev(sizeof(*priv
), "eth%d", ether1394_init_dev
);
607 ETH1394_PRINT_G(KERN_ERR
, "Out of memory\n");
611 SET_NETDEV_DEV(dev
, &host
->device
);
613 priv
= netdev_priv(dev
);
614 INIT_LIST_HEAD(&priv
->ip_node_list
);
615 spin_lock_init(&priv
->lock
);
617 priv
->local_fifo
= fifo_addr
;
618 INIT_WORK(&priv
->wake
, ether1394_wake_queue
);
619 priv
->wake_dev
= dev
;
621 hi
= hpsb_create_hostinfo(ð1394_highlevel
, host
, sizeof(*hi
));
623 ETH1394_PRINT_G(KERN_ERR
, "Out of memory\n");
627 ether1394_reset_priv(dev
, 1);
629 if (register_netdev(dev
)) {
630 ETH1394_PRINT_G(KERN_ERR
, "Cannot register the driver\n");
634 ETH1394_PRINT(KERN_INFO
, dev
->name
, "IPv4 over IEEE 1394 (fw-host%d)\n",
640 /* Ignore validity in hopes that it will be set in the future. It'll
641 * be checked when the eth device is opened. */
642 priv
->broadcast_channel
= host
->csr
.broadcast_channel
& 0x3f;
644 ether1394_recv_init(priv
);
650 hpsb_destroy_hostinfo(ð1394_highlevel
, host
);
651 hpsb_unregister_addrspace(ð1394_highlevel
, host
, fifo_addr
);
652 hpsb_config_rom_ip1394_remove(host
);
655 /* Remove a card from our list */
656 static void ether1394_remove_host(struct hpsb_host
*host
)
658 struct eth1394_host_info
*hi
;
659 struct eth1394_priv
*priv
;
661 hi
= hpsb_get_hostinfo(ð1394_highlevel
, host
);
664 priv
= netdev_priv(hi
->dev
);
665 hpsb_unregister_addrspace(ð1394_highlevel
, host
, priv
->local_fifo
);
666 hpsb_config_rom_ip1394_remove(host
);
668 hpsb_iso_shutdown(priv
->iso
);
669 unregister_netdev(hi
->dev
);
670 free_netdev(hi
->dev
);
673 /* A bus reset happened */
674 static void ether1394_host_reset(struct hpsb_host
*host
)
676 struct eth1394_host_info
*hi
;
677 struct eth1394_priv
*priv
;
678 struct net_device
*dev
;
679 struct list_head
*lh
, *n
;
680 struct eth1394_node_ref
*node
;
681 struct eth1394_node_info
*node_info
;
684 hi
= hpsb_get_hostinfo(ð1394_highlevel
, host
);
686 /* This can happen for hosts that we don't use */
691 priv
= netdev_priv(dev
);
693 /* Reset our private host data, but not our MTU */
694 netif_stop_queue(dev
);
695 ether1394_reset_priv(dev
, 0);
697 list_for_each_entry(node
, &priv
->ip_node_list
, list
) {
698 node_info
= node
->ud
->device
.driver_data
;
700 spin_lock_irqsave(&node_info
->pdg
.lock
, flags
);
702 list_for_each_safe(lh
, n
, &node_info
->pdg
.list
)
703 purge_partial_datagram(lh
);
705 INIT_LIST_HEAD(&(node_info
->pdg
.list
));
706 node_info
->pdg
.sz
= 0;
708 spin_unlock_irqrestore(&node_info
->pdg
.lock
, flags
);
711 netif_wake_queue(dev
);
714 /******************************************
715 * HW Header net device functions
716 ******************************************/
717 /* These functions have been adapted from net/ethernet/eth.c */
719 /* Create a fake MAC header for an arbitrary protocol layer.
720 * saddr=NULL means use device source address
721 * daddr=NULL means leave destination address (eg unresolved arp). */
722 static int ether1394_header(struct sk_buff
*skb
, struct net_device
*dev
,
723 unsigned short type
, const void *daddr
,
724 const void *saddr
, unsigned len
)
726 struct eth1394hdr
*eth
=
727 (struct eth1394hdr
*)skb_push(skb
, ETH1394_HLEN
);
729 eth
->h_proto
= htons(type
);
731 if (dev
->flags
& (IFF_LOOPBACK
| IFF_NOARP
)) {
732 memset(eth
->h_dest
, 0, dev
->addr_len
);
733 return dev
->hard_header_len
;
737 memcpy(eth
->h_dest
, daddr
, dev
->addr_len
);
738 return dev
->hard_header_len
;
741 return -dev
->hard_header_len
;
744 /* Rebuild the faked MAC header. This is called after an ARP
745 * (or in future other address resolution) has completed on this
746 * sk_buff. We now let ARP fill in the other fields.
748 * This routine CANNOT use cached dst->neigh!
749 * Really, it is used only when dst->neigh is wrong.
751 static int ether1394_rebuild_header(struct sk_buff
*skb
)
753 struct eth1394hdr
*eth
= (struct eth1394hdr
*)skb
->data
;
755 if (eth
->h_proto
== htons(ETH_P_IP
))
756 return arp_find((unsigned char *)ð
->h_dest
, skb
);
758 ETH1394_PRINT(KERN_DEBUG
, skb
->dev
->name
,
759 "unable to resolve type %04x addresses\n",
760 ntohs(eth
->h_proto
));
764 static int ether1394_header_parse(const struct sk_buff
*skb
,
765 unsigned char *haddr
)
767 memcpy(haddr
, skb
->dev
->dev_addr
, ETH1394_ALEN
);
771 static int ether1394_header_cache(const struct neighbour
*neigh
,
774 unsigned short type
= hh
->hh_type
;
775 struct net_device
*dev
= neigh
->dev
;
776 struct eth1394hdr
*eth
=
777 (struct eth1394hdr
*)((u8
*)hh
->hh_data
+ 16 - ETH1394_HLEN
);
779 if (type
== htons(ETH_P_802_3
))
783 memcpy(eth
->h_dest
, neigh
->ha
, dev
->addr_len
);
785 hh
->hh_len
= ETH1394_HLEN
;
789 /* Called by Address Resolution module to notify changes in address. */
790 static void ether1394_header_cache_update(struct hh_cache
*hh
,
791 const struct net_device
*dev
,
792 const unsigned char * haddr
)
794 memcpy((u8
*)hh
->hh_data
+ 16 - ETH1394_HLEN
, haddr
, dev
->addr_len
);
797 /******************************************
798 * Datagram reception code
799 ******************************************/
801 /* Copied from net/ethernet/eth.c */
802 static u16
ether1394_type_trans(struct sk_buff
*skb
, struct net_device
*dev
)
804 struct eth1394hdr
*eth
;
807 skb_reset_mac_header(skb
);
808 skb_pull(skb
, ETH1394_HLEN
);
809 eth
= eth1394_hdr(skb
);
811 if (*eth
->h_dest
& 1) {
812 if (memcmp(eth
->h_dest
, dev
->broadcast
, dev
->addr_len
) == 0)
813 skb
->pkt_type
= PACKET_BROADCAST
;
816 skb
->pkt_type
= PACKET_MULTICAST
;
819 if (memcmp(eth
->h_dest
, dev
->dev_addr
, dev
->addr_len
))
820 skb
->pkt_type
= PACKET_OTHERHOST
;
823 if (ntohs(eth
->h_proto
) >= 1536)
828 if (*(unsigned short *)rawp
== 0xFFFF)
829 return htons(ETH_P_802_3
);
831 return htons(ETH_P_802_2
);
834 /* Parse an encapsulated IP1394 header into an ethernet frame packet.
835 * We also perform ARP translation here, if need be. */
836 static u16
ether1394_parse_encap(struct sk_buff
*skb
, struct net_device
*dev
,
837 nodeid_t srcid
, nodeid_t destid
,
840 struct eth1394_priv
*priv
= netdev_priv(dev
);
842 unsigned short ret
= 0;
844 /* Setup our hw addresses. We use these to build the ethernet header. */
845 if (destid
== (LOCAL_BUS
| ALL_NODES
))
846 dest_hw
= ~0ULL; /* broadcast */
848 dest_hw
= cpu_to_be64((u64
)priv
->host
->csr
.guid_hi
<< 32 |
849 priv
->host
->csr
.guid_lo
);
851 /* If this is an ARP packet, convert it. First, we want to make
852 * use of some of the fields, since they tell us a little bit
853 * about the sending machine. */
854 if (ether_type
== htons(ETH_P_ARP
)) {
855 struct eth1394_arp
*arp1394
= (struct eth1394_arp
*)skb
->data
;
856 struct arphdr
*arp
= (struct arphdr
*)skb
->data
;
857 unsigned char *arp_ptr
= (unsigned char *)(arp
+ 1);
858 u64 fifo_addr
= (u64
)ntohs(arp1394
->fifo_hi
) << 32 |
859 ntohl(arp1394
->fifo_lo
);
860 u8 max_rec
= min(priv
->host
->csr
.max_rec
,
861 (u8
)(arp1394
->max_rec
));
862 int sspd
= arp1394
->sspd
;
864 struct eth1394_node_ref
*node
;
865 struct eth1394_node_info
*node_info
;
868 /* Sanity check. MacOSX seems to be sending us 131 in this
869 * field (atleast on my Panther G5). Not sure why. */
870 if (sspd
> 5 || sspd
< 0)
873 maxpayload
= min(eth1394_speedto_maxpayload
[sspd
],
874 (u16
)(1 << (max_rec
+ 1)));
876 guid
= get_unaligned(&arp1394
->s_uniq_id
);
877 node
= eth1394_find_node_guid(&priv
->ip_node_list
,
883 (struct eth1394_node_info
*)node
->ud
->device
.driver_data
;
885 /* Update our speed/payload/fifo_offset table */
886 node_info
->maxpayload
= maxpayload
;
887 node_info
->sspd
= sspd
;
888 node_info
->fifo
= fifo_addr
;
890 /* Now that we're done with the 1394 specific stuff, we'll
891 * need to alter some of the data. Believe it or not, all
892 * that needs to be done is sender_IP_address needs to be
893 * moved, the destination hardware address get stuffed
894 * in and the hardware address length set to 8.
896 * IMPORTANT: The code below overwrites 1394 specific data
897 * needed above so keep the munging of the data for the
898 * higher level IP stack last. */
901 arp_ptr
+= arp
->ar_hln
; /* skip over sender unique id */
902 *(u32
*)arp_ptr
= arp1394
->sip
; /* move sender IP addr */
903 arp_ptr
+= arp
->ar_pln
; /* skip over sender IP addr */
905 if (arp
->ar_op
== htons(ARPOP_REQUEST
))
906 memset(arp_ptr
, 0, sizeof(u64
));
908 memcpy(arp_ptr
, dev
->dev_addr
, sizeof(u64
));
911 /* Now add the ethernet header. */
912 if (dev_hard_header(skb
, dev
, ntohs(ether_type
), &dest_hw
, NULL
,
914 ret
= ether1394_type_trans(skb
, dev
);
919 static int fragment_overlap(struct list_head
*frag_list
, int offset
, int len
)
921 struct fragment_info
*fi
;
922 int end
= offset
+ len
;
924 list_for_each_entry(fi
, frag_list
, list
)
925 if (offset
< fi
->offset
+ fi
->len
&& end
> fi
->offset
)
931 static struct list_head
*find_partial_datagram(struct list_head
*pdgl
, int dgl
)
933 struct partial_datagram
*pd
;
935 list_for_each_entry(pd
, pdgl
, list
)
942 /* Assumes that new fragment does not overlap any existing fragments */
943 static int new_fragment(struct list_head
*frag_info
, int offset
, int len
)
945 struct list_head
*lh
;
946 struct fragment_info
*fi
, *fi2
, *new;
948 list_for_each(lh
, frag_info
) {
949 fi
= list_entry(lh
, struct fragment_info
, list
);
950 if (fi
->offset
+ fi
->len
== offset
) {
951 /* The new fragment can be tacked on to the end */
953 /* Did the new fragment plug a hole? */
954 fi2
= list_entry(lh
->next
, struct fragment_info
, list
);
955 if (fi
->offset
+ fi
->len
== fi2
->offset
) {
956 /* glue fragments together */
962 } else if (offset
+ len
== fi
->offset
) {
963 /* The new fragment can be tacked on to the beginning */
966 /* Did the new fragment plug a hole? */
967 fi2
= list_entry(lh
->prev
, struct fragment_info
, list
);
968 if (fi2
->offset
+ fi2
->len
== fi
->offset
) {
969 /* glue fragments together */
975 } else if (offset
> fi
->offset
+ fi
->len
) {
977 } else if (offset
+ len
< fi
->offset
) {
983 new = kmalloc(sizeof(*new), GFP_ATOMIC
);
987 new->offset
= offset
;
990 list_add(&new->list
, lh
);
994 static int new_partial_datagram(struct net_device
*dev
, struct list_head
*pdgl
,
995 int dgl
, int dg_size
, char *frag_buf
,
996 int frag_off
, int frag_len
)
998 struct partial_datagram
*new;
1000 new = kmalloc(sizeof(*new), GFP_ATOMIC
);
1004 INIT_LIST_HEAD(&new->frag_info
);
1006 if (new_fragment(&new->frag_info
, frag_off
, frag_len
) < 0) {
1012 new->dg_size
= dg_size
;
1014 new->skb
= dev_alloc_skb(dg_size
+ dev
->hard_header_len
+ 15);
1016 struct fragment_info
*fi
= list_entry(new->frag_info
.next
,
1017 struct fragment_info
,
1024 skb_reserve(new->skb
, (dev
->hard_header_len
+ 15) & ~15);
1025 new->pbuf
= skb_put(new->skb
, dg_size
);
1026 memcpy(new->pbuf
+ frag_off
, frag_buf
, frag_len
);
1028 list_add(&new->list
, pdgl
);
1032 static int update_partial_datagram(struct list_head
*pdgl
, struct list_head
*lh
,
1033 char *frag_buf
, int frag_off
, int frag_len
)
1035 struct partial_datagram
*pd
=
1036 list_entry(lh
, struct partial_datagram
, list
);
1038 if (new_fragment(&pd
->frag_info
, frag_off
, frag_len
) < 0)
1041 memcpy(pd
->pbuf
+ frag_off
, frag_buf
, frag_len
);
1043 /* Move list entry to beginnig of list so that oldest partial
1044 * datagrams percolate to the end of the list */
1045 list_move(lh
, pdgl
);
1049 static int is_datagram_complete(struct list_head
*lh
, int dg_size
)
1051 struct partial_datagram
*pd
;
1052 struct fragment_info
*fi
;
1054 pd
= list_entry(lh
, struct partial_datagram
, list
);
1055 fi
= list_entry(pd
->frag_info
.next
, struct fragment_info
, list
);
1057 return (fi
->len
== dg_size
);
1060 /* Packet reception. We convert the IP1394 encapsulation header to an
1061 * ethernet header, and fill it with some of our other fields. This is
1062 * an incoming packet from the 1394 bus. */
1063 static int ether1394_data_handler(struct net_device
*dev
, int srcid
, int destid
,
1066 struct sk_buff
*skb
;
1067 unsigned long flags
;
1068 struct eth1394_priv
*priv
= netdev_priv(dev
);
1069 union eth1394_hdr
*hdr
= (union eth1394_hdr
*)buf
;
1070 u16 ether_type
= 0; /* initialized to clear warning */
1072 struct unit_directory
*ud
= priv
->ud_list
[NODEID_TO_NODE(srcid
)];
1073 struct eth1394_node_info
*node_info
;
1076 struct eth1394_node_ref
*node
;
1077 node
= eth1394_find_node_nodeid(&priv
->ip_node_list
, srcid
);
1078 if (unlikely(!node
)) {
1079 HPSB_PRINT(KERN_ERR
, "ether1394 rx: sender nodeid "
1080 "lookup failure: " NODE_BUS_FMT
,
1081 NODE_BUS_ARGS(priv
->host
, srcid
));
1082 priv
->stats
.rx_dropped
++;
1087 priv
->ud_list
[NODEID_TO_NODE(srcid
)] = ud
;
1090 node_info
= (struct eth1394_node_info
*)ud
->device
.driver_data
;
1092 /* First, did we receive a fragmented or unfragmented datagram? */
1093 hdr
->words
.word1
= ntohs(hdr
->words
.word1
);
1095 hdr_len
= hdr_type_len
[hdr
->common
.lf
];
1097 if (hdr
->common
.lf
== ETH1394_HDR_LF_UF
) {
1098 /* An unfragmented datagram has been received by the ieee1394
1099 * bus. Build an skbuff around it so we can pass it to the
1100 * high level network layer. */
1102 skb
= dev_alloc_skb(len
+ dev
->hard_header_len
+ 15);
1103 if (unlikely(!skb
)) {
1104 ETH1394_PRINT_G(KERN_ERR
, "Out of memory\n");
1105 priv
->stats
.rx_dropped
++;
1108 skb_reserve(skb
, (dev
->hard_header_len
+ 15) & ~15);
1109 memcpy(skb_put(skb
, len
- hdr_len
), buf
+ hdr_len
,
1111 ether_type
= hdr
->uf
.ether_type
;
1113 /* A datagram fragment has been received, now the fun begins. */
1115 struct list_head
*pdgl
, *lh
;
1116 struct partial_datagram
*pd
;
1118 int fg_len
= len
- hdr_len
;
1122 struct pdg_list
*pdg
= &(node_info
->pdg
);
1124 hdr
->words
.word3
= ntohs(hdr
->words
.word3
);
1125 /* The 4th header word is reserved so no need to do ntohs() */
1127 if (hdr
->common
.lf
== ETH1394_HDR_LF_FF
) {
1128 ether_type
= hdr
->ff
.ether_type
;
1130 dg_size
= hdr
->ff
.dg_size
+ 1;
1133 hdr
->words
.word2
= ntohs(hdr
->words
.word2
);
1135 dg_size
= hdr
->sf
.dg_size
+ 1;
1136 fg_off
= hdr
->sf
.fg_off
;
1138 spin_lock_irqsave(&pdg
->lock
, flags
);
1140 pdgl
= &(pdg
->list
);
1141 lh
= find_partial_datagram(pdgl
, dgl
);
1144 while (pdg
->sz
>= max_partial_datagrams
) {
1145 /* remove the oldest */
1146 purge_partial_datagram(pdgl
->prev
);
1150 retval
= new_partial_datagram(dev
, pdgl
, dgl
, dg_size
,
1151 buf
+ hdr_len
, fg_off
,
1154 spin_unlock_irqrestore(&pdg
->lock
, flags
);
1158 lh
= find_partial_datagram(pdgl
, dgl
);
1160 pd
= list_entry(lh
, struct partial_datagram
, list
);
1162 if (fragment_overlap(&pd
->frag_info
, fg_off
, fg_len
)) {
1163 /* Overlapping fragments, obliterate old
1164 * datagram and start new one. */
1165 purge_partial_datagram(lh
);
1166 retval
= new_partial_datagram(dev
, pdgl
, dgl
,
1172 spin_unlock_irqrestore(&pdg
->lock
, flags
);
1176 retval
= update_partial_datagram(pdgl
, lh
,
1180 /* Couldn't save off fragment anyway
1181 * so might as well obliterate the
1183 purge_partial_datagram(lh
);
1185 spin_unlock_irqrestore(&pdg
->lock
, flags
);
1188 } /* fragment overlap */
1189 } /* new datagram or add to existing one */
1191 pd
= list_entry(lh
, struct partial_datagram
, list
);
1193 if (hdr
->common
.lf
== ETH1394_HDR_LF_FF
)
1194 pd
->ether_type
= ether_type
;
1196 if (is_datagram_complete(lh
, dg_size
)) {
1197 ether_type
= pd
->ether_type
;
1199 skb
= skb_get(pd
->skb
);
1200 purge_partial_datagram(lh
);
1201 spin_unlock_irqrestore(&pdg
->lock
, flags
);
1203 /* Datagram is not complete, we're done for the
1205 spin_unlock_irqrestore(&pdg
->lock
, flags
);
1208 } /* unframgented datagram or fragmented one */
1210 /* Write metadata, and then pass to the receive level */
1212 skb
->ip_summed
= CHECKSUM_UNNECESSARY
; /* don't check it */
1214 /* Parse the encapsulation header. This actually does the job of
1215 * converting to an ethernet frame header, aswell as arp
1216 * conversion if needed. ARP conversion is easier in this
1217 * direction, since we are using ethernet as our backend. */
1218 skb
->protocol
= ether1394_parse_encap(skb
, dev
, srcid
, destid
,
1221 spin_lock_irqsave(&priv
->lock
, flags
);
1223 if (!skb
->protocol
) {
1224 priv
->stats
.rx_errors
++;
1225 priv
->stats
.rx_dropped
++;
1226 dev_kfree_skb_any(skb
);
1227 } else if (netif_rx(skb
) == NET_RX_DROP
) {
1228 priv
->stats
.rx_errors
++;
1229 priv
->stats
.rx_dropped
++;
1231 priv
->stats
.rx_packets
++;
1232 priv
->stats
.rx_bytes
+= skb
->len
;
1235 spin_unlock_irqrestore(&priv
->lock
, flags
);
1238 if (netif_queue_stopped(dev
))
1239 netif_wake_queue(dev
);
1244 static int ether1394_write(struct hpsb_host
*host
, int srcid
, int destid
,
1245 quadlet_t
*data
, u64 addr
, size_t len
, u16 flags
)
1247 struct eth1394_host_info
*hi
;
1249 hi
= hpsb_get_hostinfo(ð1394_highlevel
, host
);
1250 if (unlikely(!hi
)) {
1251 ETH1394_PRINT_G(KERN_ERR
, "No net device at fw-host%d\n",
1253 return RCODE_ADDRESS_ERROR
;
1256 if (ether1394_data_handler(hi
->dev
, srcid
, destid
, (char*)data
, len
))
1257 return RCODE_ADDRESS_ERROR
;
1259 return RCODE_COMPLETE
;
1262 static void ether1394_iso(struct hpsb_iso
*iso
)
1266 struct eth1394_host_info
*hi
;
1267 struct net_device
*dev
;
1268 struct eth1394_priv
*priv
;
1275 hi
= hpsb_get_hostinfo(ð1394_highlevel
, iso
->host
);
1276 if (unlikely(!hi
)) {
1277 ETH1394_PRINT_G(KERN_ERR
, "No net device at fw-host%d\n",
1284 nready
= hpsb_iso_n_ready(iso
);
1285 for (i
= 0; i
< nready
; i
++) {
1286 struct hpsb_iso_packet_info
*info
=
1287 &iso
->infos
[(iso
->first_packet
+ i
) % iso
->buf_packets
];
1288 data
= (quadlet_t
*)(iso
->data_buf
.kvirt
+ info
->offset
);
1290 /* skip over GASP header */
1291 buf
= (char *)data
+ 8;
1292 len
= info
->len
- 8;
1294 specifier_id
= (be32_to_cpu(data
[0]) & 0xffff) << 8 |
1295 (be32_to_cpu(data
[1]) & 0xff000000) >> 24;
1296 source_id
= be32_to_cpu(data
[0]) >> 16;
1298 priv
= netdev_priv(dev
);
1300 if (info
->channel
!= (iso
->host
->csr
.broadcast_channel
& 0x3f)
1301 || specifier_id
!= ETHER1394_GASP_SPECIFIER_ID
) {
1302 /* This packet is not for us */
1305 ether1394_data_handler(dev
, source_id
, LOCAL_BUS
| ALL_NODES
,
1309 hpsb_iso_recv_release_packets(iso
, i
);
1311 dev
->last_rx
= jiffies
;
1314 /******************************************
1315 * Datagram transmission code
1316 ******************************************/
1318 /* Convert a standard ARP packet to 1394 ARP. The first 8 bytes (the entire
1319 * arphdr) is the same format as the ip1394 header, so they overlap. The rest
1320 * needs to be munged a bit. The remainder of the arphdr is formatted based
1321 * on hwaddr len and ipaddr len. We know what they'll be, so it's easy to
1324 * Now that the EUI is used for the hardware address all we need to do to make
1325 * this work for 1394 is to insert 2 quadlets that contain max_rec size,
1326 * speed, and unicast FIFO address information between the sender_unique_id
1327 * and the IP addresses.
1329 static void ether1394_arp_to_1394arp(struct sk_buff
*skb
,
1330 struct net_device
*dev
)
1332 struct eth1394_priv
*priv
= netdev_priv(dev
);
1333 struct arphdr
*arp
= (struct arphdr
*)skb
->data
;
1334 unsigned char *arp_ptr
= (unsigned char *)(arp
+ 1);
1335 struct eth1394_arp
*arp1394
= (struct eth1394_arp
*)skb
->data
;
1337 arp1394
->hw_addr_len
= 16;
1338 arp1394
->sip
= *(u32
*)(arp_ptr
+ ETH1394_ALEN
);
1339 arp1394
->max_rec
= priv
->host
->csr
.max_rec
;
1340 arp1394
->sspd
= priv
->host
->csr
.lnk_spd
;
1341 arp1394
->fifo_hi
= htons(priv
->local_fifo
>> 32);
1342 arp1394
->fifo_lo
= htonl(priv
->local_fifo
& ~0x0);
1345 /* We need to encapsulate the standard header with our own. We use the
1346 * ethernet header's proto for our own. */
1347 static unsigned int ether1394_encapsulate_prep(unsigned int max_payload
,
1349 union eth1394_hdr
*hdr
,
1350 u16 dg_size
, u16 dgl
)
1352 unsigned int adj_max_payload
=
1353 max_payload
- hdr_type_len
[ETH1394_HDR_LF_UF
];
1355 /* Does it all fit in one packet? */
1356 if (dg_size
<= adj_max_payload
) {
1357 hdr
->uf
.lf
= ETH1394_HDR_LF_UF
;
1358 hdr
->uf
.ether_type
= proto
;
1360 hdr
->ff
.lf
= ETH1394_HDR_LF_FF
;
1361 hdr
->ff
.ether_type
= proto
;
1362 hdr
->ff
.dg_size
= dg_size
- 1;
1364 adj_max_payload
= max_payload
- hdr_type_len
[ETH1394_HDR_LF_FF
];
1366 return DIV_ROUND_UP(dg_size
, adj_max_payload
);
1369 static unsigned int ether1394_encapsulate(struct sk_buff
*skb
,
1370 unsigned int max_payload
,
1371 union eth1394_hdr
*hdr
)
1373 union eth1394_hdr
*bufhdr
;
1374 int ftype
= hdr
->common
.lf
;
1375 int hdrsz
= hdr_type_len
[ftype
];
1376 unsigned int adj_max_payload
= max_payload
- hdrsz
;
1379 case ETH1394_HDR_LF_UF
:
1380 bufhdr
= (union eth1394_hdr
*)skb_push(skb
, hdrsz
);
1381 bufhdr
->words
.word1
= htons(hdr
->words
.word1
);
1382 bufhdr
->words
.word2
= hdr
->words
.word2
;
1385 case ETH1394_HDR_LF_FF
:
1386 bufhdr
= (union eth1394_hdr
*)skb_push(skb
, hdrsz
);
1387 bufhdr
->words
.word1
= htons(hdr
->words
.word1
);
1388 bufhdr
->words
.word2
= hdr
->words
.word2
;
1389 bufhdr
->words
.word3
= htons(hdr
->words
.word3
);
1390 bufhdr
->words
.word4
= 0;
1392 /* Set frag type here for future interior fragments */
1393 hdr
->common
.lf
= ETH1394_HDR_LF_IF
;
1398 hdr
->sf
.fg_off
+= adj_max_payload
;
1399 bufhdr
= (union eth1394_hdr
*)skb_pull(skb
, adj_max_payload
);
1400 if (max_payload
>= skb
->len
)
1401 hdr
->common
.lf
= ETH1394_HDR_LF_LF
;
1402 bufhdr
->words
.word1
= htons(hdr
->words
.word1
);
1403 bufhdr
->words
.word2
= htons(hdr
->words
.word2
);
1404 bufhdr
->words
.word3
= htons(hdr
->words
.word3
);
1405 bufhdr
->words
.word4
= 0;
1407 return min(max_payload
, skb
->len
);
1410 static struct hpsb_packet
*ether1394_alloc_common_packet(struct hpsb_host
*host
)
1412 struct hpsb_packet
*p
;
1414 p
= hpsb_alloc_packet(0);
1417 p
->generation
= get_hpsb_generation(host
);
1418 p
->type
= hpsb_async
;
1423 static int ether1394_prep_write_packet(struct hpsb_packet
*p
,
1424 struct hpsb_host
*host
, nodeid_t node
,
1425 u64 addr
, void *data
, int tx_len
)
1429 if (hpsb_get_tlabel(p
))
1432 p
->tcode
= TCODE_WRITEB
;
1433 p
->header_size
= 16;
1434 p
->expect_response
= 1;
1436 p
->node_id
<< 16 | p
->tlabel
<< 10 | 1 << 8 | TCODE_WRITEB
<< 4;
1437 p
->header
[1] = host
->node_id
<< 16 | addr
>> 32;
1438 p
->header
[2] = addr
& 0xffffffff;
1439 p
->header
[3] = tx_len
<< 16;
1440 p
->data_size
= (tx_len
+ 3) & ~3;
1446 static void ether1394_prep_gasp_packet(struct hpsb_packet
*p
,
1447 struct eth1394_priv
*priv
,
1448 struct sk_buff
*skb
, int length
)
1451 p
->tcode
= TCODE_STREAM_DATA
;
1453 p
->header
[0] = length
<< 16 | 3 << 14 | priv
->broadcast_channel
<< 8 |
1454 TCODE_STREAM_DATA
<< 4;
1455 p
->data_size
= length
;
1456 p
->data
= (quadlet_t
*)skb
->data
- 2;
1457 p
->data
[0] = cpu_to_be32(priv
->host
->node_id
<< 16 |
1458 ETHER1394_GASP_SPECIFIER_ID_HI
);
1459 p
->data
[1] = cpu_to_be32(ETHER1394_GASP_SPECIFIER_ID_LO
<< 24 |
1460 ETHER1394_GASP_VERSION
);
1462 p
->speed_code
= priv
->bc_sspd
;
1464 /* prevent hpsb_send_packet() from overriding our speed code */
1465 p
->node_id
= LOCAL_BUS
| ALL_NODES
;
1468 static void ether1394_free_packet(struct hpsb_packet
*packet
)
1470 if (packet
->tcode
!= TCODE_STREAM_DATA
)
1471 hpsb_free_tlabel(packet
);
1472 hpsb_free_packet(packet
);
1475 static void ether1394_complete_cb(void *__ptask
);
1477 static int ether1394_send_packet(struct packet_task
*ptask
, unsigned int tx_len
)
1479 struct eth1394_priv
*priv
= ptask
->priv
;
1480 struct hpsb_packet
*packet
= NULL
;
1482 packet
= ether1394_alloc_common_packet(priv
->host
);
1486 if (ptask
->tx_type
== ETH1394_GASP
) {
1487 int length
= tx_len
+ 2 * sizeof(quadlet_t
);
1489 ether1394_prep_gasp_packet(packet
, priv
, ptask
->skb
, length
);
1490 } else if (ether1394_prep_write_packet(packet
, priv
->host
,
1492 ptask
->addr
, ptask
->skb
->data
,
1494 hpsb_free_packet(packet
);
1498 ptask
->packet
= packet
;
1499 hpsb_set_packet_complete_task(ptask
->packet
, ether1394_complete_cb
,
1502 if (hpsb_send_packet(packet
) < 0) {
1503 ether1394_free_packet(packet
);
1510 /* Task function to be run when a datagram transmission is completed */
1511 static void ether1394_dg_complete(struct packet_task
*ptask
, int fail
)
1513 struct sk_buff
*skb
= ptask
->skb
;
1514 struct eth1394_priv
*priv
= netdev_priv(skb
->dev
);
1515 unsigned long flags
;
1518 spin_lock_irqsave(&priv
->lock
, flags
);
1520 priv
->stats
.tx_dropped
++;
1521 priv
->stats
.tx_errors
++;
1523 priv
->stats
.tx_bytes
+= skb
->len
;
1524 priv
->stats
.tx_packets
++;
1526 spin_unlock_irqrestore(&priv
->lock
, flags
);
1528 dev_kfree_skb_any(skb
);
1529 kmem_cache_free(packet_task_cache
, ptask
);
1532 /* Callback for when a packet has been sent and the status of that packet is
1534 static void ether1394_complete_cb(void *__ptask
)
1536 struct packet_task
*ptask
= (struct packet_task
*)__ptask
;
1537 struct hpsb_packet
*packet
= ptask
->packet
;
1540 if (packet
->tcode
!= TCODE_STREAM_DATA
)
1541 fail
= hpsb_packet_success(packet
);
1543 ether1394_free_packet(packet
);
1545 ptask
->outstanding_pkts
--;
1546 if (ptask
->outstanding_pkts
> 0 && !fail
) {
1549 /* Add the encapsulation header to the fragment */
1550 tx_len
= ether1394_encapsulate(ptask
->skb
, ptask
->max_payload
,
1552 err
= ether1394_send_packet(ptask
, tx_len
);
1555 ETH1394_PRINT_G(KERN_ERR
, "Out of tlabels\n");
1557 ether1394_dg_complete(ptask
, 1);
1560 ether1394_dg_complete(ptask
, fail
);
1564 /* Transmit a packet (called by kernel) */
1565 static int ether1394_tx(struct sk_buff
*skb
, struct net_device
*dev
)
1567 struct eth1394hdr hdr_buf
;
1568 struct eth1394_priv
*priv
= netdev_priv(dev
);
1570 unsigned long flags
;
1572 eth1394_tx_type tx_type
;
1573 unsigned int tx_len
;
1574 unsigned int max_payload
;
1577 struct packet_task
*ptask
;
1578 struct eth1394_node_ref
*node
;
1579 struct eth1394_node_info
*node_info
= NULL
;
1581 ptask
= kmem_cache_alloc(packet_task_cache
, GFP_ATOMIC
);
1585 /* XXX Ignore this for now. Noticed that when MacOSX is the IRM,
1586 * it does not set our validity bit. We need to compensate for
1587 * that somewhere else, but not in eth1394. */
1589 if ((priv
->host
->csr
.broadcast_channel
& 0xc0000000) != 0xc0000000)
1593 skb
= skb_share_check(skb
, GFP_ATOMIC
);
1597 /* Get rid of the fake eth1394 header, but first make a copy.
1598 * We might need to rebuild the header on tx failure. */
1599 memcpy(&hdr_buf
, skb
->data
, sizeof(hdr_buf
));
1600 skb_pull(skb
, ETH1394_HLEN
);
1602 proto
= hdr_buf
.h_proto
;
1605 /* Set the transmission type for the packet. ARP packets and IP
1606 * broadcast packets are sent via GASP. */
1607 if (memcmp(hdr_buf
.h_dest
, dev
->broadcast
, ETH1394_ALEN
) == 0 ||
1608 proto
== htons(ETH_P_ARP
) ||
1609 (proto
== htons(ETH_P_IP
) &&
1610 IN_MULTICAST(ntohl(ip_hdr(skb
)->daddr
)))) {
1611 tx_type
= ETH1394_GASP
;
1612 dest_node
= LOCAL_BUS
| ALL_NODES
;
1613 max_payload
= priv
->bc_maxpayload
- ETHER1394_GASP_OVERHEAD
;
1614 BUG_ON(max_payload
< 512 - ETHER1394_GASP_OVERHEAD
);
1616 if (max_payload
< dg_size
+ hdr_type_len
[ETH1394_HDR_LF_UF
])
1619 __be64 guid
= get_unaligned((u64
*)hdr_buf
.h_dest
);
1621 node
= eth1394_find_node_guid(&priv
->ip_node_list
,
1627 (struct eth1394_node_info
*)node
->ud
->device
.driver_data
;
1628 if (node_info
->fifo
== CSR1212_INVALID_ADDR_SPACE
)
1631 dest_node
= node
->ud
->ne
->nodeid
;
1632 max_payload
= node_info
->maxpayload
;
1633 BUG_ON(max_payload
< 512 - ETHER1394_GASP_OVERHEAD
);
1635 dgl
= node_info
->dgl
;
1636 if (max_payload
< dg_size
+ hdr_type_len
[ETH1394_HDR_LF_UF
])
1638 tx_type
= ETH1394_WRREQ
;
1641 /* If this is an ARP packet, convert it */
1642 if (proto
== htons(ETH_P_ARP
))
1643 ether1394_arp_to_1394arp(skb
, dev
);
1645 ptask
->hdr
.words
.word1
= 0;
1646 ptask
->hdr
.words
.word2
= 0;
1647 ptask
->hdr
.words
.word3
= 0;
1648 ptask
->hdr
.words
.word4
= 0;
1651 ptask
->tx_type
= tx_type
;
1653 if (tx_type
!= ETH1394_GASP
) {
1656 spin_lock_irqsave(&priv
->lock
, flags
);
1657 addr
= node_info
->fifo
;
1658 spin_unlock_irqrestore(&priv
->lock
, flags
);
1661 ptask
->dest_node
= dest_node
;
1664 ptask
->tx_type
= tx_type
;
1665 ptask
->max_payload
= max_payload
;
1666 ptask
->outstanding_pkts
= ether1394_encapsulate_prep(max_payload
,
1667 proto
, &ptask
->hdr
, dg_size
, dgl
);
1669 /* Add the encapsulation header to the fragment */
1670 tx_len
= ether1394_encapsulate(skb
, max_payload
, &ptask
->hdr
);
1671 dev
->trans_start
= jiffies
;
1672 if (ether1394_send_packet(ptask
, tx_len
)) {
1673 if (dest_node
== (LOCAL_BUS
| ALL_NODES
))
1676 /* At this point we want to restore the packet. When we return
1677 * here with NETDEV_TX_BUSY we will get another entrance in this
1678 * routine with the same skb and we need it to look the same.
1679 * So we pull 4 more bytes, then build the header again. */
1681 ether1394_header(skb
, dev
, ntohs(hdr_buf
.h_proto
),
1682 hdr_buf
.h_dest
, NULL
, 0);
1684 /* Most failures of ether1394_send_packet are recoverable. */
1685 netif_stop_queue(dev
);
1686 priv
->wake_node
= dest_node
;
1687 schedule_work(&priv
->wake
);
1688 kmem_cache_free(packet_task_cache
, ptask
);
1689 return NETDEV_TX_BUSY
;
1692 return NETDEV_TX_OK
;
1695 kmem_cache_free(packet_task_cache
, ptask
);
1700 spin_lock_irqsave(&priv
->lock
, flags
);
1701 priv
->stats
.tx_dropped
++;
1702 priv
->stats
.tx_errors
++;
1703 spin_unlock_irqrestore(&priv
->lock
, flags
);
1706 * FIXME: According to a patch from 2003-02-26, "returning non-zero
1707 * causes serious problems" here, allegedly. Before that patch,
1708 * -ERRNO was returned which is not appropriate under Linux 2.6.
1709 * Perhaps more needs to be done? Stop the queue in serious
1710 * conditions and restart it elsewhere?
1712 /* return NETDEV_TX_BUSY; */
1713 return NETDEV_TX_OK
;
1716 static void ether1394_get_drvinfo(struct net_device
*dev
,
1717 struct ethtool_drvinfo
*info
)
1719 strcpy(info
->driver
, driver_name
);
1720 strcpy(info
->bus_info
, "ieee1394"); /* FIXME provide more detail? */
1723 static struct ethtool_ops ethtool_ops
= {
1724 .get_drvinfo
= ether1394_get_drvinfo
1727 static int __init
ether1394_init_module(void)
1731 packet_task_cache
= kmem_cache_create("packet_task",
1732 sizeof(struct packet_task
),
1734 if (!packet_task_cache
)
1737 hpsb_register_highlevel(ð1394_highlevel
);
1738 err
= hpsb_register_protocol(ð1394_proto_driver
);
1740 hpsb_unregister_highlevel(ð1394_highlevel
);
1741 kmem_cache_destroy(packet_task_cache
);
1746 static void __exit
ether1394_exit_module(void)
1748 hpsb_unregister_protocol(ð1394_proto_driver
);
1749 hpsb_unregister_highlevel(ð1394_highlevel
);
1750 kmem_cache_destroy(packet_task_cache
);
1753 module_init(ether1394_init_module
);
1754 module_exit(ether1394_exit_module
);