1 /** @file 2 3 This driver produces Virtio Device Protocol instances for Virtio PCI devices. 4 5 Copyright (C) 2012, Red Hat, Inc. 6 Copyright (c) 2012, Intel Corporation. All rights reserved.<BR> 7 Copyright (C) 2013, ARM Ltd. 8 9 This program and the accompanying materials are licensed and made available 10 under the terms and conditions of the BSD License which accompanies this 11 distribution. The full text of the license may be found at 12 http://opensource.org/licenses/bsd-license.php 13 14 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT 15 WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 16 17 **/ 18 #include <Library/BaseMemoryLib.h> 19 #include <Library/DebugLib.h> 20 #include <Library/MemoryAllocationLib.h> 21 #include <Library/UefiBootServicesTableLib.h> 22 #include <Library/UefiLib.h> 23 #include "VirtioPciDevice.h" 24 25 /** 26 27 Read a word from Region 0 of the device specified by VirtIo Device protocol. 28 29 The function implements the ReadDevice protocol member of 30 VIRTIO_DEVICE_PROTOCOL. 31 32 @param[in] This VirtIo Device protocol. 33 34 @param[in] FieldOffset Source offset. 35 36 @param[in] FieldSize Source field size, must be in { 1, 2, 4, 8 }. 37 38 @param[in] BufferSize Number of bytes available in the target buffer. Must 39 equal FieldSize. 40 41 @param[out] Buffer Target buffer. 42 43 44 @return Status code returned by PciIo->Io.Read(). 45 46 **/ 47 EFI_STATUS 48 EFIAPI VirtioPciDeviceRead(IN VIRTIO_DEVICE_PROTOCOL * This,IN UINTN FieldOffset,IN UINTN FieldSize,IN UINTN BufferSize,OUT VOID * Buffer)49 VirtioPciDeviceRead ( 50 IN VIRTIO_DEVICE_PROTOCOL *This, 51 IN UINTN FieldOffset, 52 IN UINTN FieldSize, 53 IN UINTN BufferSize, 54 OUT VOID *Buffer 55 ) 56 { 57 VIRTIO_PCI_DEVICE *Dev; 58 59 Dev = VIRTIO_PCI_DEVICE_FROM_VIRTIO_DEVICE (This); 60 61 return VirtioPciIoRead (Dev, 62 Dev->DeviceSpecificConfigurationOffset + FieldOffset, 63 FieldSize, BufferSize, Buffer); 64 } 65 66 /** 67 68 Write a word into Region 0 of the device specified by VirtIo Device protocol. 69 70 @param[in] This VirtIo Device protocol. 71 72 @param[in] FieldOffset Destination offset. 73 74 @param[in] FieldSize Destination field size, must be in { 1, 2, 4, 8 }. 75 76 @param[in] Value Little endian value to write, converted to UINT64. 77 The least significant FieldSize bytes will be used. 78 79 80 @return Status code returned by PciIo->Io.Write(). 81 82 **/ 83 EFI_STATUS 84 EFIAPI VirtioPciDeviceWrite(IN VIRTIO_DEVICE_PROTOCOL * This,IN UINTN FieldOffset,IN UINTN FieldSize,IN UINT64 Value)85 VirtioPciDeviceWrite ( 86 IN VIRTIO_DEVICE_PROTOCOL *This, 87 IN UINTN FieldOffset, 88 IN UINTN FieldSize, 89 IN UINT64 Value 90 ) 91 { 92 VIRTIO_PCI_DEVICE *Dev; 93 94 Dev = VIRTIO_PCI_DEVICE_FROM_VIRTIO_DEVICE (This); 95 96 return VirtioPciIoWrite (Dev, 97 Dev->DeviceSpecificConfigurationOffset + FieldOffset, FieldSize, Value); 98 } 99 100 EFI_STATUS 101 EFIAPI VirtioPciGetDeviceFeatures(IN VIRTIO_DEVICE_PROTOCOL * This,OUT UINT32 * DeviceFeatures)102 VirtioPciGetDeviceFeatures ( 103 IN VIRTIO_DEVICE_PROTOCOL *This, 104 OUT UINT32 *DeviceFeatures 105 ) 106 { 107 VIRTIO_PCI_DEVICE *Dev; 108 109 if (DeviceFeatures == NULL) { 110 return EFI_INVALID_PARAMETER; 111 } 112 113 Dev = VIRTIO_PCI_DEVICE_FROM_VIRTIO_DEVICE (This); 114 115 return VirtioPciIoRead (Dev, VIRTIO_PCI_OFFSET_DEVICE_FEATURES, sizeof (UINT32), 116 sizeof (UINT32), DeviceFeatures); 117 } 118 119 EFI_STATUS 120 EFIAPI VirtioPciGetQueueAddress(IN VIRTIO_DEVICE_PROTOCOL * This,OUT UINT32 * QueueAddress)121 VirtioPciGetQueueAddress ( 122 IN VIRTIO_DEVICE_PROTOCOL *This, 123 OUT UINT32 *QueueAddress 124 ) 125 { 126 VIRTIO_PCI_DEVICE *Dev; 127 128 if (QueueAddress == NULL) { 129 return EFI_INVALID_PARAMETER; 130 } 131 132 Dev = VIRTIO_PCI_DEVICE_FROM_VIRTIO_DEVICE (This); 133 134 return VirtioPciIoRead (Dev, VIRTIO_PCI_OFFSET_QUEUE_ADDRESS, sizeof (UINT32), 135 sizeof (UINT32), QueueAddress); 136 } 137 138 EFI_STATUS 139 EFIAPI VirtioPciGetQueueSize(IN VIRTIO_DEVICE_PROTOCOL * This,OUT UINT16 * QueueNumMax)140 VirtioPciGetQueueSize ( 141 IN VIRTIO_DEVICE_PROTOCOL *This, 142 OUT UINT16 *QueueNumMax 143 ) 144 { 145 VIRTIO_PCI_DEVICE *Dev; 146 147 if (QueueNumMax == NULL) { 148 return EFI_INVALID_PARAMETER; 149 } 150 151 Dev = VIRTIO_PCI_DEVICE_FROM_VIRTIO_DEVICE (This); 152 153 return VirtioPciIoRead (Dev, VIRTIO_PCI_OFFSET_QUEUE_SIZE, sizeof (UINT16), 154 sizeof (UINT16), QueueNumMax); 155 } 156 157 EFI_STATUS 158 EFIAPI VirtioPciGetDeviceStatus(IN VIRTIO_DEVICE_PROTOCOL * This,OUT UINT8 * DeviceStatus)159 VirtioPciGetDeviceStatus ( 160 IN VIRTIO_DEVICE_PROTOCOL *This, 161 OUT UINT8 *DeviceStatus 162 ) 163 { 164 VIRTIO_PCI_DEVICE *Dev; 165 166 if (DeviceStatus == NULL) { 167 return EFI_INVALID_PARAMETER; 168 } 169 170 Dev = VIRTIO_PCI_DEVICE_FROM_VIRTIO_DEVICE (This); 171 172 return VirtioPciIoRead (Dev, VIRTIO_PCI_OFFSET_QUEUE_DEVICE_STATUS, 173 sizeof (UINT8), sizeof (UINT8), DeviceStatus); 174 } 175 176 EFI_STATUS 177 EFIAPI VirtioPciSetGuestFeatures(IN VIRTIO_DEVICE_PROTOCOL * This,IN UINT32 Features)178 VirtioPciSetGuestFeatures ( 179 IN VIRTIO_DEVICE_PROTOCOL *This, 180 IN UINT32 Features 181 ) 182 { 183 VIRTIO_PCI_DEVICE *Dev; 184 185 Dev = VIRTIO_PCI_DEVICE_FROM_VIRTIO_DEVICE (This); 186 187 return VirtioPciIoWrite (Dev, VIRTIO_PCI_OFFSET_GUEST_FEATURES, 188 sizeof (UINT32), Features); 189 } 190 191 EFI_STATUS 192 EFIAPI VirtioPciSetQueueAddress(VIRTIO_DEVICE_PROTOCOL * This,UINT32 Address)193 VirtioPciSetQueueAddress ( 194 VIRTIO_DEVICE_PROTOCOL *This, 195 UINT32 Address 196 ) 197 { 198 VIRTIO_PCI_DEVICE *Dev; 199 200 Dev = VIRTIO_PCI_DEVICE_FROM_VIRTIO_DEVICE (This); 201 202 return VirtioPciIoWrite (Dev, VIRTIO_PCI_OFFSET_QUEUE_ADDRESS, sizeof (UINT32), 203 Address); 204 } 205 206 EFI_STATUS 207 EFIAPI VirtioPciSetQueueSel(VIRTIO_DEVICE_PROTOCOL * This,UINT16 Sel)208 VirtioPciSetQueueSel ( 209 VIRTIO_DEVICE_PROTOCOL *This, 210 UINT16 Sel 211 ) 212 { 213 VIRTIO_PCI_DEVICE *Dev; 214 215 Dev = VIRTIO_PCI_DEVICE_FROM_VIRTIO_DEVICE (This); 216 217 return VirtioPciIoWrite (Dev, VIRTIO_PCI_OFFSET_QUEUE_SELECT, sizeof (UINT16), 218 Sel); 219 } 220 221 EFI_STATUS 222 EFIAPI VirtioPciSetQueueAlignment(VIRTIO_DEVICE_PROTOCOL * This,UINT32 Alignment)223 VirtioPciSetQueueAlignment ( 224 VIRTIO_DEVICE_PROTOCOL *This, 225 UINT32 Alignment 226 ) 227 { 228 return EFI_SUCCESS; 229 } 230 231 EFI_STATUS 232 EFIAPI VirtioPciSetPageSize(VIRTIO_DEVICE_PROTOCOL * This,UINT32 PageSize)233 VirtioPciSetPageSize ( 234 VIRTIO_DEVICE_PROTOCOL *This, 235 UINT32 PageSize 236 ) 237 { 238 return (PageSize == EFI_PAGE_SIZE) ? EFI_SUCCESS : EFI_UNSUPPORTED; 239 } 240 241 EFI_STATUS 242 EFIAPI VirtioPciSetQueueNotify(VIRTIO_DEVICE_PROTOCOL * This,UINT16 Index)243 VirtioPciSetQueueNotify ( 244 VIRTIO_DEVICE_PROTOCOL *This, 245 UINT16 Index 246 ) 247 { 248 VIRTIO_PCI_DEVICE *Dev; 249 250 Dev = VIRTIO_PCI_DEVICE_FROM_VIRTIO_DEVICE (This); 251 252 return VirtioPciIoWrite (Dev, VIRTIO_PCI_OFFSET_QUEUE_NOTIFY, sizeof (UINT16), 253 Index); 254 } 255 256 EFI_STATUS 257 EFIAPI VirtioPciSetQueueSize(VIRTIO_DEVICE_PROTOCOL * This,UINT16 Size)258 VirtioPciSetQueueSize ( 259 VIRTIO_DEVICE_PROTOCOL *This, 260 UINT16 Size 261 ) 262 { 263 // 264 // This function is only applicable in Virtio-MMIO. 265 // (The QueueSize field is read-only in Virtio proper (PCI)) 266 // 267 return EFI_SUCCESS; 268 } 269 270 EFI_STATUS 271 EFIAPI VirtioPciSetDeviceStatus(VIRTIO_DEVICE_PROTOCOL * This,UINT8 DeviceStatus)272 VirtioPciSetDeviceStatus ( 273 VIRTIO_DEVICE_PROTOCOL *This, 274 UINT8 DeviceStatus 275 ) 276 { 277 VIRTIO_PCI_DEVICE *Dev; 278 279 Dev = VIRTIO_PCI_DEVICE_FROM_VIRTIO_DEVICE (This); 280 281 return VirtioPciIoWrite (Dev, VIRTIO_PCI_OFFSET_QUEUE_DEVICE_STATUS, 282 sizeof (UINT8), DeviceStatus); 283 } 284