SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/staging/hv/ChannelInterface.c

   1 /*
   2  *
   3  * Copyright (c) 2009, Microsoft Corporation.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  16  * Place - Suite 330, Boston, MA 02111-1307 USA.
  17  *
  18  * Authors:
  19  *   Haiyang Zhang <haiyangz@microsoft.com>
  20  *   Hank Janssen  <hjanssen@microsoft.com>
  21  *
  22  */
  23
  24 #include <linux/kernel.h>
  25 #include <linux/mm.h>
  26 #include "osd.h"
  27 #include "VmbusPrivate.h"
  28
  29 static int
  30 IVmbusChannelOpen(
  31         struct hv_device *Device,
  32         u32                             SendBufferSize,
  33         u32                             RecvRingBufferSize,
  34         void *                          UserData,
  35         u32                             UserDataLen,
  36         VMBUS_CHANNEL_CALLBACK ChannelCallback,
  37         void *                          Context
  38         )
  39 {
  40         return VmbusChannelOpen((struct vmbus_channel *)Device->context,
  41                                                                 SendBufferSize,
  42                                                                 RecvRingBufferSize,
  43                                                                 UserData,
  44                                                                 UserDataLen,
  45                                                                 ChannelCallback,
  46                                                                 Context);
  47 }
  48
  49
  50 static void
  51 IVmbusChannelClose(
  52         struct hv_device *Device
  53         )
  54 {
  55         VmbusChannelClose((struct vmbus_channel *)Device->context);
  56 }
  57
  58
  59 static int
  60 IVmbusChannelSendPacket(
  61         struct hv_device *Device,
  62         const void *                    Buffer,
  63         u32                             BufferLen,
  64         u64                             RequestId,
  65         u32                             Type,
  66         u32                             Flags
  67         )
  68 {
  69         return VmbusChannelSendPacket((struct vmbus_channel *)Device->context,
  70                                                                         Buffer,
  71                                                                         BufferLen,
  72                                                                         RequestId,
  73                                                                         Type,
  74                                                                         Flags);
  75 }
  76
  77 static int
  78 IVmbusChannelSendPacketPageBuffer(
  79         struct hv_device *Device,
  80         struct hv_page_buffer PageBuffers[],
  81         u32                             PageCount,
  82         void *                          Buffer,
  83         u32                             BufferLen,
  84         u64                             RequestId
  85         )
  86 {
  87         return VmbusChannelSendPacketPageBuffer((struct vmbus_channel *)Device->context,
  88                                                                                                 PageBuffers,
  89                                                                                                 PageCount,
  90                                                                                                 Buffer,
  91                                                                                                 BufferLen,
  92                                                                                                 RequestId);
  93 }
  94
  95 static int
  96 IVmbusChannelSendPacketMultiPageBuffer(
  97         struct hv_device *Device,
  98         struct hv_multipage_buffer *MultiPageBuffer,
  99         void *                          Buffer,
 100         u32                             BufferLen,
 101         u64                             RequestId
 102         )
 103 {
 104         return VmbusChannelSendPacketMultiPageBuffer((struct vmbus_channel *)Device->context,
 105                                                                                                         MultiPageBuffer,
 106                                                                                                         Buffer,
 107                                                                                                         BufferLen,
 108                                                                                                         RequestId);
 109 }
 110
 111 static int
 112 IVmbusChannelRecvPacket (
 113         struct hv_device *Device,
 114         void *                          Buffer,
 115         u32                             BufferLen,
 116         u32*                            BufferActualLen,
 117         u64*                            RequestId
 118         )
 119 {
 120         return VmbusChannelRecvPacket((struct vmbus_channel *)Device->context,
 121                                                                         Buffer,
 122                                                                         BufferLen,
 123                                                                         BufferActualLen,
 124                                                                         RequestId);
 125 }
 126
 127 static int
 128 IVmbusChannelRecvPacketRaw(
 129         struct hv_device *Device,
 130         void *                          Buffer,
 131         u32                             BufferLen,
 132         u32*                            BufferActualLen,
 133         u64*                            RequestId
 134         )
 135 {
 136         return VmbusChannelRecvPacketRaw((struct vmbus_channel *)Device->context,
 137                                                                                 Buffer,
 138                                                                                 BufferLen,
 139                                                                                 BufferActualLen,
 140                                                                                 RequestId);
 141 }
 142
 143 static int
 144 IVmbusChannelEstablishGpadl(
 145         struct hv_device *Device,
 146         void *                          Buffer,
 147         u32                             BufferLen,
 148         u32*                            GpadlHandle
 149         )
 150 {
 151         return VmbusChannelEstablishGpadl((struct vmbus_channel *)Device->context,
 152                                                                                 Buffer,
 153                                                                                 BufferLen,
 154                                                                                 GpadlHandle);
 155 }
 156
 157 static int
 158 IVmbusChannelTeardownGpadl(
 159    struct hv_device *Device,
 160    u32                          GpadlHandle
 161         )
 162 {
 163         return VmbusChannelTeardownGpadl((struct vmbus_channel *)Device->context,
 164                                                                                 GpadlHandle);
 165
 166 }
 167
 168 void GetChannelInterface(struct vmbus_channel_interface *ChannelInterface)
 169 {
 170         ChannelInterface->Open                                          = IVmbusChannelOpen;
 171         ChannelInterface->Close                                         = IVmbusChannelClose;
 172         ChannelInterface->SendPacket                            = IVmbusChannelSendPacket;
 173         ChannelInterface->SendPacketPageBuffer          = IVmbusChannelSendPacketPageBuffer;
 174         ChannelInterface->SendPacketMultiPageBuffer = IVmbusChannelSendPacketMultiPageBuffer;
 175         ChannelInterface->RecvPacket                            = IVmbusChannelRecvPacket;
 176         ChannelInterface->RecvPacketRaw                         = IVmbusChannelRecvPacketRaw;
 177         ChannelInterface->EstablishGpadl                        = IVmbusChannelEstablishGpadl;
 178         ChannelInterface->TeardownGpadl                         = IVmbusChannelTeardownGpadl;
 179         ChannelInterface->GetInfo                                       = GetChannelInfo;
 180 }
 181
 182
 183 void GetChannelInfo(struct hv_device *Device, struct hv_device_info *DeviceInfo)
 184 {
 185         struct vmbus_channel_debug_info debugInfo;
 186
 187         if (Device->context)
 188         {
 189                 VmbusChannelGetDebugInfo((struct vmbus_channel *)Device->context, &debugInfo);
 190
 191                 DeviceInfo->ChannelId = debugInfo.RelId;
 192                 DeviceInfo->ChannelState = debugInfo.State;
 193                 memcpy(&DeviceInfo->ChannelType, &debugInfo.InterfaceType, sizeof(struct hv_guid));
 194                 memcpy(&DeviceInfo->ChannelInstance, &debugInfo.InterfaceInstance, sizeof(struct hv_guid));
 195
 196                 DeviceInfo->MonitorId = debugInfo.MonitorId;
 197
 198                 DeviceInfo->ServerMonitorPending = debugInfo.ServerMonitorPending;
 199                 DeviceInfo->ServerMonitorLatency = debugInfo.ServerMonitorLatency;
 200                 DeviceInfo->ServerMonitorConnectionId = debugInfo.ServerMonitorConnectionId;
 201
 202                 DeviceInfo->ClientMonitorPending = debugInfo.ClientMonitorPending;
 203                 DeviceInfo->ClientMonitorLatency = debugInfo.ClientMonitorLatency;
 204                 DeviceInfo->ClientMonitorConnectionId = debugInfo.ClientMonitorConnectionId;
 205
 206                 DeviceInfo->Inbound.InterruptMask = debugInfo.Inbound.CurrentInterruptMask;
 207                 DeviceInfo->Inbound.ReadIndex = debugInfo.Inbound.CurrentReadIndex;
 208                 DeviceInfo->Inbound.WriteIndex = debugInfo.Inbound.CurrentWriteIndex;
 209                 DeviceInfo->Inbound.BytesAvailToRead = debugInfo.Inbound.BytesAvailToRead;
 210                 DeviceInfo->Inbound.BytesAvailToWrite = debugInfo.Inbound.BytesAvailToWrite;
 211
 212                 DeviceInfo->Outbound.InterruptMask = debugInfo.Outbound.CurrentInterruptMask;
 213                 DeviceInfo->Outbound.ReadIndex = debugInfo.Outbound.CurrentReadIndex;
 214                 DeviceInfo->Outbound.WriteIndex = debugInfo.Outbound.CurrentWriteIndex;
 215                 DeviceInfo->Outbound.BytesAvailToRead = debugInfo.Outbound.BytesAvailToRead;
 216                 DeviceInfo->Outbound.BytesAvailToWrite = debugInfo.Outbound.BytesAvailToWrite;
 217         }
 218 }