--- a/rathaxes_samples_e1000_use_the_dma_abstraction_in_socket.patch	Fri Jul 19 19:12:10 2013 -0700
+++ b/rathaxes_samples_e1000_use_the_dma_abstraction_in_socket.patch	Sat Jul 20 20:45:39 2013 -0700
@@ -1,7 +1,65 @@
 # HG changeset patch
-# Parent c571aba317b28723d36bf15393be227b41fce242
+# Parent 05460906d5aba5d3671969d9ac53182d0ac91649
 Replace Linux specific code in Socket by DMA calls
 
+diff --git a/rathaxes/samples/e1000/dma.blt b/rathaxes/samples/e1000/dma.blt
+--- a/rathaxes/samples/e1000/dma.blt
++++ b/rathaxes/samples/e1000/dma.blt
+@@ -14,7 +14,7 @@
+ 
+         map
+         {
+-            k_dma_handle: ((dma_addr_t *)${self});
++            k_dma_handle: ((dma_addr_t)${self});
+         }
+     }
+ 
+@@ -51,7 +51,7 @@
+     {
+         chunk  ::CALL()
+         {
+-            dma_map_single(${dev.k_device}, ${buf}, ${size}, ${dir.dma_direction});
++            ((${DMA::AbstractDMAHandle})dma_map_single(${dev.k_device}, ${buf}, ${size}, ${dir.dma_direction}));
+         }
+     }
+ 
+@@ -63,11 +63,19 @@
+         }
+     }
+ 
++    template sequence   mapping_error(Device::AbstractDevice dev, AbstractDMAHandle handle)
++    {
++        chunk ::CALL()
++        {
++            dma_mapping_error(${dev.k_device}, ${handle.k_dma_handle});
++        }
++    }
++
+     template sequence   alloc_coherent(Device::AbstractDevice dev, Builtin::number size, AbstractDMAHandle handle)
+     {
+         chunk  ::CALL()
+         {
+-            dma_alloc_coherent(${dev.k_device}, ${size}, ${handle.k_dma_handle}, GFP_KERNEL);
++            dma_alloc_coherent(${dev.k_device}, ${size}, &${handle.k_dma_handle}, GFP_KERNEL);
+         }
+     }
+ 
+diff --git a/rathaxes/samples/e1000/dma.rti b/rathaxes/samples/e1000/dma.rti
+--- a/rathaxes/samples/e1000/dma.rti
++++ b/rathaxes/samples/e1000/dma.rti
+@@ -29,6 +29,12 @@
+         provided chunk  ::CALL();
+     }
+ 
++    /* XXX: Until we have a real error handling mechanism: */
++    provided sequence   mapping_error(Device::AbstractDevice, AbstractDMAHandle)
++    {
++        provided chunk  ::CALL(); /* -> != 0 if the mapping failed */
++    }
++
+     provided sequence   alloc_coherent(Device::AbstractDevice, Builtin::number, AbstractDMAHandle)
+     {
+         /* return the addr and the handle via the AbstractDMAHandle ptr: */
 diff --git a/rathaxes/samples/e1000/socket.blt b/rathaxes/samples/e1000/socket.blt
 --- a/rathaxes/samples/e1000/socket.blt
 +++ b/rathaxes/samples/e1000/socket.blt
@@ -26,30 +84,44 @@
              static void rtx_socket_skbuff_dump_infos(${Socket::SKBuff.ref});
 -            static int  rtx_socket_skbuff_map(${Socket::SKBuff.ref}, struct device *, enum dma_data_direction);
 -            static void rtx_socket_skbuff_unmap_and_free(${Socket::SKBuff.ref}, struct device *, enum dma_data_direction);
-+            static int  rtx_socket_skbuff_map(${Socket::SKBuff.ref}, struct device *, ${DMA::DMADirection});
-+            static void rtx_socket_skbuff_unmap_and_free(${Socket::SKBuff.ref}, struct device *, ${DMA::DMADirection});
++            static int  rtx_socket_skbuff_map(${Socket::SKBuff.ref}, ${Device::AbstractDevice.ref}, ${DMA::DMADirection.scalar});
++            static void rtx_socket_skbuff_unmap_and_free(${Socket::SKBuff.ref}, struct device *, ${DMA::DMADirection.scalar});
          }
  
          chunk   LKM::code()
