Mercurial > archived > louis > epitech > mq > rathaxes

comparison rathaxes_samples_e1000_use_the_dma_abstraction_in_socket.patch @ 115:5a663f8f0e54

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
WIP, fix another small bug in rathaxes sequence calls
author Louis Opter <louis@lse.epita.fr>
date Mon, 22 Jul 2013 13:52:00 -0700
parents 8eac160e5f1c
children f3c7e9b0c5cf
comparison
equal deleted inserted replaced
114:8eac160e5f1c 115:5a663f8f0e54
1 # HG changeset patch 1 # HG changeset patch
2 # Parent 5a53813ed1306484aa98dd95fe1d284ed24111ab 2 # Parent 22cdd951a10d1b8b06daf6448da73e738f21d2e3
3 Replace Linux specific code in Socket by DMA calls 3 Replace Linux specific code in Socket by DMA calls
4 4
5 diff --git a/rathaxes/samples/e1000/dma.blt b/rathaxes/samples/e1000/dma.blt
6 --- a/rathaxes/samples/e1000/dma.blt
7 +++ b/rathaxes/samples/e1000/dma.blt
8 @@ -1,6 +1,6 @@
9 with DMA, Builtin, LKM, Device
10 {
11 - template type AbstractDMAHandle()
12 + template type DMA::AbstractDMAHandle()
13 {
14 chunk LKM::includes()
15 {
16 @@ -14,11 +14,11 @@
17
18 map
19 {
20 - k_dma_handle: ((dma_addr_t *)${self});
21 + k_dma_handle: ((dma_addr_t)${self});
22 }
23 }
24
25 - template type AbstractDMADirection()
26 + template type DMA::AbstractDMADirection()
27 {
28 decl data_types()
29 {
30 @@ -42,7 +42,7 @@
31
32 map
33 {
34 - /* XXX: we should use ${AbstractDMADirection} here: */
35 + /* XXX: we should use ${DMA::AbstractDMADirection} here: */
36 dma_direction: ((enum dma_data_direction)${self});
37 }
38 }
39 @@ -51,11 +51,11 @@
40 {
41 chunk ::CALL()
42 {
43 - dma_map_single(${dev.k_device}, ${buf}, ${size}, ${dir.dma_direction});
44 + ((${DMA::DMA::AbstractDMAHandle})dma_map_single(${dev.k_device}, ${buf}, ${size}, ${dir.dma_direction}));
45 }
46 }
47
48 - template sequence unmap(Device::AbstractDevice dev, AbstractDMAHandle handle, Builtin::number size, DMADirection dir)
49 + template sequence unmap(Device::AbstractDevice dev, DMA::AbstractDMAHandle handle, Builtin::number size, DMADirection dir)
50 {
51 chunk ::CALL()
52 {
53 @@ -63,15 +63,23 @@
54 }
55 }
56
57 - template sequence alloc_coherent(Device::AbstractDevice dev, Builtin::number size, AbstractDMAHandle handle)
58 + template sequence mapping_error(Device::AbstractDevice dev, DMA::AbstractDMAHandle handle)
59 + {
60 + chunk ::CALL()
61 + {
62 + dma_mapping_error(${dev.k_device}, ${handle.k_dma_handle});
63 + }
64 + }
65 +
66 + template sequence alloc_coherent(Device::AbstractDevice dev, Builtin::number size, DMA::AbstractDMAHandle handle)
67 {
68 chunk ::CALL()
69 {
70 - dma_alloc_coherent(${dev.k_device}, ${size}, ${handle.k_dma_handle}, GFP_KERNEL);
71 + dma_alloc_coherent(${dev.k_device}, ${size}, &${handle.k_dma_handle}, GFP_KERNEL);
72 }
73 }
74
75 - template sequence free_coherent(Device::AbstractDevice dev, Builtin::number size, Builtin::symbol addr, AbstractDMAHandle handle)
76 + template sequence free_coherent(Device::AbstractDevice dev, Builtin::number size, Builtin::symbol addr, DMA::AbstractDMAHandle handle)
77 {
78 chunk ::CALL()
79 {
80 diff --git a/rathaxes/samples/e1000/dma.rti b/rathaxes/samples/e1000/dma.rti
81 --- a/rathaxes/samples/e1000/dma.rti
82 +++ b/rathaxes/samples/e1000/dma.rti
83 @@ -29,6 +29,12 @@
84 provided chunk ::CALL();
85 }
86
87 + /* XXX: Until we have a real error handling mechanism: */
88 + provided sequence mapping_error(Device::AbstractDevice, AbstractDMAHandle)
89 + {
90 + provided chunk ::CALL(); /* -> != 0 if the mapping failed */
91 + }
92 +
93 provided sequence alloc_coherent(Device::AbstractDevice, Builtin::number, AbstractDMAHandle)
94 {
95 /* return the addr and the handle via the AbstractDMAHandle ptr: */
96 diff --git a/rathaxes/samples/e1000/socket.blt b/rathaxes/samples/e1000/socket.blt 5 diff --git a/rathaxes/samples/e1000/socket.blt b/rathaxes/samples/e1000/socket.blt
97 --- a/rathaxes/samples/e1000/socket.blt 6 --- a/rathaxes/samples/e1000/socket.blt
98 +++ b/rathaxes/samples/e1000/socket.blt 7 +++ b/rathaxes/samples/e1000/socket.blt
99 @@ -1,4 +1,4 @@ 8 @@ -1,4 +1,4 @@
100 -with Socket, LKM, Device, Ethernet 9 -with Socket, LKM, Device, Ethernet
101 +with Socket, LKM, Device, DMA, Ethernet 10 +with Socket, LKM, Device, DMA, Ethernet
102 { 11 {
103 template type Socket::AbstractSKBuff() 12 template type Socket::AbstractSKBuff()
104 { 13 {
105 @@ -22,15 +22,15 @@ 14 @@ -22,35 +22,34 @@
106 { 15 {
107 decl data_types() 16 decl data_types()
108 { 17 {
109 - ${Socket::AbstractSKBuff.ref} skbuff; 18 - ${Socket::AbstractSKBuff.ref} skbuff;
110 - dma_addr_t dma_handle; 19 - dma_addr_t dma_handle;
116 { 25 {
117 static void rtx_socket_skbuff_dump_infos(${Socket::SKBuff.ref}); 26 static void rtx_socket_skbuff_dump_infos(${Socket::SKBuff.ref});
118 - static int rtx_socket_skbuff_map(${Socket::SKBuff.ref}, struct device *, enum dma_data_direction); 27 - static int rtx_socket_skbuff_map(${Socket::SKBuff.ref}, struct device *, enum dma_data_direction);
119 - static void rtx_socket_skbuff_unmap_and_free(${Socket::SKBuff.ref}, struct device *, enum dma_data_direction); 28 - static void rtx_socket_skbuff_unmap_and_free(${Socket::SKBuff.ref}, struct device *, enum dma_data_direction);
120 + static int rtx_socket_skbuff_map(${Socket::SKBuff.ref}, ${Device::AbstractDevice.ref}, ${DMA::DMADirection.scalar}); 29 + static int rtx_socket_skbuff_map(${Socket::SKBuff.ref}, ${Device::AbstractDevice.ref}, ${DMA::DMADirection.scalar});
121 + static void rtx_socket_skbuff_unmap_and_free(${Socket::SKBuff.ref}, struct device *, ${DMA::DMADirection.scalar}); 30 + static void rtx_socket_skbuff_unmap_and_free(${Socket::SKBuff.ref}, ${Device::AbstractDevice.ref}, ${DMA::DMADirection.scalar});
122 } 31 }
123 32
124 chunk LKM::code() 33 chunk LKM::code()
125 @@ -65,23 +65,21 @@ 34 {
35 static void rtx_socket_skbuff_dump_infos(${Socket::SKBuff.ref} self)
36 {
37 - WARN_ON(!self->skbuff);
38 + WARN_ON(!${local.self.k_sk_buff});
39 +
40 + ${Ethernet::ProtocolId} ethernet_proto = { .id = be16_to_cpu(${local.self.k_sk_buff}->protocol) };
41 + static const char * const ip_summed_values[] = {
42 + "none", "unnecessary", "complete", "partial"
43 + };
44 + struct skb_shared_info *shinfo = skb_shinfo(${local.self.k_sk_buff});
45
46 /*
47 * We should use a Rathaxes log abstraction instead of pr_info here,
48 * but Rathaxes doesn't support functions with a variable number of
49 * arguments yet.
50 */
51 - ${Socket::AbstractSKBuff.ref} skb = self->skbuff;
52 - ${Ethernet::ProtocolId} ethernet_proto = { .id = be16_to_cpu(${local.skb.k_sk_buff}->protocol) };
53 - static const char * const ip_summed_values[] = {
54 - "none", "unnecessary", "complete", "partial"
55 - };
56 - struct skb_shared_info *shinfo = skb_shinfo(${local.skb.k_sk_buff});
57 -
58 pr_info(
59 "\t protocol = %#-5x (%s) ip_summed = %d (%s)\n"
60 "\t len = %-5u data_len = %-5u head_len = %-5u\n"
61 @@ -58,30 +57,26 @@
62 "\t gso_size = %-5u gso_segs = %-5u gso_type = %-5u",
63 /* XXX: can't use ${local.ethernet_proto.id} here (issue #52): */
64 ethernet_proto.id, ${local.ethernet_proto.str},
65 - ${local.skb.k_sk_buff}->ip_summed, ip_summed_values[${local.skb.k_sk_buff}->ip_summed],
66 - ${local.skb.k_sk_buff}->len, ${local.skb.k_sk_buff}->data_len, skb_headlen(${local.skb.k_sk_buff}),
67 + ${local.self.k_sk_buff}->ip_summed, ip_summed_values[${local.self.k_sk_buff}->ip_summed],
68 + ${local.self.k_sk_buff}->len, ${local.self.k_sk_buff}->data_len, skb_headlen(${local.self.k_sk_buff}),
69 shinfo->nr_frags, shinfo->gso_size, shinfo->gso_segs, shinfo->gso_type
70 );
126 } 71 }
127 72
128 static int rtx_socket_skbuff_map(${Socket::SKBuff.ref} self, 73 static int rtx_socket_skbuff_map(${Socket::SKBuff.ref} self,
129 - struct device *dev, 74 - struct device *dev,
130 - enum dma_data_direction direction) 75 - enum dma_data_direction direction)
131 + ${Device::AbstractDevice.ref} dev, 76 + ${Device::AbstractDevice.ref} dev,
132 + ${DMA::DMADirection.scalar} direction) 77 + ${DMA::DMADirection.scalar} direction)
133 { 78 {
134 - ${Socket::AbstractSKBuff.ref} skb = self->skbuff; 79 - ${Socket::AbstractSKBuff.ref} skb = self->skbuff;
135 -
136 - WARN_ON(!${local.skb.k_sk_buff});
137 - WARN_ON(self->dma_handle);
138 + WARN_ON(!${local.self.k_sk_buff}); 80 + WARN_ON(!${local.self.k_sk_buff});
139 + WARN_ON(${local.self.k_dma_handle}); 81 + WARN_ON(${local.self.k_dma_handle});
140 82
141 self->dma_handle = dma_map_single( 83 - WARN_ON(!${local.skb.k_sk_buff});
84 - WARN_ON(self->dma_handle);
85 -
86 - self->dma_handle = dma_map_single(
142 - dev, 87 - dev,
143 + ${dev.k_device}, 88 - ${local.skb.k_sk_buff},
144 ${local.skb.k_sk_buff}, 89 - skb_headlen(${local.skb.k_sk_buff}),
145 skb_headlen(${local.skb.k_sk_buff}),
146 - direction); 90 - direction);
147 - int err = dma_mapping_error(dev, self->dma_handle); 91 - int err = dma_mapping_error(dev, self->dma_handle);
148 + ${local.direction.dma_direction}); 92 + unsigned int len = skb_headlen(${local.skb.k_sk_buff});
93 + ${cast local.len as Builtin::number};
94 + ${local.self.k_dma_handle} = ${DMA::map(local.dev, local.skb.k_sk_buff, local.len, local.direction)};
149 + int err = ${DMA::mapping_error(local.dev, local.self.k_dma_handle)}; 95 + int err = ${DMA::mapping_error(local.dev, local.self.k_dma_handle)};
150 if (err) 96 if (err)
151 { 97 {
152 - self->dma_handle = 0; 98 - self->dma_handle = 0;
153 + ${local.self.k_dma_handle} = 0; 99 + ${local.self.k_dma_handle} = 0;
154 return err; 100 return err;
155 } 101 }
156 return 0; 102 return 0;
157 @@ -89,7 +87,7 @@ 103 @@ -89,7 +84,7 @@
158 104
159 static void rtx_socket_skbuff_unmap_and_free(${Socket::SKBuff.ref} self, 105 static void rtx_socket_skbuff_unmap_and_free(${Socket::SKBuff.ref} self,
160 struct device *dev, 106 struct device *dev,
161 - enum dma_data_direction direction) 107 - enum dma_data_direction direction)
162 + ${DMA::DMADirection} direction) 108 + ${DMA::DMADirection} direction)
163 { 109 {
164 ${Socket::AbstractSKBuff.ref} skb = self->skbuff; 110 ${Socket::AbstractSKBuff.ref} skb = self->skbuff;
165 111
166 @@ -100,7 +98,7 @@ 112 @@ -100,7 +95,7 @@
167 dma_unmap_single(dev, 113 dma_unmap_single(dev,
168 self->dma_handle, 114 self->dma_handle,
169 skb_headlen(${local.skb.k_sk_buff}), 115 skb_headlen(${local.skb.k_sk_buff}),
170 - direction); 116 - direction);
171 + ${local.direction.dma_direction}); 117 + ${local.direction.dma_direction});
172 self->dma_handle = 0; 118 self->dma_handle = 0;
173 } 119 }
174 dev_kfree_skb_any(${local.skb.k_sk_buff}); 120 dev_kfree_skb_any(${local.skb.k_sk_buff});
175 @@ -126,30 +124,32 @@ 121 @@ -126,30 +121,32 @@
176 122
177 method map_to(Device::AbstractDevice dev) 123 method map_to(Device::AbstractDevice dev)
178 { 124 {
179 - rtx_socket_skbuff_map(${self}, ${dev.k_device}, DMA_TO_DEVICE); 125 - rtx_socket_skbuff_map(${self}, ${dev.k_device}, DMA_TO_DEVICE);
180 + rtx_socket_skbuff_map(${self}, ${dev}, RTX_DMA_TO_DEVICE); 126 + rtx_socket_skbuff_map(${self}, ${dev}, RTX_DMA_TO_DEVICE);