|
130
|
1 # HG changeset patch
|
|
|
2 # Parent ead0d8be18437dcd68451112be0652dfdec884b5
|
|
|
3 diff --git a/rathaxes/samples/e1000/e1000.blt b/rathaxes/samples/e1000/e1000.blt
|
|
|
4 --- a/rathaxes/samples/e1000/e1000.blt
|
|
|
5 +++ b/rathaxes/samples/e1000/e1000.blt
|
|
|
6 @@ -150,17 +150,10 @@
|
|
|
7 /* Allocate the descriptors */
|
|
|
8 hw_ctx->rx_ring.size = ${config.rx_ring_size} * sizeof(*hw_ctx->rx_ring.base);
|
|
|
9 hw_ctx->rx_ring.size = ALIGN(hw_ctx->rx_ring.size, 4096);
|
|
|
10 - hw_ctx->rx_ring.base = dma_alloc_coherent(
|
|
|
11 - ${rtx_ether_ctx.device},
|
|
|
12 - hw_ctx->rx_ring.size,
|
|
|
13 - &hw_ctx->rx_ring.dma_base,
|
|
|
14 - GFP_KERNEL);
|
|
|
15 - /* XXX
|
|
|
16 - * The first arg is recognized as Ethernet::Device instead of
|
|
|
17 - * Device::AbstractDevice.
|
|
|
18 - */
|
|
|
19 hw_ctx->rx_ring.base = ${DMA::alloc_coherent(
|
|
|
20 - rtx_ether_ctx.device, local.hw_ctx.rx_ring.size, local.hw_ctx.rx_ring.dma_base.dma_handle
|
|
|
21 + rtx_ether_ctx.device,
|
|
|
22 + local.hw_ctx.rx_ring.size,
|
|
|
23 + local.hw_ctx.rx_ring.dma_base.dma_handle
|
|
|
24 )};
|
|
|
25 if (!hw_ctx->rx_ring.base)
|
|
|
26 {
|
|
|
27 @@ -176,19 +169,13 @@
|
|
|
28 */
|
|
|
29 for (i = 0; i != ${config.rx_ring_size}; ++i)
|
|
|
30 {
|
|
|
31 - // XXX #46: ${Socket::SKBuff.ref} skbuff = ${rtx_ether_ctx.net_device.alloc_rx_skbuff(config.rx_buffer_len)};
|
|
|
32 - ${Socket::AbstractSKBuff.ref} k_sk_buff = (${Socket::AbstractSKBuff.ref})netdev_alloc_skb(
|
|
|
33 - ${rtx_ether_ctx.net_device.k_net_dev}, ${config.rx_buffer_len}
|
|
|
34 - );
|
|
|
35 - if (!k_sk_buff)
|
|
|
36 + ${Socket::SKBuff.ref} skbuff = &hw_ctx->rx_ring.skbuffs[i];
|
|
|
37 + // XXX #46: ${rtx_ether_ctx.init_rx_skbuff(local.skbuff, config.rx_buffer_len)};
|
|
|
38 + if (rtx_ethernet_init_rx_skbuff(${local.skbuff}, ${config.rx_buffer_len}))
|
|
|
39 {
|
|
|
40 ${Log::info("adapter_init_rx: cannot allocate a skbuff for the rx ring")};
|
|
|
41 goto err_skbuffs_alloc;
|
|
|
42 }
|
|
|
43 - ${Socket::SKBuff.ref} skbuff = &hw_ctx->rx_ring.skbuffs[i];
|
|
|
44 - // XXX breaks rtxGen: ${local.skbuff.init(local.k_sk_buff)};
|
|
|
45 - skbuff->skbuff = k_sk_buff;
|
|
|
46 - *(dma_addr_t *)&(skbuff->dma_handle) = 0;
|
|
|
47 // XXX #46: ${local.skbuff.map_from(rtx_ether_ctx.device)};
|
|
|
48 if (rtx_socket_skbuff_map(${local.skbuff}, ${rtx_ether_ctx.device}, RTX_DMA_FROM_DEVICE))
|
|
|
49 {
|
|
|
50 @@ -199,7 +186,7 @@
|
|
|
51 }
|
|
|
52
|
|
|
53 // ${Log::info("adapter_init_rx: skbuffs allocated};
|
|
|
54 - pr_info("adapter_init_rx: skbuffs allocated, headlen=%d", skb_headlen((struct sk_buff *)hw_ctx->rx_ring.skbuffs[i].skbuff));
|
|
|
55 + pr_info("rtx_e1k: adapter_init_rx: skbuffs allocated, headlen=%d", skb_headlen((struct sk_buff *)hw_ctx->rx_ring.skbuffs[i - 1].skbuff));
|
|
|
56
|
|
|
57 /* 5. Save the emplacement and the size of the ring in RDBA/RDLEN */
|
|
|
58 rtx_e1000_register_write32(hw_ctx, E1000_RDBAL, hw_ctx->rx_ring.dma_base & 0xffffffff);
|
|
|
59 @@ -565,7 +552,7 @@
|
|
|
60 map
|
|
|
61 {
|
|
|
62 rx_ring: ((${self})->rx_ring);
|
|
|
63 - //tx_ring: ((${self})->tx_ring);
|
|
|
64 + //tx_ring: ((${self})->tx_ring); XXX Circular dep with Context
|
|
|
65 }
|
|
|
66 }
|
|
|
67
|
|
|
68 diff --git a/rathaxes/samples/e1000/e1000.rti b/rathaxes/samples/e1000/e1000.rti
|
|
|
69 --- a/rathaxes/samples/e1000/e1000.rti
|
|
|
70 +++ b/rathaxes/samples/e1000/e1000.rti
|
|
|
71 @@ -48,6 +48,8 @@
|
|
|
72 chunk Ethernet::adapter_setup(Ethernet::Device);
|
|
|
73
|
|
|
74 attribute RxRing.scalar rx_ring;
|
|
|
75 + /* XXX: circular dependency with Contex: */
|
|
|
76 + //attribute TxRing.scalar tx_ring;
|
|
|
77 }
|
|
|
78
|
|
|
79 provided type TxRing
|
|
|
80 diff --git a/rathaxes/samples/e1000/ethernet.blt b/rathaxes/samples/e1000/ethernet.blt
|
|
|
81 --- a/rathaxes/samples/e1000/ethernet.blt
|
|
|
82 +++ b/rathaxes/samples/e1000/ethernet.blt
|
|
|
83 @@ -95,6 +95,24 @@
|
|
|
84 #include <linux/etherdevice.h>
|
|
|
85 }
|
|
|
86
|
|
|
87 + chunk LKM::prototypes()
|
|
|
88 + {
|
|
|
89 + static int rtx_ethernet_alloc_rx_skbuff(${Ethernet::Device.ref}, ${Socket::SKBuff.ref}, ${Builtin::number});
|
|
|
90 + }
|
|
|
91 +
|
|
|
92 + chunk LKM::code()
|
|
|
93 + {
|
|
|
94 + static int rtx_ethernet_alloc_rx_skbuff(${Ethernet::Device.ref} self, ${Socket::SKBuff.ref} sk_buff, ${Builtin::number} size)
|
|
|
95 + {
|
|
|
96 + ${Socket::AbstractSKBuff} k_sk_buff = netdev_alloc_skb(${local.self.net_device.k_net_dev}, ${local.size});
|
|
|
97 + if (${local.k_sk_buff) {
|
|
|
98 + ${local.sk_buff.init(local.k_sk_buff, local.size)};
|
|
|
99 + return 0;
|
|
|
100 + }
|
|
|
101 + return 1;
|
|
|
102 + }
|
|
|
103 + }
|
|
|
104 +
|
|
|
105 /* XXX: if the first arg is not called rtx_net_dev, it breaks. */
|
|
|
106 method init(Ethernet::AbstractDevice rtx_net_dev, PCI::AbstractDevice pci_dev)
|
|
|
107 {
|
|
|
108 @@ -107,9 +125,9 @@
|
|
|
109 ${self}->net_dev = ${rtx_net_dev};
|
|
|
110 }
|
|
|
111
|
|
|
112 - method alloc_rx_skbuff(Builtin::number size)
|
|
|
113 + method alloc_rx_skbuff(Socket::SKBuff sk_buff, Builtin::number size)
|
|
|
114 {
|
|
|
115 - (${Socket::Skbuff.ref})netdev_alloc_skb(${self}, ${size});
|
|
|
116 + rtx_ethernet_alloc_rx_skbuff(${self}, ${sk_buff}, ${size});
|
|
|
117 }
|
|
|
118
|
|
|
119 map
|
|
|
120 diff --git a/rathaxes/samples/e1000/ethernet.rti b/rathaxes/samples/e1000/ethernet.rti
|
|
|
121 --- a/rathaxes/samples/e1000/ethernet.rti
|
|
|
122 +++ b/rathaxes/samples/e1000/ethernet.rti
|
|
|
123 @@ -33,7 +33,11 @@
|
|
|
124 pointcut Ethernet::HardwareContext();
|
|
|
125
|
|
|
126 method init(Ethernet::AbstractDevice, PCI::AbstractDevice);
|
|
|
127 - method alloc_rx_skbuff(Builtin::number); /* -> Socket::Skbuff.ref */
|
|
|
128 + /*
|
|
|
129 + * Alloc (the AbstractSKBuff inside) the given SKBuff and initialize
|
|
|
130 + * the SKBuff, return 1 if the allocation failed, 0 on success.
|
|
|
131 + */
|
|
|
132 + method alloc_rx_skbuff(Socket::SKBuff, Builtin::number);
|
|
|
133
|
|
|
134 attribute Device::AbstractDevice.ref device;
|
|
|
135 attribute PCI::AbstractDevice.ref pci_device;
|
|
|
136 diff --git a/rathaxes/samples/e1000/socket.blt b/rathaxes/samples/e1000/socket.blt
|
|
|
137 --- a/rathaxes/samples/e1000/socket.blt
|
|
|
138 +++ b/rathaxes/samples/e1000/socket.blt
|
|
|
139 @@ -24,6 +24,7 @@
|
|
|
140 {
|
|
|
141 ${Socket::AbstractSKBuff.ref} skbuff;
|
|
|
142 ${DMA::AbstractDMAHandle.scalar} dma_handle;
|
|
|
143 + unsigned int size;
|
|
|
144 }
|
|
|
145
|
|
|
146 chunk LKM::prototypes()
|
|
|
147 @@ -69,8 +70,13 @@
|
|
|
148 {
|
|
|
149 WARN_ON(!${local.self.sk_buff});
|
|
|
150 WARN_ON(${local.self.dma_handle});
|
|
|
151 + /*
|
|
|
152 + * TODO: we don't support skbuffs with paged data yet (see also
|
|
|
153 + * http://vger.kernel.org/~davem/skb_data.html).
|
|
|
154 + */
|
|
|
155 + WARN_ON(skb_is_nonlinear(${local.self.sk_buff.k_sk_buff}));
|
|
|
156
|
|
|
157 - unsigned int len = skb_headlen(${local.self.sk_buff.k_sk_buff});
|
|
|
158 + unsigned int len = ${local.self.size};
|
|
|
159 ${cast local.len as Builtin::number};
|
|
|
160 ${local.self.dma_handle} = ${DMA::map(local.dev, local.self.sk_buff.k_sk_buff, local.len, local.direction)};
|
|
|
161 int err = ${DMA::mapping_error(local.dev, local.self.dma_handle)};
|
|
|
162 @@ -87,10 +93,11 @@
|
|
|
163 ${DMA::DMADirection} direction)
|
|
|
164 {
|
|
|
165 WARN_ON(!${local.self.sk_buff});
|
|
|
166 + WARN_ON(skb_is_nonlinear(${local.self.sk_buff.k_sk_buff});
|
|
|
167
|
|
|
168 if (${local.self.dma_handle})
|
|
|
169 {
|
|
|
170 - unsigned int len = skb_headlen(${local.self.sk_buff.k_sk_buff});
|
|
|
171 + unsigned int len = ${local.self.size};
|
|
|
172 ${cast local.len as Builtin::number};
|
|
|
173 ${DMA::unmap(local.dev, local.self.dma_handle, local.len, local.direction)};
|
|
|
174 ${local.self.dma_handle} = 0;
|
|
|
175 @@ -105,13 +112,14 @@
|
|
|
176 * correct C variable from Ethernet::send() (so I named it as the C
|
|
|
177 * variable I needed)
|
|
|
178 */
|
|
|
179 - method init(Socket::AbstractSKBuff kernel_skb)
|
|
|
180 + method init(Socket::AbstractSKBuff kernel_skb, Builtin::number size)
|
|
|
181 {
|
|
|
182 ${self.sk_buff} = ${kernel_skb};
|
|
|
183 + ${self.size} = ${size};
|
|
|
184 ${self.dma_handle} = 0;
|
|
|
185 }
|
|
|
186
|
|
|
187 - method dump_infos()
|
|
|
188 + method dump_infos()
|
|
|
189 {
|
|
|
190 rtx_socket_skbuff_dump_infos(${self});
|
|
|
191 }
|
|
|
192 @@ -149,6 +157,7 @@
|
|
|
193 // would yield to a struct type which you can't assign directly;
|
|
|
194 // but maybe doing the ->data in that case would be acceptable).
|
|
|
195 dma_handle: (*((dma_addr_t *)&(${self})->dma_handle));
|
|
|
196 + size: (${self})->size;
|
|
|
197 }
|
|
|
198 }
|
|
|
199 }
|
|
|
200 diff --git a/rathaxes/samples/e1000/socket.rti b/rathaxes/samples/e1000/socket.rti
|
|
|
201 --- a/rathaxes/samples/e1000/socket.rti
|
|
|
202 +++ b/rathaxes/samples/e1000/socket.rti
|
|
|
203 @@ -13,7 +13,7 @@
|
|
|
204 chunk LKM::prototypes();
|
|
|
205 chunk LKM::code();
|
|
|
206 decl data_types();
|
|
|
207 - method init(Socket::AbstractSKBuff);
|
|
|
208 + method init(Socket::AbstractSKBuff, Builtin::number);
|
|
|
209 method dump_infos();
|
|
|
210 /*
|
|
|
211 * map_to and map_from return a non-zero value on failure (which
|
|
|
212 @@ -26,5 +26,6 @@
|
|
|
213
|
|
|
214 attribute Socket::AbstractSKBuff.ref sk_buff;
|
|
|
215 attribute DMA::AbstractDMAHandle.scalar dma_handle;
|
|
|
216 + attribute Builtin::number.scalar size;
|
|
|
217 }
|
|
|
218 }
|