-@@ -66,7 +66,7 @@
+@@ -65,23 +65,21 @@
+             }
  
              static int rtx_socket_skbuff_map(${Socket::SKBuff.ref} self,
-                                              struct device *dev,
+-                                             struct device *dev,
 -                                             enum dma_data_direction direction)
-+                                             ${DMA::DMADirection} direction)
++                                             ${Device::AbstractDevice.ref} dev,
++                                             ${DMA::DMADirection.scalar} direction)
              {
-                 ${Socket::AbstractSKBuff.ref}   skb = self->skbuff;
+-                ${Socket::AbstractSKBuff.ref}   skb = self->skbuff;
+-
+-                WARN_ON(!${local.skb.k_sk_buff});
+-                WARN_ON(self->dma_handle);
++                WARN_ON(!${local.self.k_sk_buff});
++                WARN_ON(${local.self.k_dma_handle});
  
-@@ -77,7 +77,7 @@
-                         dev,
+                 self->dma_handle = dma_map_single(
+-                        dev,
++                        ${dev.k_device},
                          ${local.skb.k_sk_buff},
                          skb_headlen(${local.skb.k_sk_buff}),
 -                        direction);
+-                int err = dma_mapping_error(dev, self->dma_handle);
 +                        ${local.direction.dma_direction});
-                 int err = dma_mapping_error(dev, self->dma_handle);
++                int err = ${DMA::mapping_error(local.dev, local.self.k_dma_handle)};
                  if (err)
                  {
-@@ -89,7 +89,7 @@
+-                    self->dma_handle = 0;
++                    ${local.self.k_dma_handle} = 0;
+                     return err;
+                 }
+                 return 0;
+@@ -89,7 +87,7 @@
  
              static void rtx_socket_skbuff_unmap_and_free(${Socket::SKBuff.ref} self,
                                                           struct device *dev,
@@ -58,7 +130,7 @@
              {
                  ${Socket::AbstractSKBuff.ref}   skb = self->skbuff;
  
-@@ -100,7 +100,7 @@
+@@ -100,7 +98,7 @@
                      dma_unmap_single(dev,
                              self->dma_handle,
                              skb_headlen(${local.skb.k_sk_buff}),
@@ -67,12 +139,12 @@
                      self->dma_handle = 0;
                  }
                  dev_kfree_skb_any(${local.skb.k_sk_buff});
-@@ -126,22 +126,22 @@
+@@ -126,30 +124,32 @@
  
          method   map_to(Device::AbstractDevice dev)
          {
 -            rtx_socket_skbuff_map(${self}, ${dev.k_device}, DMA_TO_DEVICE);
-+            rtx_socket_skbuff_map(${self}, ${dev.k_device}, RTX_DMA_TO_DEVICE);
++            rtx_socket_skbuff_map(${self}, ${dev}, RTX_DMA_TO_DEVICE);
          }
  
          method   map_from(Device::AbstractDevice dev)
@@ -94,3 +166,35 @@
          }
  
          map
+         {
+-            // some work may have to be done here in order
+-            // to access to some field of the sk_buff.
+-            // We should determine if all the sk_buff management
+-            // can be abstracted from the user.
++            // Some work may have to be done here in order to access to some
++            // field of the sk_buff. We should determine if all the sk_buff
++            // management can be abstracted from the user. But this is at least
++            // useful for internal use:
++            k_sk_buff: ((struct skbuff *)(${self}->skbuff));
++            k_dma_handle: ((dma_addr_t)(${self}->dma_handle));
+         }
+     }
+ }
+diff --git a/rathaxes/samples/e1000/socket.rti b/rathaxes/samples/e1000/socket.rti
+--- a/rathaxes/samples/e1000/socket.rti
++++ b/rathaxes/samples/e1000/socket.rti
+@@ -1,4 +1,4 @@
+-interface Socket : LKM, Device
++interface Socket : LKM, Device, DMA
+ {
+     /* The SKBuff type from the kernel */
+     provided type   AbstractSKBuff
+@@ -19,5 +19,8 @@
+         method      map_from(Device::AbstractDevice);
+         method      unmap_to_and_free(Device::AbstractDevice);
+         method      unmap_from_and_free(Device::AbstractDevice);
++
++        attribute   Socket::AbstractSKBuff.ref      k_sk_buff;
++        attribute   DMA::AbstractDMAHandle.scalar   k_dma_handle;
+     }
+ }