aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/firewire
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@linux-foundation.org>2009-06-23 00:29:52 -0400
committerLinus Torvalds <torvalds@linux-foundation.org>2009-06-23 00:29:52 -0400
commit1053414068bad659479e6efa62a67403b8b1ec0a (patch)
treed4096db0f3aa9ca5e6b44c85ab848b7bedbfc37a /drivers/firewire
parentb88f8a546f5dba213938fdfc11e66bc5c2421623 (diff)
parent0c53decdd0a9f9c459ccabe0b5f79660bde5375b (diff)
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ieee1394/linux1394-2.6
* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ieee1394/linux1394-2.6: firewire: new stack is no longer experimental firewire: net: better FIFO address range check and rcodes firewire: net: fix card driver reloading firewire: core: fix iso context shutdown on card removal firewire: core: fix DMA unmapping in iso buffer removal firewire: net: adjust net_device ops firewire: net: remove unused code firewire: net: allow for unordered unit discovery firewire: net: style changes firewire: net: add Kconfig item, rename driver firewire: add IPv4 support
Diffstat (limited to 'drivers/firewire')
-rw-r--r--drivers/firewire/Kconfig60
-rw-r--r--drivers/firewire/Makefile4
-rw-r--r--drivers/firewire/core-card.c20
-rw-r--r--drivers/firewire/core-iso.c11
-rw-r--r--drivers/firewire/core.h87
-rw-r--r--drivers/firewire/net.c1655
6 files changed, 1714 insertions, 123 deletions
diff --git a/drivers/firewire/Kconfig b/drivers/firewire/Kconfig
index 450902438208..13efcd362072 100644
--- a/drivers/firewire/Kconfig
+++ b/drivers/firewire/Kconfig
@@ -1,28 +1,29 @@
1comment "A new alternative FireWire stack is available with EXPERIMENTAL=y" 1comment "You can enable one or both FireWire driver stacks."
2 depends on EXPERIMENTAL=n 2comment "See the help texts for more information."
3
4comment "Enable only one of the two stacks, unless you know what you are doing"
5 depends on EXPERIMENTAL
6 3
7config FIREWIRE 4config FIREWIRE
8 tristate "New FireWire stack, EXPERIMENTAL" 5 tristate "FireWire driver stack"
9 depends on EXPERIMENTAL
10 select CRC_ITU_T 6 select CRC_ITU_T
11 help 7 help
12 This is the "Juju" FireWire stack, a new alternative implementation 8 This is the new-generation IEEE 1394 (FireWire) driver stack
13 designed for robustness and simplicity. You can build either this 9 a.k.a. Juju, a new implementation designed for robustness and
14 stack, or the old stack (the ieee1394 driver, ohci1394 etc.) or both. 10 simplicity.
15 Please read http://ieee1394.wiki.kernel.org/index.php/Juju_Migration 11 See http://ieee1394.wiki.kernel.org/index.php/Juju_Migration
16 before you enable the new stack. 12 for information about migration from the older Linux 1394 stack
13 to the new driver stack.
17 14
18 To compile this driver as a module, say M here: the module will be 15 To compile this driver as a module, say M here: the module will be
19 called firewire-core. 16 called firewire-core.
20 17
21 This module functionally replaces ieee1394, raw1394, and video1394. 18 This module functionally replaces ieee1394, raw1394, and video1394.
22 To access it from application programs, you generally need at least 19 To access it from application programs, you generally need at least
23 libraw1394 version 2. IIDC/DCAM applications also need libdc1394 20 libraw1394 v2. IIDC/DCAM applications need libdc1394 v2.
24 version 2. No libraries are required to access storage devices 21 No libraries are required to access storage devices through the
25 through the firewire-sbp2 driver. 22 firewire-sbp2 driver.
23
24 NOTE:
25 FireWire audio devices currently require the old drivers (ieee1394,
26 ohci1394, raw1394).
26 27
27config FIREWIRE_OHCI 28config FIREWIRE_OHCI
28 tristate "OHCI-1394 controllers" 29 tristate "OHCI-1394 controllers"
@@ -37,11 +38,9 @@ config FIREWIRE_OHCI
37 stack. 38 stack.
38 39
39 NOTE: 40 NOTE:
40 41 If you want to install firewire-ohci and ohci1394 together, you
41 You should only build either firewire-ohci or the old ohci1394 driver, 42 should configure them only as modules and blacklist the driver(s)
42 but not both. If you nevertheless want to install both, you should 43 which you don't want to have auto-loaded. Add either
43 configure them only as modules and blacklist the driver(s) which you
44 don't want to have auto-loaded. Add either
45 44
46 blacklist firewire-ohci 45 blacklist firewire-ohci
47 or 46 or
@@ -50,12 +49,7 @@ config FIREWIRE_OHCI
50 blacklist dv1394 49 blacklist dv1394
51 50
52 to /etc/modprobe.conf or /etc/modprobe.d/* and update modprobe.conf 51 to /etc/modprobe.conf or /etc/modprobe.d/* and update modprobe.conf
53 depending on your distribution. The latter two modules should be 52 depending on your distribution.
54 blacklisted together with ohci1394 because they depend on ohci1394.
55
56 If you have an old modprobe which doesn't implement the blacklist
57 directive, use "install modulename /bin/true" for the modules to be
58 blacklisted.
59 53
60config FIREWIRE_OHCI_DEBUG 54config FIREWIRE_OHCI_DEBUG
61 bool 55 bool
@@ -77,3 +71,17 @@ config FIREWIRE_SBP2
77 71
78 You should also enable support for disks, CD-ROMs, etc. in the SCSI 72 You should also enable support for disks, CD-ROMs, etc. in the SCSI
79 configuration section. 73 configuration section.
74
75config FIREWIRE_NET
76 tristate "IP networking over 1394 (EXPERIMENTAL)"
77 depends on FIREWIRE && INET && EXPERIMENTAL
78 help
79 This enables IPv4 over IEEE 1394, providing IP connectivity with
80 other implementations of RFC 2734 as found on several operating
81 systems. Multicast support is currently limited.
82
83 NOTE, this driver is not stable yet!
84
85 To compile this driver as a module, say M here: The module will be
86 called firewire-net. It replaces eth1394 of the classic IEEE 1394
87 stack.
diff --git a/drivers/firewire/Makefile b/drivers/firewire/Makefile
index bc3b9bf822bf..a8f9bb6d9fdf 100644
--- a/drivers/firewire/Makefile
+++ b/drivers/firewire/Makefile
@@ -6,7 +6,9 @@ firewire-core-y += core-card.o core-cdev.o core-device.o \
6 core-iso.o core-topology.o core-transaction.o 6 core-iso.o core-topology.o core-transaction.o
7firewire-ohci-y += ohci.o 7firewire-ohci-y += ohci.o
8firewire-sbp2-y += sbp2.o 8firewire-sbp2-y += sbp2.o
9firewire-net-y += net.o
9 10
10obj-$(CONFIG_FIREWIRE) += firewire-core.o 11obj-$(CONFIG_FIREWIRE) += firewire-core.o
11obj-$(CONFIG_FIREWIRE_OHCI) += firewire-ohci.o 12obj-$(CONFIG_FIREWIRE_OHCI) += firewire-ohci.o
12obj-$(CONFIG_FIREWIRE_SBP2) += firewire-sbp2.o 13obj-$(CONFIG_FIREWIRE_SBP2) += firewire-sbp2.o
14obj-$(CONFIG_FIREWIRE_NET) += firewire-net.o
diff --git a/drivers/firewire/core-card.c b/drivers/firewire/core-card.c
index 4c1be64fdddd..543fccac81bb 100644
--- a/drivers/firewire/core-card.c
+++ b/drivers/firewire/core-card.c
@@ -176,6 +176,7 @@ int fw_core_add_descriptor(struct fw_descriptor *desc)
176 176
177 return 0; 177 return 0;
178} 178}
179EXPORT_SYMBOL(fw_core_add_descriptor);
179 180
180void fw_core_remove_descriptor(struct fw_descriptor *desc) 181void fw_core_remove_descriptor(struct fw_descriptor *desc)
181{ 182{
@@ -189,6 +190,7 @@ void fw_core_remove_descriptor(struct fw_descriptor *desc)
189 190
190 mutex_unlock(&card_mutex); 191 mutex_unlock(&card_mutex);
191} 192}
193EXPORT_SYMBOL(fw_core_remove_descriptor);
192 194
193static void allocate_broadcast_channel(struct fw_card *card, int generation) 195static void allocate_broadcast_channel(struct fw_card *card, int generation)
194{ 196{
@@ -459,11 +461,11 @@ EXPORT_SYMBOL(fw_card_add);
459 461
460 462
461/* 463/*
462 * The next few functions implements a dummy driver that use once a 464 * The next few functions implement a dummy driver that is used once a card
463 * card driver shuts down an fw_card. This allows the driver to 465 * driver shuts down an fw_card. This allows the driver to cleanly unload,
464 * cleanly unload, as all IO to the card will be handled by the dummy 466 * as all IO to the card will be handled (and failed) by the dummy driver
465 * driver instead of calling into the (possibly) unloaded module. The 467 * instead of calling into the module. Only functions for iso context
466 * dummy driver just fails all IO. 468 * shutdown still need to be provided by the card driver.
467 */ 469 */
468 470
469static int dummy_enable(struct fw_card *card, u32 *config_rom, size_t length) 471static int dummy_enable(struct fw_card *card, u32 *config_rom, size_t length)
@@ -510,7 +512,7 @@ static int dummy_enable_phys_dma(struct fw_card *card,
510 return -ENODEV; 512 return -ENODEV;
511} 513}
512 514
513static struct fw_card_driver dummy_driver = { 515static const struct fw_card_driver dummy_driver_template = {
514 .enable = dummy_enable, 516 .enable = dummy_enable,
515 .update_phy_reg = dummy_update_phy_reg, 517 .update_phy_reg = dummy_update_phy_reg,
516 .set_config_rom = dummy_set_config_rom, 518 .set_config_rom = dummy_set_config_rom,
@@ -529,6 +531,8 @@ void fw_card_release(struct kref *kref)
529 531
530void fw_core_remove_card(struct fw_card *card) 532void fw_core_remove_card(struct fw_card *card)
531{ 533{
534 struct fw_card_driver dummy_driver = dummy_driver_template;
535
532 card->driver->update_phy_reg(card, 4, 536 card->driver->update_phy_reg(card, 4,
533 PHY_LINK_ACTIVE | PHY_CONTENDER, 0); 537 PHY_LINK_ACTIVE | PHY_CONTENDER, 0);
534 fw_core_initiate_bus_reset(card, 1); 538 fw_core_initiate_bus_reset(card, 1);
@@ -537,7 +541,9 @@ void fw_core_remove_card(struct fw_card *card)
537 list_del_init(&card->link); 541 list_del_init(&card->link);
538 mutex_unlock(&card_mutex); 542 mutex_unlock(&card_mutex);
539 543
540 /* Set up the dummy driver. */ 544 /* Switch off most of the card driver interface. */
545 dummy_driver.free_iso_context = card->driver->free_iso_context;
546 dummy_driver.stop_iso = card->driver->stop_iso;
541 card->driver = &dummy_driver; 547 card->driver = &dummy_driver;
542 548
543 fw_destroy_nodes(card); 549 fw_destroy_nodes(card);
diff --git a/drivers/firewire/core-iso.c b/drivers/firewire/core-iso.c
index 28076c892d7e..166f19c6d38d 100644
--- a/drivers/firewire/core-iso.c
+++ b/drivers/firewire/core-iso.c
@@ -71,7 +71,7 @@ int fw_iso_buffer_init(struct fw_iso_buffer *buffer, struct fw_card *card,
71 for (j = 0; j < i; j++) { 71 for (j = 0; j < i; j++) {
72 address = page_private(buffer->pages[j]); 72 address = page_private(buffer->pages[j]);
73 dma_unmap_page(card->device, address, 73 dma_unmap_page(card->device, address,
74 PAGE_SIZE, DMA_TO_DEVICE); 74 PAGE_SIZE, direction);
75 __free_page(buffer->pages[j]); 75 __free_page(buffer->pages[j]);
76 } 76 }
77 kfree(buffer->pages); 77 kfree(buffer->pages);
@@ -80,6 +80,7 @@ int fw_iso_buffer_init(struct fw_iso_buffer *buffer, struct fw_card *card,
80 80
81 return -ENOMEM; 81 return -ENOMEM;
82} 82}
83EXPORT_SYMBOL(fw_iso_buffer_init);
83 84
84int fw_iso_buffer_map(struct fw_iso_buffer *buffer, struct vm_area_struct *vma) 85int fw_iso_buffer_map(struct fw_iso_buffer *buffer, struct vm_area_struct *vma)
85{ 86{
@@ -107,13 +108,14 @@ void fw_iso_buffer_destroy(struct fw_iso_buffer *buffer,
107 for (i = 0; i < buffer->page_count; i++) { 108 for (i = 0; i < buffer->page_count; i++) {
108 address = page_private(buffer->pages[i]); 109 address = page_private(buffer->pages[i]);
109 dma_unmap_page(card->device, address, 110 dma_unmap_page(card->device, address,
110 PAGE_SIZE, DMA_TO_DEVICE); 111 PAGE_SIZE, buffer->direction);
111 __free_page(buffer->pages[i]); 112 __free_page(buffer->pages[i]);
112 } 113 }
113 114
114 kfree(buffer->pages); 115 kfree(buffer->pages);
115 buffer->pages = NULL; 116 buffer->pages = NULL;
116} 117}
118EXPORT_SYMBOL(fw_iso_buffer_destroy);
117 119
118struct fw_iso_context *fw_iso_context_create(struct fw_card *card, 120struct fw_iso_context *fw_iso_context_create(struct fw_card *card,
119 int type, int channel, int speed, size_t header_size, 121 int type, int channel, int speed, size_t header_size,
@@ -136,6 +138,7 @@ struct fw_iso_context *fw_iso_context_create(struct fw_card *card,
136 138
137 return ctx; 139 return ctx;
138} 140}
141EXPORT_SYMBOL(fw_iso_context_create);
139 142
140void fw_iso_context_destroy(struct fw_iso_context *ctx) 143void fw_iso_context_destroy(struct fw_iso_context *ctx)
141{ 144{
@@ -143,12 +146,14 @@ void fw_iso_context_destroy(struct fw_iso_context *ctx)
143 146
144 card->driver->free_iso_context(ctx); 147 card->driver->free_iso_context(ctx);
145} 148}
149EXPORT_SYMBOL(fw_iso_context_destroy);
146 150
147int fw_iso_context_start(struct fw_iso_context *ctx, 151int fw_iso_context_start(struct fw_iso_context *ctx,
148 int cycle, int sync, int tags) 152 int cycle, int sync, int tags)
149{ 153{
150 return ctx->card->driver->start_iso(ctx, cycle, sync, tags); 154 return ctx->card->driver->start_iso(ctx, cycle, sync, tags);
151} 155}
156EXPORT_SYMBOL(fw_iso_context_start);
152 157
153int fw_iso_context_queue(struct fw_iso_context *ctx, 158int fw_iso_context_queue(struct fw_iso_context *ctx,
154 struct fw_iso_packet *packet, 159 struct fw_iso_packet *packet,
@@ -159,11 +164,13 @@ int fw_iso_context_queue(struct fw_iso_context *ctx,
159 164
160 return card->driver->queue_iso(ctx, packet, buffer, payload); 165 return card->driver->queue_iso(ctx, packet, buffer, payload);
161} 166}
167EXPORT_SYMBOL(fw_iso_context_queue);
162 168
163int fw_iso_context_stop(struct fw_iso_context *ctx) 169int fw_iso_context_stop(struct fw_iso_context *ctx)
164{ 170{
165 return ctx->card->driver->stop_iso(ctx); 171 return ctx->card->driver->stop_iso(ctx);
166} 172}
173EXPORT_SYMBOL(fw_iso_context_stop);
167 174
168/* 175/*
169 * Isochronous bus resource management (channels, bandwidth), client side 176 * Isochronous bus resource management (channels, bandwidth), client side
diff --git a/drivers/firewire/core.h b/drivers/firewire/core.h
index 0a25a7b38a80..c3cfc647e5e3 100644
--- a/drivers/firewire/core.h
+++ b/drivers/firewire/core.h
@@ -1,7 +1,6 @@
1#ifndef _FIREWIRE_CORE_H 1#ifndef _FIREWIRE_CORE_H
2#define _FIREWIRE_CORE_H 2#define _FIREWIRE_CORE_H
3 3
4#include <linux/dma-mapping.h>
5#include <linux/fs.h> 4#include <linux/fs.h>
6#include <linux/list.h> 5#include <linux/list.h>
7#include <linux/idr.h> 6#include <linux/idr.h>
@@ -97,17 +96,6 @@ int fw_core_initiate_bus_reset(struct fw_card *card, int short_reset);
97int fw_compute_block_crc(u32 *block); 96int fw_compute_block_crc(u32 *block);
98void fw_schedule_bm_work(struct fw_card *card, unsigned long delay); 97void fw_schedule_bm_work(struct fw_card *card, unsigned long delay);
99 98
100struct fw_descriptor {
101 struct list_head link;
102 size_t length;
103 u32 immediate;
104 u32 key;
105 const u32 *data;
106};
107
108int fw_core_add_descriptor(struct fw_descriptor *desc);
109void fw_core_remove_descriptor(struct fw_descriptor *desc);
110
111 99
112/* -cdev */ 100/* -cdev */
113 101
@@ -130,77 +118,7 @@ void fw_node_event(struct fw_card *card, struct fw_node *node, int event);
130 118
131/* -iso */ 119/* -iso */
132 120
133/*
134 * The iso packet format allows for an immediate header/payload part
135 * stored in 'header' immediately after the packet info plus an
136 * indirect payload part that is pointer to by the 'payload' field.
137 * Applications can use one or the other or both to implement simple
138 * low-bandwidth streaming (e.g. audio) or more advanced
139 * scatter-gather streaming (e.g. assembling video frame automatically).
140 */
141struct fw_iso_packet {
142 u16 payload_length; /* Length of indirect payload. */
143 u32 interrupt:1; /* Generate interrupt on this packet */
144 u32 skip:1; /* Set to not send packet at all. */
145 u32 tag:2;
146 u32 sy:4;
147 u32 header_length:8; /* Length of immediate header. */
148 u32 header[0];
149};
150
151#define FW_ISO_CONTEXT_TRANSMIT 0
152#define FW_ISO_CONTEXT_RECEIVE 1
153
154#define FW_ISO_CONTEXT_MATCH_TAG0 1
155#define FW_ISO_CONTEXT_MATCH_TAG1 2
156#define FW_ISO_CONTEXT_MATCH_TAG2 4
157#define FW_ISO_CONTEXT_MATCH_TAG3 8
158#define FW_ISO_CONTEXT_MATCH_ALL_TAGS 15
159
160/*
161 * An iso buffer is just a set of pages mapped for DMA in the
162 * specified direction. Since the pages are to be used for DMA, they
163 * are not mapped into the kernel virtual address space. We store the
164 * DMA address in the page private. The helper function
165 * fw_iso_buffer_map() will map the pages into a given vma.
166 */
167struct fw_iso_buffer {
168 enum dma_data_direction direction;
169 struct page **pages;
170 int page_count;
171};
172
173typedef void (*fw_iso_callback_t)(struct fw_iso_context *context,
174 u32 cycle, size_t header_length,
175 void *header, void *data);
176
177struct fw_iso_context {
178 struct fw_card *card;
179 int type;
180 int channel;
181 int speed;
182 size_t header_size;
183 fw_iso_callback_t callback;
184 void *callback_data;
185};
186
187int fw_iso_buffer_init(struct fw_iso_buffer *buffer, struct fw_card *card,
188 int page_count, enum dma_data_direction direction);
189int fw_iso_buffer_map(struct fw_iso_buffer *buffer, struct vm_area_struct *vma); 121int fw_iso_buffer_map(struct fw_iso_buffer *buffer, struct vm_area_struct *vma);
190void fw_iso_buffer_destroy(struct fw_iso_buffer *buffer, struct fw_card *card);
191
192struct fw_iso_context *fw_iso_context_create(struct fw_card *card,
193 int type, int channel, int speed, size_t header_size,
194 fw_iso_callback_t callback, void *callback_data);
195int fw_iso_context_queue(struct fw_iso_context *ctx,
196 struct fw_iso_packet *packet,
197 struct fw_iso_buffer *buffer,
198 unsigned long payload);
199int fw_iso_context_start(struct fw_iso_context *ctx,
200 int cycle, int sync, int tags);
201int fw_iso_context_stop(struct fw_iso_context *ctx);
202void fw_iso_context_destroy(struct fw_iso_context *ctx);
203
204void fw_iso_resource_manage(struct fw_card *card, int generation, 122void fw_iso_resource_manage(struct fw_card *card, int generation,
205 u64 channels_mask, int *channel, int *bandwidth, bool allocate); 123 u64 channels_mask, int *channel, int *bandwidth, bool allocate);
206 124
@@ -285,9 +203,4 @@ void fw_flush_transactions(struct fw_card *card);
285void fw_send_phy_config(struct fw_card *card, 203void fw_send_phy_config(struct fw_card *card,
286 int node_id, int generation, int gap_count); 204 int node_id, int generation, int gap_count);
287 205
288static inline int fw_stream_packet_destination_id(int tag, int channel, int sy)
289{
290 return tag << 14 | channel << 8 | sy;
291}
292
293#endif /* _FIREWIRE_CORE_H */ 206#endif /* _FIREWIRE_CORE_H */
diff --git a/drivers/firewire/net.c b/drivers/firewire/net.c
new file mode 100644
index 000000000000..a42209a73aed
--- /dev/null
+++ b/drivers/firewire/net.c
@@ -0,0 +1,1655 @@
1/*
2 * IPv4 over IEEE 1394, per RFC 2734
3 *
4 * Copyright (C) 2009 Jay Fenlason <fenlason@redhat.com>
5 *
6 * based on eth1394 by Ben Collins et al
7 */
8
9#include <linux/bug.h>
10#include <linux/device.h>
11#include <linux/ethtool.h>
12#include <linux/firewire.h>
13#include <linux/firewire-constants.h>
14#include <linux/highmem.h>
15#include <linux/in.h>
16#include <linux/ip.h>
17#include <linux/jiffies.h>
18#include <linux/mod_devicetable.h>
19#include <linux/module.h>
20#include <linux/moduleparam.h>
21#include <linux/mutex.h>
22#include <linux/netdevice.h>
23#include <linux/skbuff.h>
24#include <linux/spinlock.h>
25
26#include <asm/unaligned.h>
27#include <net/arp.h>
28
29#define FWNET_MAX_FRAGMENTS 25 /* arbitrary limit */
30#define FWNET_ISO_PAGE_COUNT (PAGE_SIZE < 16 * 1024 ? 4 : 2)
31
32#define IEEE1394_BROADCAST_CHANNEL 31
33#define IEEE1394_ALL_NODES (0xffc0 | 0x003f)
34#define IEEE1394_MAX_PAYLOAD_S100 512
35#define FWNET_NO_FIFO_ADDR (~0ULL)
36
37#define IANA_SPECIFIER_ID 0x00005eU
38#define RFC2734_SW_VERSION 0x000001U
39
40#define IEEE1394_GASP_HDR_SIZE 8
41
42#define RFC2374_UNFRAG_HDR_SIZE 4
43#define RFC2374_FRAG_HDR_SIZE 8
44#define RFC2374_FRAG_OVERHEAD 4
45
46#define RFC2374_HDR_UNFRAG 0 /* unfragmented */
47#define RFC2374_HDR_FIRSTFRAG 1 /* first fragment */
48#define RFC2374_HDR_LASTFRAG 2 /* last fragment */
49#define RFC2374_HDR_INTFRAG 3 /* interior fragment */
50
51#define RFC2734_HW_ADDR_LEN 16
52
53struct rfc2734_arp {
54 __be16 hw_type; /* 0x0018 */
55 __be16 proto_type; /* 0x0806 */
56 u8 hw_addr_len; /* 16 */
57 u8 ip_addr_len; /* 4 */
58 __be16 opcode; /* ARP Opcode */
59 /* Above is exactly the same format as struct arphdr */
60
61 __be64 s_uniq_id; /* Sender's 64bit EUI */
62 u8 max_rec; /* Sender's max packet size */
63 u8 sspd; /* Sender's max speed */
64 __be16 fifo_hi; /* hi 16bits of sender's FIFO addr */
65 __be32 fifo_lo; /* lo 32bits of sender's FIFO addr */
66 __be32 sip; /* Sender's IP Address */
67 __be32 tip; /* IP Address of requested hw addr */
68} __attribute__((packed));
69
70/* This header format is specific to this driver implementation. */
71#define FWNET_ALEN 8
72#define FWNET_HLEN 10
73struct fwnet_header {
74 u8 h_dest[FWNET_ALEN]; /* destination address */
75 __be16 h_proto; /* packet type ID field */
76} __attribute__((packed));
77
78/* IPv4 and IPv6 encapsulation header */
79struct rfc2734_header {
80 u32 w0;
81 u32 w1;
82};
83
84#define fwnet_get_hdr_lf(h) (((h)->w0 & 0xc0000000) >> 30)
85#define fwnet_get_hdr_ether_type(h) (((h)->w0 & 0x0000ffff))
86#define fwnet_get_hdr_dg_size(h) (((h)->w0 & 0x0fff0000) >> 16)
87#define fwnet_get_hdr_fg_off(h) (((h)->w0 & 0x00000fff))
88#define fwnet_get_hdr_dgl(h) (((h)->w1 & 0xffff0000) >> 16)
89
90#define fwnet_set_hdr_lf(lf) ((lf) << 30)
91#define fwnet_set_hdr_ether_type(et) (et)
92#define fwnet_set_hdr_dg_size(dgs) ((dgs) << 16)
93#define fwnet_set_hdr_fg_off(fgo) (fgo)
94
95#define fwnet_set_hdr_dgl(dgl) ((dgl) << 16)
96
97static inline void fwnet_make_uf_hdr(struct rfc2734_header *hdr,
98 unsigned ether_type)
99{
100 hdr->w0 = fwnet_set_hdr_lf(RFC2374_HDR_UNFRAG)
101 | fwnet_set_hdr_ether_type(ether_type);
102}
103
104static inline void fwnet_make_ff_hdr(struct rfc2734_header *hdr,
105 unsigned ether_type, unsigned dg_size, unsigned dgl)
106{
107 hdr->w0 = fwnet_set_hdr_lf(RFC2374_HDR_FIRSTFRAG)
108 | fwnet_set_hdr_dg_size(dg_size)
109 | fwnet_set_hdr_ether_type(ether_type);
110 hdr->w1 = fwnet_set_hdr_dgl(dgl);
111}
112
113static inline void fwnet_make_sf_hdr(struct rfc2734_header *hdr,
114 unsigned lf, unsigned dg_size, unsigned fg_off, unsigned dgl)
115{
116 hdr->w0 = fwnet_set_hdr_lf(lf)
117 | fwnet_set_hdr_dg_size(dg_size)
118 | fwnet_set_hdr_fg_off(fg_off);
119 hdr->w1 = fwnet_set_hdr_dgl(dgl);
120}
121
122/* This list keeps track of what parts of the datagram have been filled in */
123struct fwnet_fragment_info {
124 struct list_head fi_link;
125 u16 offset;
126 u16 len;
127};
128
129struct fwnet_partial_datagram {
130 struct list_head pd_link;
131 struct list_head fi_list;
132 struct sk_buff *skb;
133 /* FIXME Why not use skb->data? */
134 char *pbuf;
135 u16 datagram_label;
136 u16 ether_type;
137 u16 datagram_size;
138};
139
140static DEFINE_MUTEX(fwnet_device_mutex);
141static LIST_HEAD(fwnet_device_list);
142
143struct fwnet_device {
144 struct list_head dev_link;
145 spinlock_t lock;
146 enum {
147 FWNET_BROADCAST_ERROR,
148 FWNET_BROADCAST_RUNNING,
149 FWNET_BROADCAST_STOPPED,
150 } broadcast_state;
151 struct fw_iso_context *broadcast_rcv_context;
152 struct fw_iso_buffer broadcast_rcv_buffer;
153 void **broadcast_rcv_buffer_ptrs;
154 unsigned broadcast_rcv_next_ptr;
155 unsigned num_broadcast_rcv_ptrs;
156 unsigned rcv_buffer_size;
157 /*
158 * This value is the maximum unfragmented datagram size that can be
159 * sent by the hardware. It already has the GASP overhead and the
160 * unfragmented datagram header overhead calculated into it.
161 */
162 unsigned broadcast_xmt_max_payload;
163 u16 broadcast_xmt_datagramlabel;
164
165 /*
166 * The CSR address that remote nodes must send datagrams to for us to
167 * receive them.
168 */
169 struct fw_address_handler handler;
170 u64 local_fifo;
171
172 /* List of packets to be sent */
173 struct list_head packet_list;
174 /*
175 * List of packets that were broadcasted. When we get an ISO interrupt
176 * one of them has been sent
177 */
178 struct list_head broadcasted_list;
179 /* List of packets that have been sent but not yet acked */
180 struct list_head sent_list;
181
182 struct list_head peer_list;
183 struct fw_card *card;
184 struct net_device *netdev;
185};
186
187struct fwnet_peer {
188 struct list_head peer_link;
189 struct fwnet_device *dev;
190 u64 guid;
191 u64 fifo;
192
193 /* guarded by dev->lock */
194 struct list_head pd_list; /* received partial datagrams */
195 unsigned pdg_size; /* pd_list size */
196
197 u16 datagram_label; /* outgoing datagram label */
198 unsigned max_payload; /* includes RFC2374_FRAG_HDR_SIZE overhead */
199 int node_id;
200 int generation;
201 unsigned speed;
202};
203
204/* This is our task struct. It's used for the packet complete callback. */
205struct fwnet_packet_task {
206 /*
207 * ptask can actually be on dev->packet_list, dev->broadcasted_list,
208 * or dev->sent_list depending on its current state.
209 */
210 struct list_head pt_link;
211 struct fw_transaction transaction;
212 struct rfc2734_header hdr;
213 struct sk_buff *skb;
214 struct fwnet_device *dev;
215
216 int outstanding_pkts;
217 unsigned max_payload;
218 u64 fifo_addr;
219 u16 dest_node;
220 u8 generation;
221 u8 speed;
222};
223
224/*
225 * saddr == NULL means use device source address.
226 * daddr == NULL means leave destination address (eg unresolved arp).
227 */
228static int fwnet_header_create(struct sk_buff *skb, struct net_device *net,
229 unsigned short type, const void *daddr,
230 const void *saddr, unsigned len)
231{
232 struct fwnet_header *h;
233
234 h = (struct fwnet_header *)skb_push(skb, sizeof(*h));
235 put_unaligned_be16(type, &h->h_proto);
236
237 if (net->flags & (IFF_LOOPBACK | IFF_NOARP)) {
238 memset(h->h_dest, 0, net->addr_len);
239
240 return net->hard_header_len;
241 }
242
243 if (daddr) {
244 memcpy(h->h_dest, daddr, net->addr_len);
245
246 return net->hard_header_len;
247 }
248
249 return -net->hard_header_len;
250}
251
252static int fwnet_header_rebuild(struct sk_buff *skb)
253{
254 struct fwnet_header *h = (struct fwnet_header *)skb->data;
255
256 if (get_unaligned_be16(&h->h_proto) == ETH_P_IP)
257 return arp_find((unsigned char *)&h->h_dest, skb);
258
259 fw_notify("%s: unable to resolve type %04x addresses\n",
260 skb->dev->name, be16_to_cpu(h->h_proto));
261 return 0;
262}
263
264static int fwnet_header_cache(const struct neighbour *neigh,
265 struct hh_cache *hh)
266{
267 struct net_device *net;
268 struct fwnet_header *h;
269
270 if (hh->hh_type == cpu_to_be16(ETH_P_802_3))
271 return -1;
272 net = neigh->dev;
273 h = (struct fwnet_header *)((u8 *)hh->hh_data + 16 - sizeof(*h));
274 h->h_proto = hh->hh_type;
275 memcpy(h->h_dest, neigh->ha, net->addr_len);
276 hh->hh_len = FWNET_HLEN;
277
278 return 0;
279}
280
281/* Called by Address Resolution module to notify changes in address. */
282static void fwnet_header_cache_update(struct hh_cache *hh,
283 const struct net_device *net, const unsigned char *haddr)
284{
285 memcpy((u8 *)hh->hh_data + 16 - FWNET_HLEN, haddr, net->addr_len);
286}
287
288static int fwnet_header_parse(const struct sk_buff *skb, unsigned char *haddr)
289{
290 memcpy(haddr, skb->dev->dev_addr, FWNET_ALEN);
291
292 return FWNET_ALEN;
293}
294
295static const struct header_ops fwnet_header_ops = {
296 .create = fwnet_header_create,
297 .rebuild = fwnet_header_rebuild,
298 .cache = fwnet_header_cache,
299 .cache_update = fwnet_header_cache_update,
300 .parse = fwnet_header_parse,
301};
302
303/* FIXME: is this correct for all cases? */
304static bool fwnet_frag_overlap(struct fwnet_partial_datagram *pd,
305 unsigned offset, unsigned len)
306{
307 struct fwnet_fragment_info *fi;
308 unsigned end = offset + len;
309
310 list_for_each_entry(fi, &pd->fi_list, fi_link)
311 if (offset < fi->offset + fi->len && end > fi->offset)
312 return true;
313
314 return false;
315}
316
317/* Assumes that new fragment does not overlap any existing fragments */
318static struct fwnet_fragment_info *fwnet_frag_new(
319 struct fwnet_partial_datagram *pd, unsigned offset, unsigned len)
320{
321 struct fwnet_fragment_info *fi, *fi2, *new;
322 struct list_head *list;
323
324 list = &pd->fi_list;
325 list_for_each_entry(fi, &pd->fi_list, fi_link) {
326 if (fi->offset + fi->len == offset) {
327 /* The new fragment can be tacked on to the end */
328 /* Did the new fragment plug a hole? */
329 fi2 = list_entry(fi->fi_link.next,
330 struct fwnet_fragment_info, fi_link);
331 if (fi->offset + fi->len == fi2->offset) {
332 /* glue fragments together */
333 fi->len += len + fi2->len;
334 list_del(&fi2->fi_link);
335 kfree(fi2);
336 } else {
337 fi->len += len;
338 }
339
340 return fi;
341 }
342 if (offset + len == fi->offset) {
343 /* The new fragment can be tacked on to the beginning */
344 /* Did the new fragment plug a hole? */
345 fi2 = list_entry(fi->fi_link.prev,
346 struct fwnet_fragment_info, fi_link);
347 if (fi2->offset + fi2->len == fi->offset) {
348 /* glue fragments together */
349 fi2->len += fi->len + len;
350 list_del(&fi->fi_link);
351 kfree(fi);
352
353 return fi2;
354 }
355 fi->offset = offset;
356 fi->len += len;
357
358 return fi;
359 }
360 if (offset > fi->offset + fi->len) {
361 list = &fi->fi_link;
362 break;
363 }
364 if (offset + len < fi->offset) {
365 list = fi->fi_link.prev;
366 break;
367 }
368 }
369
370 new = kmalloc(sizeof(*new), GFP_ATOMIC);
371 if (!new) {
372 fw_error("out of memory\n");
373 return NULL;
374 }
375
376 new->offset = offset;
377 new->len = len;
378 list_add(&new->fi_link, list);
379
380 return new;
381}
382
383static struct fwnet_partial_datagram *fwnet_pd_new(struct net_device *net,
384 struct fwnet_peer *peer, u16 datagram_label, unsigned dg_size,
385 void *frag_buf, unsigned frag_off, unsigned frag_len)
386{
387 struct fwnet_partial_datagram *new;
388 struct fwnet_fragment_info *fi;
389
390 new = kmalloc(sizeof(*new), GFP_ATOMIC);
391 if (!new)
392 goto fail;
393
394 INIT_LIST_HEAD(&new->fi_list);
395 fi = fwnet_frag_new(new, frag_off, frag_len);
396 if (fi == NULL)
397 goto fail_w_new;
398
399 new->datagram_label = datagram_label;
400 new->datagram_size = dg_size;
401 new->skb = dev_alloc_skb(dg_size + net->hard_header_len + 15);
402 if (new->skb == NULL)
403 goto fail_w_fi;
404
405 skb_reserve(new->skb, (net->hard_header_len + 15) & ~15);
406 new->pbuf = skb_put(new->skb, dg_size);
407 memcpy(new->pbuf + frag_off, frag_buf, frag_len);
408 list_add_tail(&new->pd_link, &peer->pd_list);
409
410 return new;
411
412fail_w_fi:
413 kfree(fi);
414fail_w_new:
415 kfree(new);
416fail:
417 fw_error("out of memory\n");
418
419 return NULL;
420}
421
422static struct fwnet_partial_datagram *fwnet_pd_find(struct fwnet_peer *peer,
423 u16 datagram_label)
424{
425 struct fwnet_partial_datagram *pd;
426
427 list_for_each_entry(pd, &peer->pd_list, pd_link)
428 if (pd->datagram_label == datagram_label)
429 return pd;
430
431 return NULL;
432}
433
434
435static void fwnet_pd_delete(struct fwnet_partial_datagram *old)
436{
437 struct fwnet_fragment_info *fi, *n;
438
439 list_for_each_entry_safe(fi, n, &old->fi_list, fi_link)
440 kfree(fi);
441
442 list_del(&old->pd_link);
443 dev_kfree_skb_any(old->skb);
444 kfree(old);
445}
446
447static bool fwnet_pd_update(struct fwnet_peer *peer,
448 struct fwnet_partial_datagram *pd, void *frag_buf,
449 unsigned frag_off, unsigned frag_len)
450{
451 if (fwnet_frag_new(pd, frag_off, frag_len) == NULL)
452 return false;
453
454 memcpy(pd->pbuf + frag_off, frag_buf, frag_len);
455
456 /*
457 * Move list entry to beginnig of list so that oldest partial
458 * datagrams percolate to the end of the list
459 */
460 list_move_tail(&pd->pd_link, &peer->pd_list);
461
462 return true;
463}
464
465static bool fwnet_pd_is_complete(struct fwnet_partial_datagram *pd)
466{
467 struct fwnet_fragment_info *fi;
468
469 fi = list_entry(pd->fi_list.next, struct fwnet_fragment_info, fi_link);
470
471 return fi->len == pd->datagram_size;
472}
473
474/* caller must hold dev->lock */
475static struct fwnet_peer *fwnet_peer_find_by_guid(struct fwnet_device *dev,
476 u64 guid)
477{
478 struct fwnet_peer *peer;
479
480 list_for_each_entry(peer, &dev->peer_list, peer_link)
481 if (peer->guid == guid)
482 return peer;
483
484 return NULL;
485}
486
487/* caller must hold dev->lock */
488static struct fwnet_peer *fwnet_peer_find_by_node_id(struct fwnet_device *dev,
489 int node_id, int generation)
490{
491 struct fwnet_peer *peer;
492
493 list_for_each_entry(peer, &dev->peer_list, peer_link)
494 if (peer->node_id == node_id &&
495 peer->generation == generation)
496 return peer;
497
498 return NULL;
499}
500
501/* See IEEE 1394-2008 table 6-4, table 8-8, table 16-18. */
502static unsigned fwnet_max_payload(unsigned max_rec, unsigned speed)
503{
504 max_rec = min(max_rec, speed + 8);
505 max_rec = min(max_rec, 0xbU); /* <= 4096 */
506 if (max_rec < 8) {
507 fw_notify("max_rec %x out of range\n", max_rec);
508 max_rec = 8;
509 }
510
511 return (1 << (max_rec + 1)) - RFC2374_FRAG_HDR_SIZE;
512}
513
514
515static int fwnet_finish_incoming_packet(struct net_device *net,
516 struct sk_buff *skb, u16 source_node_id,
517 bool is_broadcast, u16 ether_type)
518{
519 struct fwnet_device *dev;
520 static const __be64 broadcast_hw = cpu_to_be64(~0ULL);
521 int status;
522 __be64 guid;
523
524 dev = netdev_priv(net);
525 /* Write metadata, and then pass to the receive level */
526 skb->dev = net;
527 skb->ip_summed = CHECKSUM_UNNECESSARY; /* don't check it */
528
529 /*
530 * Parse the encapsulation header. This actually does the job of
531 * converting to an ethernet frame header, as well as arp
532 * conversion if needed. ARP conversion is easier in this
533 * direction, since we are using ethernet as our backend.
534 */
535 /*
536 * If this is an ARP packet, convert it. First, we want to make
537 * use of some of the fields, since they tell us a little bit
538 * about the sending machine.
539 */
540 if (ether_type == ETH_P_ARP) {
541 struct rfc2734_arp *arp1394;
542 struct arphdr *arp;
543 unsigned char *arp_ptr;
544 u64 fifo_addr;
545 u64 peer_guid;
546 unsigned sspd;
547 u16 max_payload;
548 struct fwnet_peer *peer;
549 unsigned long flags;
550
551 arp1394 = (struct rfc2734_arp *)skb->data;
552 arp = (struct arphdr *)skb->data;
553 arp_ptr = (unsigned char *)(arp + 1);
554 peer_guid = get_unaligned_be64(&arp1394->s_uniq_id);
555 fifo_addr = (u64)get_unaligned_be16(&arp1394->fifo_hi) << 32
556 | get_unaligned_be32(&arp1394->fifo_lo);
557
558 sspd = arp1394->sspd;
559 /* Sanity check. OS X 10.3 PPC reportedly sends 131. */
560 if (sspd > SCODE_3200) {
561 fw_notify("sspd %x out of range\n", sspd);
562 sspd = SCODE_3200;
563 }
564 max_payload = fwnet_max_payload(arp1394->max_rec, sspd);
565
566 spin_lock_irqsave(&dev->lock, flags);
567 peer = fwnet_peer_find_by_guid(dev, peer_guid);
568 if (peer) {
569 peer->fifo = fifo_addr;
570
571 if (peer->speed > sspd)
572 peer->speed = sspd;
573 if (peer->max_payload > max_payload)
574 peer->max_payload = max_payload;
575 }
576 spin_unlock_irqrestore(&dev->lock, flags);
577
578 if (!peer) {
579 fw_notify("No peer for ARP packet from %016llx\n",
580 (unsigned long long)peer_guid);
581 goto failed_proto;
582 }
583
584 /*
585 * Now that we're done with the 1394 specific stuff, we'll
586 * need to alter some of the data. Believe it or not, all
587 * that needs to be done is sender_IP_address needs to be
588 * moved, the destination hardware address get stuffed
589 * in and the hardware address length set to 8.
590 *
591 * IMPORTANT: The code below overwrites 1394 specific data
592 * needed above so keep the munging of the data for the
593 * higher level IP stack last.
594 */
595
596 arp->ar_hln = 8;
597 /* skip over sender unique id */
598 arp_ptr += arp->ar_hln;
599 /* move sender IP addr */
600 put_unaligned(arp1394->sip, (u32 *)arp_ptr);
601 /* skip over sender IP addr */
602 arp_ptr += arp->ar_pln;
603
604 if (arp->ar_op == htons(ARPOP_REQUEST))
605 memset(arp_ptr, 0, sizeof(u64));
606 else
607 memcpy(arp_ptr, net->dev_addr, sizeof(u64));
608 }
609
610 /* Now add the ethernet header. */
611 guid = cpu_to_be64(dev->card->guid);
612 if (dev_hard_header(skb, net, ether_type,
613 is_broadcast ? &broadcast_hw : &guid,
614 NULL, skb->len) >= 0) {
615 struct fwnet_header *eth;
616 u16 *rawp;
617 __be16 protocol;
618
619 skb_reset_mac_header(skb);
620 skb_pull(skb, sizeof(*eth));
621 eth = (struct fwnet_header *)skb_mac_header(skb);
622 if (*eth->h_dest & 1) {
623 if (memcmp(eth->h_dest, net->broadcast,
624 net->addr_len) == 0)
625 skb->pkt_type = PACKET_BROADCAST;
626#if 0
627 else
628 skb->pkt_type = PACKET_MULTICAST;
629#endif
630 } else {
631 if (memcmp(eth->h_dest, net->dev_addr, net->addr_len))
632 skb->pkt_type = PACKET_OTHERHOST;
633 }
634 if (ntohs(eth->h_proto) >= 1536) {
635 protocol = eth->h_proto;
636 } else {
637 rawp = (u16 *)skb->data;
638 if (*rawp == 0xffff)
639 protocol = htons(ETH_P_802_3);
640 else
641 protocol = htons(ETH_P_802_2);
642 }
643 skb->protocol = protocol;
644 }
645 status = netif_rx(skb);
646 if (status == NET_RX_DROP) {
647 net->stats.rx_errors++;
648 net->stats.rx_dropped++;
649 } else {
650 net->stats.rx_packets++;
651 net->stats.rx_bytes += skb->len;
652 }
653 if (netif_queue_stopped(net))
654 netif_wake_queue(net);
655
656 return 0;
657
658 failed_proto:
659 net->stats.rx_errors++;
660 net->stats.rx_dropped++;
661
662 dev_kfree_skb_any(skb);
663 if (netif_queue_stopped(net))
664 netif_wake_queue(net);
665
666 net->last_rx = jiffies;
667
668 return 0;
669}
670
671static int fwnet_incoming_packet(struct fwnet_device *dev, __be32 *buf, int len,
672 int source_node_id, int generation,
673 bool is_broadcast)
674{
675 struct sk_buff *skb;
676 struct net_device *net = dev->netdev;
677 struct rfc2734_header hdr;
678 unsigned lf;
679 unsigned long flags;
680 struct fwnet_peer *peer;
681 struct fwnet_partial_datagram *pd;
682 int fg_off;
683 int dg_size;
684 u16 datagram_label;
685 int retval;
686 u16 ether_type;
687
688 hdr.w0 = be32_to_cpu(buf[0]);
689 lf = fwnet_get_hdr_lf(&hdr);
690 if (lf == RFC2374_HDR_UNFRAG) {
691 /*
692 * An unfragmented datagram has been received by the ieee1394
693 * bus. Build an skbuff around it so we can pass it to the
694 * high level network layer.
695 */
696 ether_type = fwnet_get_hdr_ether_type(&hdr);
697 buf++;
698 len -= RFC2374_UNFRAG_HDR_SIZE;
699
700 skb = dev_alloc_skb(len + net->hard_header_len + 15);
701 if (unlikely(!skb)) {
702 fw_error("out of memory\n");
703 net->stats.rx_dropped++;
704
705 return -1;
706 }
707 skb_reserve(skb, (net->hard_header_len + 15) & ~15);
708 memcpy(skb_put(skb, len), buf, len);
709
710 return fwnet_finish_incoming_packet(net, skb, source_node_id,
711 is_broadcast, ether_type);
712 }
713 /* A datagram fragment has been received, now the fun begins. */
714 hdr.w1 = ntohl(buf[1]);
715 buf += 2;
716 len -= RFC2374_FRAG_HDR_SIZE;
717 if (lf == RFC2374_HDR_FIRSTFRAG) {
718 ether_type = fwnet_get_hdr_ether_type(&hdr);
719 fg_off = 0;
720 } else {
721 ether_type = 0;
722 fg_off = fwnet_get_hdr_fg_off(&hdr);
723 }
724 datagram_label = fwnet_get_hdr_dgl(&hdr);
725 dg_size = fwnet_get_hdr_dg_size(&hdr); /* ??? + 1 */
726
727 spin_lock_irqsave(&dev->lock, flags);
728
729 peer = fwnet_peer_find_by_node_id(dev, source_node_id, generation);
730 if (!peer)
731 goto bad_proto;
732
733 pd = fwnet_pd_find(peer, datagram_label);
734 if (pd == NULL) {
735 while (peer->pdg_size >= FWNET_MAX_FRAGMENTS) {
736 /* remove the oldest */
737 fwnet_pd_delete(list_first_entry(&peer->pd_list,
738 struct fwnet_partial_datagram, pd_link));
739 peer->pdg_size--;
740 }
741 pd = fwnet_pd_new(net, peer, datagram_label,
742 dg_size, buf, fg_off, len);
743 if (pd == NULL) {
744 retval = -ENOMEM;
745 goto bad_proto;
746 }
747 peer->pdg_size++;
748 } else {
749 if (fwnet_frag_overlap(pd, fg_off, len) ||
750 pd->datagram_size != dg_size) {
751 /*
752 * Differing datagram sizes or overlapping fragments,
753 * discard old datagram and start a new one.
754 */
755 fwnet_pd_delete(pd);
756 pd = fwnet_pd_new(net, peer, datagram_label,
757 dg_size, buf, fg_off, len);
758 if (pd == NULL) {
759 retval = -ENOMEM;
760 peer->pdg_size--;
761 goto bad_proto;
762 }
763 } else {
764 if (!fwnet_pd_update(peer, pd, buf, fg_off, len)) {
765 /*
766 * Couldn't save off fragment anyway
767 * so might as well obliterate the
768 * datagram now.
769 */
770 fwnet_pd_delete(pd);
771 peer->pdg_size--;
772 goto bad_proto;
773 }
774 }
775 } /* new datagram or add to existing one */
776
777 if (lf == RFC2374_HDR_FIRSTFRAG)
778 pd->ether_type = ether_type;
779
780 if (fwnet_pd_is_complete(pd)) {
781 ether_type = pd->ether_type;
782 peer->pdg_size--;
783 skb = skb_get(pd->skb);
784 fwnet_pd_delete(pd);
785
786 spin_unlock_irqrestore(&dev->lock, flags);
787
788 return fwnet_finish_incoming_packet(net, skb, source_node_id,
789 false, ether_type);
790 }
791 /*
792 * Datagram is not complete, we're done for the
793 * moment.
794 */
795 spin_unlock_irqrestore(&dev->lock, flags);
796
797 return 0;
798
799 bad_proto:
800 spin_unlock_irqrestore(&dev->lock, flags);
801
802 if (netif_queue_stopped(net))
803 netif_wake_queue(net);
804
805 return 0;
806}
807
808static void fwnet_receive_packet(struct fw_card *card, struct fw_request *r,
809 int tcode, int destination, int source, int generation,
810 int speed, unsigned long long offset, void *payload,
811 size_t length, void *callback_data)
812{
813 struct fwnet_device *dev = callback_data;
814 int rcode;
815
816 if (destination == IEEE1394_ALL_NODES) {
817 kfree(r);
818
819 return;
820 }
821
822 if (offset != dev->handler.offset)
823 rcode = RCODE_ADDRESS_ERROR;
824 else if (tcode != TCODE_WRITE_BLOCK_REQUEST)
825 rcode = RCODE_TYPE_ERROR;
826 else if (fwnet_incoming_packet(dev, payload, length,
827 source, generation, false) != 0) {
828 fw_error("Incoming packet failure\n");
829 rcode = RCODE_CONFLICT_ERROR;
830 } else
831 rcode = RCODE_COMPLETE;
832
833 fw_send_response(card, r, rcode);
834}
835
836static void fwnet_receive_broadcast(struct fw_iso_context *context,
837 u32 cycle, size_t header_length, void *header, void *data)
838{
839 struct fwnet_device *dev;
840 struct fw_iso_packet packet;
841 struct fw_card *card;
842 __be16 *hdr_ptr;
843 __be32 *buf_ptr;
844 int retval;
845 u32 length;
846 u16 source_node_id;
847 u32 specifier_id;
848 u32 ver;
849 unsigned long offset;
850 unsigned long flags;
851
852 dev = data;
853 card = dev->card;
854 hdr_ptr = header;
855 length = be16_to_cpup(hdr_ptr);
856
857 spin_lock_irqsave(&dev->lock, flags);
858
859 offset = dev->rcv_buffer_size * dev->broadcast_rcv_next_ptr;
860 buf_ptr = dev->broadcast_rcv_buffer_ptrs[dev->broadcast_rcv_next_ptr++];
861 if (dev->broadcast_rcv_next_ptr == dev->num_broadcast_rcv_ptrs)
862 dev->broadcast_rcv_next_ptr = 0;
863
864 spin_unlock_irqrestore(&dev->lock, flags);
865
866 specifier_id = (be32_to_cpu(buf_ptr[0]) & 0xffff) << 8
867 | (be32_to_cpu(buf_ptr[1]) & 0xff000000) >> 24;
868 ver = be32_to_cpu(buf_ptr[1]) & 0xffffff;
869 source_node_id = be32_to_cpu(buf_ptr[0]) >> 16;
870
871 if (specifier_id == IANA_SPECIFIER_ID && ver == RFC2734_SW_VERSION) {
872 buf_ptr += 2;
873 length -= IEEE1394_GASP_HDR_SIZE;
874 fwnet_incoming_packet(dev, buf_ptr, length,
875 source_node_id, -1, true);
876 }
877
878 packet.payload_length = dev->rcv_buffer_size;
879 packet.interrupt = 1;
880 packet.skip = 0;
881 packet.tag = 3;
882 packet.sy = 0;
883 packet.header_length = IEEE1394_GASP_HDR_SIZE;
884
885 spin_lock_irqsave(&dev->lock, flags);
886
887 retval = fw_iso_context_queue(dev->broadcast_rcv_context, &packet,
888 &dev->broadcast_rcv_buffer, offset);
889
890 spin_unlock_irqrestore(&dev->lock, flags);
891
892 if (retval < 0)
893 fw_error("requeue failed\n");
894}
895
896static struct kmem_cache *fwnet_packet_task_cache;
897
898static int fwnet_send_packet(struct fwnet_packet_task *ptask);
899
900static void fwnet_transmit_packet_done(struct fwnet_packet_task *ptask)
901{
902 struct fwnet_device *dev;
903 unsigned long flags;
904
905 dev = ptask->dev;
906
907 spin_lock_irqsave(&dev->lock, flags);
908 list_del(&ptask->pt_link);
909 spin_unlock_irqrestore(&dev->lock, flags);
910
911 ptask->outstanding_pkts--; /* FIXME access inside lock */
912
913 if (ptask->outstanding_pkts > 0) {
914 u16 dg_size;
915 u16 fg_off;
916 u16 datagram_label;
917 u16 lf;
918 struct sk_buff *skb;
919
920 /* Update the ptask to point to the next fragment and send it */
921 lf = fwnet_get_hdr_lf(&ptask->hdr);
922 switch (lf) {
923 case RFC2374_HDR_LASTFRAG:
924 case RFC2374_HDR_UNFRAG:
925 default:
926 fw_error("Outstanding packet %x lf %x, header %x,%x\n",
927 ptask->outstanding_pkts, lf, ptask->hdr.w0,
928 ptask->hdr.w1);
929 BUG();
930
931 case RFC2374_HDR_FIRSTFRAG:
932 /* Set frag type here for future interior fragments */
933 dg_size = fwnet_get_hdr_dg_size(&ptask->hdr);
934 fg_off = ptask->max_payload - RFC2374_FRAG_HDR_SIZE;
935 datagram_label = fwnet_get_hdr_dgl(&ptask->hdr);
936 break;
937
938 case RFC2374_HDR_INTFRAG:
939 dg_size = fwnet_get_hdr_dg_size(&ptask->hdr);
940 fg_off = fwnet_get_hdr_fg_off(&ptask->hdr)
941 + ptask->max_payload - RFC2374_FRAG_HDR_SIZE;
942 datagram_label = fwnet_get_hdr_dgl(&ptask->hdr);
943 break;
944 }
945 skb = ptask->skb;
946 skb_pull(skb, ptask->max_payload);
947 if (ptask->outstanding_pkts > 1) {
948 fwnet_make_sf_hdr(&ptask->hdr, RFC2374_HDR_INTFRAG,
949 dg_size, fg_off, datagram_label);
950 } else {
951 fwnet_make_sf_hdr(&ptask->hdr, RFC2374_HDR_LASTFRAG,
952 dg_size, fg_off, datagram_label);
953 ptask->max_payload = skb->len + RFC2374_FRAG_HDR_SIZE;
954 }
955 fwnet_send_packet(ptask);
956 } else {
957 dev_kfree_skb_any(ptask->skb);
958 kmem_cache_free(fwnet_packet_task_cache, ptask);
959 }
960}
961
962static void fwnet_write_complete(struct fw_card *card, int rcode,
963 void *payload, size_t length, void *data)
964{
965 struct fwnet_packet_task *ptask;
966
967 ptask = data;
968
969 if (rcode == RCODE_COMPLETE)
970 fwnet_transmit_packet_done(ptask);
971 else
972 fw_error("fwnet_write_complete: failed: %x\n", rcode);
973 /* ??? error recovery */
974}
975
976static int fwnet_send_packet(struct fwnet_packet_task *ptask)
977{
978 struct fwnet_device *dev;
979 unsigned tx_len;
980 struct rfc2734_header *bufhdr;
981 unsigned long flags;
982
983 dev = ptask->dev;
984 tx_len = ptask->max_payload;
985 switch (fwnet_get_hdr_lf(&ptask->hdr)) {
986 case RFC2374_HDR_UNFRAG:
987 bufhdr = (struct rfc2734_header *)
988 skb_push(ptask->skb, RFC2374_UNFRAG_HDR_SIZE);
989 put_unaligned_be32(ptask->hdr.w0, &bufhdr->w0);
990 break;
991
992 case RFC2374_HDR_FIRSTFRAG:
993 case RFC2374_HDR_INTFRAG:
994 case RFC2374_HDR_LASTFRAG:
995 bufhdr = (struct rfc2734_header *)
996 skb_push(ptask->skb, RFC2374_FRAG_HDR_SIZE);
997 put_unaligned_be32(ptask->hdr.w0, &bufhdr->w0);
998 put_unaligned_be32(ptask->hdr.w1, &bufhdr->w1);
999 break;
1000
1001 default:
1002 BUG();
1003 }
1004 if (ptask->dest_node == IEEE1394_ALL_NODES) {
1005 u8 *p;
1006 int generation;
1007 int node_id;
1008
1009 /* ptask->generation may not have been set yet */
1010 generation = dev->card->generation;
1011 smp_rmb();
1012 node_id = dev->card->node_id;
1013
1014 p = skb_push(ptask->skb, 8);
1015 put_unaligned_be32(node_id << 16 | IANA_SPECIFIER_ID >> 8, p);
1016 put_unaligned_be32((IANA_SPECIFIER_ID & 0xff) << 24
1017 | RFC2734_SW_VERSION, &p[4]);
1018
1019 /* We should not transmit if broadcast_channel.valid == 0. */
1020 fw_send_request(dev->card, &ptask->transaction,
1021 TCODE_STREAM_DATA,
1022 fw_stream_packet_destination_id(3,
1023 IEEE1394_BROADCAST_CHANNEL, 0),
1024 generation, SCODE_100, 0ULL, ptask->skb->data,
1025 tx_len + 8, fwnet_write_complete, ptask);
1026
1027 /* FIXME race? */
1028 spin_lock_irqsave(&dev->lock, flags);
1029 list_add_tail(&ptask->pt_link, &dev->broadcasted_list);
1030 spin_unlock_irqrestore(&dev->lock, flags);
1031
1032 return 0;
1033 }
1034
1035 fw_send_request(dev->card, &ptask->transaction,
1036 TCODE_WRITE_BLOCK_REQUEST, ptask->dest_node,
1037 ptask->generation, ptask->speed, ptask->fifo_addr,
1038 ptask->skb->data, tx_len, fwnet_write_complete, ptask);
1039
1040 /* FIXME race? */
1041 spin_lock_irqsave(&dev->lock, flags);
1042 list_add_tail(&ptask->pt_link, &dev->sent_list);
1043 spin_unlock_irqrestore(&dev->lock, flags);
1044
1045 dev->netdev->trans_start = jiffies;
1046
1047 return 0;
1048}
1049
1050static int fwnet_broadcast_start(struct fwnet_device *dev)
1051{
1052 struct fw_iso_context *context;
1053 int retval;
1054 unsigned num_packets;
1055 unsigned max_receive;
1056 struct fw_iso_packet packet;
1057 unsigned long offset;
1058 unsigned u;
1059
1060 if (dev->local_fifo == FWNET_NO_FIFO_ADDR) {
1061 /* outside OHCI posted write area? */
1062 static const struct fw_address_region region = {
1063 .start = 0xffff00000000ULL,
1064 .end = CSR_REGISTER_BASE,
1065 };
1066
1067 dev->handler.length = 4096;
1068 dev->handler.address_callback = fwnet_receive_packet;
1069 dev->handler.callback_data = dev;
1070
1071 retval = fw_core_add_address_handler(&dev->handler, &region);
1072 if (retval < 0)
1073 goto failed_initial;
1074
1075 dev->local_fifo = dev->handler.offset;
1076 }
1077
1078 max_receive = 1U << (dev->card->max_receive + 1);
1079 num_packets = (FWNET_ISO_PAGE_COUNT * PAGE_SIZE) / max_receive;
1080
1081 if (!dev->broadcast_rcv_context) {
1082 void **ptrptr;
1083
1084 context = fw_iso_context_create(dev->card,
1085 FW_ISO_CONTEXT_RECEIVE, IEEE1394_BROADCAST_CHANNEL,
1086 dev->card->link_speed, 8, fwnet_receive_broadcast, dev);
1087 if (IS_ERR(context)) {
1088 retval = PTR_ERR(context);
1089 goto failed_context_create;
1090 }
1091
1092 retval = fw_iso_buffer_init(&dev->broadcast_rcv_buffer,
1093 dev->card, FWNET_ISO_PAGE_COUNT, DMA_FROM_DEVICE);
1094 if (retval < 0)
1095 goto failed_buffer_init;
1096
1097 ptrptr = kmalloc(sizeof(void *) * num_packets, GFP_KERNEL);
1098 if (!ptrptr) {
1099 retval = -ENOMEM;
1100 goto failed_ptrs_alloc;
1101 }
1102
1103 dev->broadcast_rcv_buffer_ptrs = ptrptr;
1104 for (u = 0; u < FWNET_ISO_PAGE_COUNT; u++) {
1105 void *ptr;
1106 unsigned v;
1107
1108 ptr = kmap(dev->broadcast_rcv_buffer.pages[u]);
1109 for (v = 0; v < num_packets / FWNET_ISO_PAGE_COUNT; v++)
1110 *ptrptr++ = (void *)
1111 ((char *)ptr + v * max_receive);
1112 }
1113 dev->broadcast_rcv_context = context;
1114 } else {
1115 context = dev->broadcast_rcv_context;
1116 }
1117
1118 packet.payload_length = max_receive;
1119 packet.interrupt = 1;
1120 packet.skip = 0;
1121 packet.tag = 3;
1122 packet.sy = 0;
1123 packet.header_length = IEEE1394_GASP_HDR_SIZE;
1124 offset = 0;
1125
1126 for (u = 0; u < num_packets; u++) {
1127 retval = fw_iso_context_queue(context, &packet,
1128 &dev->broadcast_rcv_buffer, offset);
1129 if (retval < 0)
1130 goto failed_rcv_queue;
1131
1132 offset += max_receive;
1133 }
1134 dev->num_broadcast_rcv_ptrs = num_packets;
1135 dev->rcv_buffer_size = max_receive;
1136 dev->broadcast_rcv_next_ptr = 0U;
1137 retval = fw_iso_context_start(context, -1, 0,
1138 FW_ISO_CONTEXT_MATCH_ALL_TAGS); /* ??? sync */
1139 if (retval < 0)
1140 goto failed_rcv_queue;
1141
1142 /* FIXME: adjust it according to the min. speed of all known peers? */
1143 dev->broadcast_xmt_max_payload = IEEE1394_MAX_PAYLOAD_S100
1144 - IEEE1394_GASP_HDR_SIZE - RFC2374_UNFRAG_HDR_SIZE;
1145 dev->broadcast_state = FWNET_BROADCAST_RUNNING;
1146
1147 return 0;
1148
1149 failed_rcv_queue:
1150 kfree(dev->broadcast_rcv_buffer_ptrs);
1151 dev->broadcast_rcv_buffer_ptrs = NULL;
1152 failed_ptrs_alloc:
1153 fw_iso_buffer_destroy(&dev->broadcast_rcv_buffer, dev->card);
1154 failed_buffer_init:
1155 fw_iso_context_destroy(context);
1156 dev->broadcast_rcv_context = NULL;
1157 failed_context_create:
1158 fw_core_remove_address_handler(&dev->handler);
1159 failed_initial:
1160 dev->local_fifo = FWNET_NO_FIFO_ADDR;
1161
1162 return retval;
1163}
1164
1165/* ifup */
1166static int fwnet_open(struct net_device *net)
1167{
1168 struct fwnet_device *dev = netdev_priv(net);
1169 int ret;
1170
1171 if (dev->broadcast_state == FWNET_BROADCAST_ERROR) {
1172 ret = fwnet_broadcast_start(dev);
1173 if (ret)
1174 return ret;
1175 }
1176 netif_start_queue(net);
1177
1178 return 0;
1179}
1180
1181/* ifdown */
1182static int fwnet_stop(struct net_device *net)
1183{
1184 netif_stop_queue(net);
1185
1186 /* Deallocate iso context for use by other applications? */
1187
1188 return 0;
1189}
1190
1191static int fwnet_tx(struct sk_buff *skb, struct net_device *net)
1192{
1193 struct fwnet_header hdr_buf;
1194 struct fwnet_device *dev = netdev_priv(net);
1195 __be16 proto;
1196 u16 dest_node;
1197 unsigned max_payload;
1198 u16 dg_size;
1199 u16 *datagram_label_ptr;
1200 struct fwnet_packet_task *ptask;
1201 struct fwnet_peer *peer;
1202 unsigned long flags;
1203
1204 ptask = kmem_cache_alloc(fwnet_packet_task_cache, GFP_ATOMIC);
1205 if (ptask == NULL)
1206 goto fail;
1207
1208 skb = skb_share_check(skb, GFP_ATOMIC);
1209 if (!skb)
1210 goto fail;
1211
1212 /*
1213 * Make a copy of the driver-specific header.
1214 * We might need to rebuild the header on tx failure.
1215 */
1216 memcpy(&hdr_buf, skb->data, sizeof(hdr_buf));
1217 skb_pull(skb, sizeof(hdr_buf));
1218
1219 proto = hdr_buf.h_proto;
1220 dg_size = skb->len;
1221
1222 /* serialize access to peer, including peer->datagram_label */
1223 spin_lock_irqsave(&dev->lock, flags);
1224
1225 /*
1226 * Set the transmission type for the packet. ARP packets and IP
1227 * broadcast packets are sent via GASP.
1228 */
1229 if (memcmp(hdr_buf.h_dest, net->broadcast, FWNET_ALEN) == 0
1230 || proto == htons(ETH_P_ARP)
1231 || (proto == htons(ETH_P_IP)
1232 && IN_MULTICAST(ntohl(ip_hdr(skb)->daddr)))) {
1233 max_payload = dev->broadcast_xmt_max_payload;
1234 datagram_label_ptr = &dev->broadcast_xmt_datagramlabel;
1235
1236 ptask->fifo_addr = FWNET_NO_FIFO_ADDR;
1237 ptask->generation = 0;
1238 ptask->dest_node = IEEE1394_ALL_NODES;
1239 ptask->speed = SCODE_100;
1240 } else {
1241 __be64 guid = get_unaligned((__be64 *)hdr_buf.h_dest);
1242 u8 generation;
1243
1244 peer = fwnet_peer_find_by_guid(dev, be64_to_cpu(guid));
1245 if (!peer || peer->fifo == FWNET_NO_FIFO_ADDR)
1246 goto fail_unlock;
1247
1248 generation = peer->generation;
1249 dest_node = peer->node_id;
1250 max_payload = peer->max_payload;
1251 datagram_label_ptr = &peer->datagram_label;
1252
1253 ptask->fifo_addr = peer->fifo;
1254 ptask->generation = generation;
1255 ptask->dest_node = dest_node;
1256 ptask->speed = peer->speed;
1257 }
1258
1259 /* If this is an ARP packet, convert it */
1260 if (proto == htons(ETH_P_ARP)) {
1261 struct arphdr *arp = (struct arphdr *)skb->data;
1262 unsigned char *arp_ptr = (unsigned char *)(arp + 1);
1263 struct rfc2734_arp *arp1394 = (struct rfc2734_arp *)skb->data;
1264 __be32 ipaddr;
1265
1266 ipaddr = get_unaligned((__be32 *)(arp_ptr + FWNET_ALEN));
1267
1268 arp1394->hw_addr_len = RFC2734_HW_ADDR_LEN;
1269 arp1394->max_rec = dev->card->max_receive;
1270 arp1394->sspd = dev->card->link_speed;
1271
1272 put_unaligned_be16(dev->local_fifo >> 32,
1273 &arp1394->fifo_hi);
1274 put_unaligned_be32(dev->local_fifo & 0xffffffff,
1275 &arp1394->fifo_lo);
1276 put_unaligned(ipaddr, &arp1394->sip);
1277 }
1278
1279 ptask->hdr.w0 = 0;
1280 ptask->hdr.w1 = 0;
1281 ptask->skb = skb;
1282 ptask->dev = dev;
1283
1284 /* Does it all fit in one packet? */
1285 if (dg_size <= max_payload) {
1286 fwnet_make_uf_hdr(&ptask->hdr, ntohs(proto));
1287 ptask->outstanding_pkts = 1;
1288 max_payload = dg_size + RFC2374_UNFRAG_HDR_SIZE;
1289 } else {
1290 u16 datagram_label;
1291
1292 max_payload -= RFC2374_FRAG_OVERHEAD;
1293 datagram_label = (*datagram_label_ptr)++;
1294 fwnet_make_ff_hdr(&ptask->hdr, ntohs(proto), dg_size,
1295 datagram_label);
1296 ptask->outstanding_pkts = DIV_ROUND_UP(dg_size, max_payload);
1297 max_payload += RFC2374_FRAG_HDR_SIZE;
1298 }
1299
1300 spin_unlock_irqrestore(&dev->lock, flags);
1301
1302 ptask->max_payload = max_payload;
1303 fwnet_send_packet(ptask);
1304
1305 return NETDEV_TX_OK;
1306
1307 fail_unlock:
1308 spin_unlock_irqrestore(&dev->lock, flags);
1309 fail:
1310 if (ptask)
1311 kmem_cache_free(fwnet_packet_task_cache, ptask);
1312
1313 if (skb != NULL)
1314 dev_kfree_skb(skb);
1315
1316 net->stats.tx_dropped++;
1317 net->stats.tx_errors++;
1318
1319 /*
1320 * FIXME: According to a patch from 2003-02-26, "returning non-zero
1321 * causes serious problems" here, allegedly. Before that patch,
1322 * -ERRNO was returned which is not appropriate under Linux 2.6.
1323 * Perhaps more needs to be done? Stop the queue in serious
1324 * conditions and restart it elsewhere?
1325 */
1326 return NETDEV_TX_OK;
1327}
1328
1329static int fwnet_change_mtu(struct net_device *net, int new_mtu)
1330{
1331 if (new_mtu < 68)
1332 return -EINVAL;
1333
1334 net->mtu = new_mtu;
1335 return 0;
1336}
1337
1338static void fwnet_get_drvinfo(struct net_device *net,
1339 struct ethtool_drvinfo *info)
1340{
1341 strcpy(info->driver, KBUILD_MODNAME);
1342 strcpy(info->bus_info, "ieee1394");
1343}
1344
1345static struct ethtool_ops fwnet_ethtool_ops = {
1346 .get_drvinfo = fwnet_get_drvinfo,
1347};
1348
1349static const struct net_device_ops fwnet_netdev_ops = {
1350 .ndo_open = fwnet_open,
1351 .ndo_stop = fwnet_stop,
1352 .ndo_start_xmit = fwnet_tx,
1353 .ndo_change_mtu = fwnet_change_mtu,
1354};
1355
1356static void fwnet_init_dev(struct net_device *net)
1357{
1358 net->header_ops = &fwnet_header_ops;
1359 net->netdev_ops = &fwnet_netdev_ops;
1360 net->watchdog_timeo = 2 * HZ;
1361 net->flags = IFF_BROADCAST | IFF_MULTICAST;
1362 net->features = NETIF_F_HIGHDMA;
1363 net->addr_len = FWNET_ALEN;
1364 net->hard_header_len = FWNET_HLEN;
1365 net->type = ARPHRD_IEEE1394;
1366 net->tx_queue_len = 10;
1367 SET_ETHTOOL_OPS(net, &fwnet_ethtool_ops);
1368}
1369
1370/* caller must hold fwnet_device_mutex */
1371static struct fwnet_device *fwnet_dev_find(struct fw_card *card)
1372{
1373 struct fwnet_device *dev;
1374
1375 list_for_each_entry(dev, &fwnet_device_list, dev_link)
1376 if (dev->card == card)
1377 return dev;
1378
1379 return NULL;
1380}
1381
1382static int fwnet_add_peer(struct fwnet_device *dev,
1383 struct fw_unit *unit, struct fw_device *device)
1384{
1385 struct fwnet_peer *peer;
1386
1387 peer = kmalloc(sizeof(*peer), GFP_KERNEL);
1388 if (!peer)
1389 return -ENOMEM;
1390
1391 dev_set_drvdata(&unit->device, peer);
1392
1393 peer->dev = dev;
1394 peer->guid = (u64)device->config_rom[3] << 32 | device->config_rom[4];
1395 peer->fifo = FWNET_NO_FIFO_ADDR;
1396 INIT_LIST_HEAD(&peer->pd_list);
1397 peer->pdg_size = 0;
1398 peer->datagram_label = 0;
1399 peer->speed = device->max_speed;
1400 peer->max_payload = fwnet_max_payload(device->max_rec, peer->speed);
1401
1402 peer->generation = device->generation;
1403 smp_rmb();
1404 peer->node_id = device->node_id;
1405
1406 spin_lock_irq(&dev->lock);
1407 list_add_tail(&peer->peer_link, &dev->peer_list);
1408 spin_unlock_irq(&dev->lock);
1409
1410 return 0;
1411}
1412
1413static int fwnet_probe(struct device *_dev)
1414{
1415 struct fw_unit *unit = fw_unit(_dev);
1416 struct fw_device *device = fw_parent_device(unit);
1417 struct fw_card *card = device->card;
1418 struct net_device *net;
1419 bool allocated_netdev = false;
1420 struct fwnet_device *dev;
1421 unsigned max_mtu;
1422 int ret;
1423
1424 mutex_lock(&fwnet_device_mutex);
1425
1426 dev = fwnet_dev_find(card);
1427 if (dev) {
1428 net = dev->netdev;
1429 goto have_dev;
1430 }
1431
1432 net = alloc_netdev(sizeof(*dev), "firewire%d", fwnet_init_dev);
1433 if (net == NULL) {
1434 ret = -ENOMEM;
1435 goto out;
1436 }
1437
1438 allocated_netdev = true;
1439 SET_NETDEV_DEV(net, card->device);
1440 dev = netdev_priv(net);
1441
1442 spin_lock_init(&dev->lock);
1443 dev->broadcast_state = FWNET_BROADCAST_ERROR;
1444 dev->broadcast_rcv_context = NULL;
1445 dev->broadcast_xmt_max_payload = 0;
1446 dev->broadcast_xmt_datagramlabel = 0;
1447
1448 dev->local_fifo = FWNET_NO_FIFO_ADDR;
1449
1450 INIT_LIST_HEAD(&dev->packet_list);
1451 INIT_LIST_HEAD(&dev->broadcasted_list);
1452 INIT_LIST_HEAD(&dev->sent_list);
1453 INIT_LIST_HEAD(&dev->peer_list);
1454
1455 dev->card = card;
1456 dev->netdev = net;
1457
1458 /*
1459 * Use the RFC 2734 default 1500 octets or the maximum payload
1460 * as initial MTU
1461 */
1462 max_mtu = (1 << (card->max_receive + 1))
1463 - sizeof(struct rfc2734_header) - IEEE1394_GASP_HDR_SIZE;
1464 net->mtu = min(1500U, max_mtu);
1465
1466 /* Set our hardware address while we're at it */
1467 put_unaligned_be64(card->guid, net->dev_addr);
1468 put_unaligned_be64(~0ULL, net->broadcast);
1469 ret = register_netdev(net);
1470 if (ret) {
1471 fw_error("Cannot register the driver\n");
1472 goto out;
1473 }
1474
1475 list_add_tail(&dev->dev_link, &fwnet_device_list);
1476 fw_notify("%s: IPv4 over FireWire on device %016llx\n",
1477 net->name, (unsigned long long)card->guid);
1478 have_dev:
1479 ret = fwnet_add_peer(dev, unit, device);
1480 if (ret && allocated_netdev) {
1481 unregister_netdev(net);
1482 list_del(&dev->dev_link);
1483 }
1484 out:
1485 if (ret && allocated_netdev)
1486 free_netdev(net);
1487
1488 mutex_unlock(&fwnet_device_mutex);
1489
1490 return ret;
1491}
1492
1493static void fwnet_remove_peer(struct fwnet_peer *peer)
1494{
1495 struct fwnet_partial_datagram *pd, *pd_next;
1496
1497 spin_lock_irq(&peer->dev->lock);
1498 list_del(&peer->peer_link);
1499 spin_unlock_irq(&peer->dev->lock);
1500
1501 list_for_each_entry_safe(pd, pd_next, &peer->pd_list, pd_link)
1502 fwnet_pd_delete(pd);
1503
1504 kfree(peer);
1505}
1506
1507static int fwnet_remove(struct device *_dev)
1508{
1509 struct fwnet_peer *peer = dev_get_drvdata(_dev);
1510 struct fwnet_device *dev = peer->dev;
1511 struct net_device *net;
1512 struct fwnet_packet_task *ptask, *pt_next;
1513
1514 mutex_lock(&fwnet_device_mutex);
1515
1516 fwnet_remove_peer(peer);
1517
1518 if (list_empty(&dev->peer_list)) {
1519 net = dev->netdev;
1520 unregister_netdev(net);
1521
1522 if (dev->local_fifo != FWNET_NO_FIFO_ADDR)
1523 fw_core_remove_address_handler(&dev->handler);
1524 if (dev->broadcast_rcv_context) {
1525 fw_iso_context_stop(dev->broadcast_rcv_context);
1526 fw_iso_buffer_destroy(&dev->broadcast_rcv_buffer,
1527 dev->card);
1528 fw_iso_context_destroy(dev->broadcast_rcv_context);
1529 }
1530 list_for_each_entry_safe(ptask, pt_next,
1531 &dev->packet_list, pt_link) {
1532 dev_kfree_skb_any(ptask->skb);
1533 kmem_cache_free(fwnet_packet_task_cache, ptask);
1534 }
1535 list_for_each_entry_safe(ptask, pt_next,
1536 &dev->broadcasted_list, pt_link) {
1537 dev_kfree_skb_any(ptask->skb);
1538 kmem_cache_free(fwnet_packet_task_cache, ptask);
1539 }
1540 list_for_each_entry_safe(ptask, pt_next,
1541 &dev->sent_list, pt_link) {
1542 dev_kfree_skb_any(ptask->skb);
1543 kmem_cache_free(fwnet_packet_task_cache, ptask);
1544 }
1545 list_del(&dev->dev_link);
1546
1547 free_netdev(net);
1548 }
1549
1550 mutex_unlock(&fwnet_device_mutex);
1551
1552 return 0;
1553}
1554
1555/*
1556 * FIXME abort partially sent fragmented datagrams,
1557 * discard partially received fragmented datagrams
1558 */
1559static void fwnet_update(struct fw_unit *unit)
1560{
1561 struct fw_device *device = fw_parent_device(unit);
1562 struct fwnet_peer *peer = dev_get_drvdata(&unit->device);
1563 int generation;
1564
1565 generation = device->generation;
1566
1567 spin_lock_irq(&peer->dev->lock);
1568 peer->node_id = device->node_id;
1569 peer->generation = generation;
1570 spin_unlock_irq(&peer->dev->lock);
1571}
1572
1573static const struct ieee1394_device_id fwnet_id_table[] = {
1574 {
1575 .match_flags = IEEE1394_MATCH_SPECIFIER_ID |
1576 IEEE1394_MATCH_VERSION,
1577 .specifier_id = IANA_SPECIFIER_ID,
1578 .version = RFC2734_SW_VERSION,
1579 },
1580 { }
1581};
1582
1583static struct fw_driver fwnet_driver = {
1584 .driver = {
1585 .owner = THIS_MODULE,
1586 .name = "net",
1587 .bus = &fw_bus_type,
1588 .probe = fwnet_probe,
1589 .remove = fwnet_remove,
1590 },
1591 .update = fwnet_update,
1592 .id_table = fwnet_id_table,
1593};
1594
1595static const u32 rfc2374_unit_directory_data[] = {
1596 0x00040000, /* directory_length */
1597 0x1200005e, /* unit_specifier_id: IANA */
1598 0x81000003, /* textual descriptor offset */
1599 0x13000001, /* unit_sw_version: RFC 2734 */
1600 0x81000005, /* textual descriptor offset */
1601 0x00030000, /* descriptor_length */
1602 0x00000000, /* text */
1603 0x00000000, /* minimal ASCII, en */
1604 0x49414e41, /* I A N A */
1605 0x00030000, /* descriptor_length */
1606 0x00000000, /* text */
1607 0x00000000, /* minimal ASCII, en */
1608 0x49507634, /* I P v 4 */
1609};
1610
1611static struct fw_descriptor rfc2374_unit_directory = {
1612 .length = ARRAY_SIZE(rfc2374_unit_directory_data),
1613 .key = (CSR_DIRECTORY | CSR_UNIT) << 24,
1614 .data = rfc2374_unit_directory_data
1615};
1616
1617static int __init fwnet_init(void)
1618{
1619 int err;
1620
1621 err = fw_core_add_descriptor(&rfc2374_unit_directory);
1622 if (err)
1623 return err;
1624
1625 fwnet_packet_task_cache = kmem_cache_create("packet_task",
1626 sizeof(struct fwnet_packet_task), 0, 0, NULL);
1627 if (!fwnet_packet_task_cache) {
1628 err = -ENOMEM;
1629 goto out;
1630 }
1631
1632 err = driver_register(&fwnet_driver.driver);
1633 if (!err)
1634 return 0;
1635
1636 kmem_cache_destroy(fwnet_packet_task_cache);
1637out:
1638 fw_core_remove_descriptor(&rfc2374_unit_directory);
1639
1640 return err;
1641}
1642module_init(fwnet_init);
1643
1644static void __exit fwnet_cleanup(void)
1645{
1646 driver_unregister(&fwnet_driver.driver);
1647 kmem_cache_destroy(fwnet_packet_task_cache);
1648 fw_core_remove_descriptor(&rfc2374_unit_directory);
1649}
1650module_exit(fwnet_cleanup);
1651
1652MODULE_AUTHOR("Jay Fenlason <fenlason@redhat.com>");
1653MODULE_DESCRIPTION("IPv4 over IEEE1394 as per RFC 2734");
1654MODULE_LICENSE("GPL");
1655MODULE_DEVICE_TABLE(ieee1394, fwnet_id_table);
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-13 12:02:18 -0500