PvScsi.c 38 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570
  1. /** @file
  2. This driver produces Extended SCSI Pass Thru Protocol instances for
  3. pvscsi devices.
  4. Copyright (C) 2020, Oracle and/or its affiliates.
  5. SPDX-License-Identifier: BSD-2-Clause-Patent
  6. **/
  7. #include <IndustryStandard/Pci.h>
  8. #include <IndustryStandard/PvScsi.h>
  9. #include <Library/BaseLib.h>
  10. #include <Library/BaseMemoryLib.h>
  11. #include <Library/MemoryAllocationLib.h>
  12. #include <Library/UefiBootServicesTableLib.h>
  13. #include <Library/UefiLib.h>
  14. #include <Protocol/PciIo.h>
  15. #include <Protocol/PciRootBridgeIo.h>
  16. #include <Uefi/UefiSpec.h>
  17. #include "PvScsi.h"
  18. //
  19. // Higher versions will be used before lower, 0x10-0xffffffef is the version
  20. // range for IHV (Indie Hardware Vendors)
  21. //
  22. #define PVSCSI_BINDING_VERSION 0x10
  23. //
  24. // Ext SCSI Pass Thru utilities
  25. //
  26. /**
  27. Reads a 32-bit value into BAR0 using MMIO
  28. **/
  29. STATIC
  30. EFI_STATUS
  31. PvScsiMmioRead32 (
  32. IN CONST PVSCSI_DEV *Dev,
  33. IN UINT64 Offset,
  34. OUT UINT32 *Value
  35. )
  36. {
  37. return Dev->PciIo->Mem.Read (
  38. Dev->PciIo,
  39. EfiPciIoWidthUint32,
  40. PCI_BAR_IDX0,
  41. Offset,
  42. 1, // Count
  43. Value
  44. );
  45. }
  46. /**
  47. Writes a 32-bit value into BAR0 using MMIO
  48. **/
  49. STATIC
  50. EFI_STATUS
  51. PvScsiMmioWrite32 (
  52. IN CONST PVSCSI_DEV *Dev,
  53. IN UINT64 Offset,
  54. IN UINT32 Value
  55. )
  56. {
  57. return Dev->PciIo->Mem.Write (
  58. Dev->PciIo,
  59. EfiPciIoWidthUint32,
  60. PCI_BAR_IDX0,
  61. Offset,
  62. 1, // Count
  63. &Value
  64. );
  65. }
  66. /**
  67. Writes multiple words of data into BAR0 using MMIO
  68. **/
  69. STATIC
  70. EFI_STATUS
  71. PvScsiMmioWrite32Multiple (
  72. IN CONST PVSCSI_DEV *Dev,
  73. IN UINT64 Offset,
  74. IN UINTN Count,
  75. IN UINT32 *Words
  76. )
  77. {
  78. return Dev->PciIo->Mem.Write (
  79. Dev->PciIo,
  80. EfiPciIoWidthFifoUint32,
  81. PCI_BAR_IDX0,
  82. Offset,
  83. Count,
  84. Words
  85. );
  86. }
  87. /**
  88. Send a PVSCSI command to device.
  89. @param[in] Dev The pvscsi host device.
  90. @param[in] Cmd The command to send to device.
  91. @param[in] OPTIONAL DescWords An optional command descriptor (If command
  92. have a descriptor). The descriptor is
  93. provided as an array of UINT32 words and
  94. is must be 32-bit aligned.
  95. @param[in] DescWordsCount The number of words in command descriptor.
  96. Caller must specify here 0 if DescWords
  97. is not supplied (It is optional). In that
  98. case, DescWords is ignored.
  99. @return Status codes returned by Dev->PciIo->Mem.Write().
  100. **/
  101. STATIC
  102. EFI_STATUS
  103. PvScsiWriteCmdDesc (
  104. IN CONST PVSCSI_DEV *Dev,
  105. IN UINT32 Cmd,
  106. IN UINT32 *DescWords OPTIONAL,
  107. IN UINTN DescWordsCount
  108. )
  109. {
  110. EFI_STATUS Status;
  111. if (DescWordsCount > PVSCSI_MAX_CMD_DATA_WORDS) {
  112. return EFI_INVALID_PARAMETER;
  113. }
  114. Status = PvScsiMmioWrite32 (Dev, PvScsiRegOffsetCommand, Cmd);
  115. if (EFI_ERROR (Status)) {
  116. return Status;
  117. }
  118. if (DescWordsCount > 0) {
  119. return PvScsiMmioWrite32Multiple (
  120. Dev,
  121. PvScsiRegOffsetCommandData,
  122. DescWordsCount,
  123. DescWords
  124. );
  125. }
  126. return EFI_SUCCESS;
  127. }
  128. STATIC
  129. EFI_STATUS
  130. PvScsiResetAdapter (
  131. IN CONST PVSCSI_DEV *Dev
  132. )
  133. {
  134. return PvScsiWriteCmdDesc (Dev, PvScsiCmdAdapterReset, NULL, 0);
  135. }
  136. /**
  137. Returns if PVSCSI request ring is full
  138. **/
  139. STATIC
  140. BOOLEAN
  141. PvScsiIsReqRingFull (
  142. IN CONST PVSCSI_DEV *Dev
  143. )
  144. {
  145. PVSCSI_RINGS_STATE *RingsState;
  146. UINT32 ReqNumEntries;
  147. RingsState = Dev->RingDesc.RingState;
  148. ReqNumEntries = 1U << RingsState->ReqNumEntriesLog2;
  149. return (RingsState->ReqProdIdx - RingsState->CmpConsIdx) >= ReqNumEntries;
  150. }
  151. /**
  152. Returns pointer to current request descriptor to produce
  153. **/
  154. STATIC
  155. PVSCSI_RING_REQ_DESC *
  156. PvScsiGetCurrentRequest (
  157. IN CONST PVSCSI_DEV *Dev
  158. )
  159. {
  160. PVSCSI_RINGS_STATE *RingState;
  161. UINT32 ReqNumEntries;
  162. RingState = Dev->RingDesc.RingState;
  163. ReqNumEntries = 1U << RingState->ReqNumEntriesLog2;
  164. return Dev->RingDesc.RingReqs +
  165. (RingState->ReqProdIdx & (ReqNumEntries - 1));
  166. }
  167. /**
  168. Returns pointer to current completion descriptor to consume
  169. **/
  170. STATIC
  171. PVSCSI_RING_CMP_DESC *
  172. PvScsiGetCurrentResponse (
  173. IN CONST PVSCSI_DEV *Dev
  174. )
  175. {
  176. PVSCSI_RINGS_STATE *RingState;
  177. UINT32 CmpNumEntries;
  178. RingState = Dev->RingDesc.RingState;
  179. CmpNumEntries = 1U << RingState->CmpNumEntriesLog2;
  180. return Dev->RingDesc.RingCmps +
  181. (RingState->CmpConsIdx & (CmpNumEntries - 1));
  182. }
  183. /**
  184. Wait for device to signal completion of submitted requests
  185. **/
  186. STATIC
  187. EFI_STATUS
  188. PvScsiWaitForRequestCompletion (
  189. IN CONST PVSCSI_DEV *Dev
  190. )
  191. {
  192. EFI_STATUS Status;
  193. UINT32 IntrStatus;
  194. //
  195. // Note: We don't yet support Timeout according to
  196. // EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET.Timeout.
  197. //
  198. // This is consistent with some other Scsi PassThru drivers
  199. // such as VirtioScsi.
  200. //
  201. for ( ; ;) {
  202. Status = PvScsiMmioRead32 (Dev, PvScsiRegOffsetIntrStatus, &IntrStatus);
  203. if (EFI_ERROR (Status)) {
  204. return Status;
  205. }
  206. //
  207. // PVSCSI_INTR_CMPL_MASK is set if device completed submitted requests
  208. //
  209. if ((IntrStatus & PVSCSI_INTR_CMPL_MASK) != 0) {
  210. break;
  211. }
  212. gBS->Stall (Dev->WaitForCmpStallInUsecs);
  213. }
  214. //
  215. // Acknowledge PVSCSI_INTR_CMPL_MASK in device interrupt-status register
  216. //
  217. return PvScsiMmioWrite32 (
  218. Dev,
  219. PvScsiRegOffsetIntrStatus,
  220. PVSCSI_INTR_CMPL_MASK
  221. );
  222. }
  223. /**
  224. Create a fake host adapter error
  225. **/
  226. STATIC
  227. EFI_STATUS
  228. ReportHostAdapterError (
  229. OUT EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet
  230. )
  231. {
  232. Packet->InTransferLength = 0;
  233. Packet->OutTransferLength = 0;
  234. Packet->SenseDataLength = 0;
  235. Packet->HostAdapterStatus = EFI_EXT_SCSI_STATUS_HOST_ADAPTER_OTHER;
  236. Packet->TargetStatus = EFI_EXT_SCSI_STATUS_TARGET_GOOD;
  237. return EFI_DEVICE_ERROR;
  238. }
  239. /**
  240. Create a fake host adapter overrun error
  241. **/
  242. STATIC
  243. EFI_STATUS
  244. ReportHostAdapterOverrunError (
  245. OUT EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet
  246. )
  247. {
  248. Packet->SenseDataLength = 0;
  249. Packet->HostAdapterStatus =
  250. EFI_EXT_SCSI_STATUS_HOST_ADAPTER_DATA_OVERRUN_UNDERRUN;
  251. Packet->TargetStatus = EFI_EXT_SCSI_STATUS_TARGET_GOOD;
  252. return EFI_BAD_BUFFER_SIZE;
  253. }
  254. /**
  255. Populate a PVSCSI request descriptor from the Extended SCSI Pass Thru
  256. Protocol packet.
  257. **/
  258. STATIC
  259. EFI_STATUS
  260. PopulateRequest (
  261. IN CONST PVSCSI_DEV *Dev,
  262. IN UINT8 *Target,
  263. IN UINT64 Lun,
  264. IN OUT EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet,
  265. OUT PVSCSI_RING_REQ_DESC *Request
  266. )
  267. {
  268. UINT8 TargetValue;
  269. //
  270. // We only use first byte of target identifer
  271. //
  272. TargetValue = *Target;
  273. //
  274. // Check for unsupported requests
  275. //
  276. if (
  277. //
  278. // Bidirectional transfer was requested
  279. //
  280. ((Packet->InTransferLength > 0) && (Packet->OutTransferLength > 0)) ||
  281. (Packet->DataDirection == EFI_EXT_SCSI_DATA_DIRECTION_BIDIRECTIONAL) ||
  282. //
  283. // Command Descriptor Block bigger than this constant should be considered
  284. // out-of-band. We currently don't support these CDBs.
  285. //
  286. (Packet->CdbLength > PVSCSI_CDB_MAX_SIZE)
  287. )
  288. {
  289. //
  290. // This error code doesn't require updates to the Packet output fields
  291. //
  292. return EFI_UNSUPPORTED;
  293. }
  294. //
  295. // Check for invalid parameters
  296. //
  297. if (
  298. //
  299. // Addressed invalid device
  300. //
  301. (TargetValue > Dev->MaxTarget) || (Lun > Dev->MaxLun) ||
  302. //
  303. // Invalid direction (there doesn't seem to be a macro for the "no data
  304. // transferred" "direction", eg. for TEST UNIT READY)
  305. //
  306. (Packet->DataDirection > EFI_EXT_SCSI_DATA_DIRECTION_BIDIRECTIONAL) ||
  307. //
  308. // Trying to receive, but destination pointer is NULL, or contradicting
  309. // transfer direction
  310. //
  311. ((Packet->InTransferLength > 0) &&
  312. ((Packet->InDataBuffer == NULL) ||
  313. (Packet->DataDirection == EFI_EXT_SCSI_DATA_DIRECTION_WRITE)
  314. )
  315. ) ||
  316. //
  317. // Trying to send, but source pointer is NULL, or contradicting
  318. // transfer direction
  319. //
  320. ((Packet->OutTransferLength > 0) &&
  321. ((Packet->OutDataBuffer == NULL) ||
  322. (Packet->DataDirection == EFI_EXT_SCSI_DATA_DIRECTION_READ)
  323. )
  324. )
  325. )
  326. {
  327. //
  328. // This error code doesn't require updates to the Packet output fields
  329. //
  330. return EFI_INVALID_PARAMETER;
  331. }
  332. //
  333. // Check for input/output buffer too large for DMA communication buffer
  334. //
  335. if (Packet->InTransferLength > sizeof (Dev->DmaBuf->Data)) {
  336. Packet->InTransferLength = sizeof (Dev->DmaBuf->Data);
  337. return ReportHostAdapterOverrunError (Packet);
  338. }
  339. if (Packet->OutTransferLength > sizeof (Dev->DmaBuf->Data)) {
  340. Packet->OutTransferLength = sizeof (Dev->DmaBuf->Data);
  341. return ReportHostAdapterOverrunError (Packet);
  342. }
  343. //
  344. // Encode PVSCSI request
  345. //
  346. ZeroMem (Request, sizeof (*Request));
  347. Request->Bus = 0;
  348. Request->Target = TargetValue;
  349. //
  350. // This cast is safe as PVSCSI_DEV.MaxLun is defined as UINT8
  351. //
  352. Request->Lun[1] = (UINT8)Lun;
  353. Request->SenseLen = Packet->SenseDataLength;
  354. //
  355. // DMA communication buffer SenseData overflow is not possible
  356. // due to Packet->SenseDataLength defined as UINT8
  357. //
  358. Request->SenseAddr = PVSCSI_DMA_BUF_DEV_ADDR (Dev, SenseData);
  359. Request->CdbLen = Packet->CdbLength;
  360. CopyMem (Request->Cdb, Packet->Cdb, Packet->CdbLength);
  361. Request->VcpuHint = 0;
  362. Request->Tag = PVSCSI_SIMPLE_QUEUE_TAG;
  363. if (Packet->DataDirection == EFI_EXT_SCSI_DATA_DIRECTION_READ) {
  364. Request->Flags = PVSCSI_FLAG_CMD_DIR_TOHOST;
  365. Request->DataLen = Packet->InTransferLength;
  366. } else {
  367. Request->Flags = PVSCSI_FLAG_CMD_DIR_TODEVICE;
  368. Request->DataLen = Packet->OutTransferLength;
  369. CopyMem (
  370. Dev->DmaBuf->Data,
  371. Packet->OutDataBuffer,
  372. Packet->OutTransferLength
  373. );
  374. }
  375. Request->DataAddr = PVSCSI_DMA_BUF_DEV_ADDR (Dev, Data);
  376. return EFI_SUCCESS;
  377. }
  378. /**
  379. Handle the PVSCSI device response:
  380. - Copy returned data from DMA communication buffer.
  381. - Update fields in Extended SCSI Pass Thru Protocol packet as required.
  382. - Translate response code to EFI status code and host adapter status.
  383. **/
  384. STATIC
  385. EFI_STATUS
  386. HandleResponse (
  387. IN PVSCSI_DEV *Dev,
  388. IN OUT EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet,
  389. IN CONST PVSCSI_RING_CMP_DESC *Response
  390. )
  391. {
  392. //
  393. // Fix SenseDataLength to amount of data returned
  394. //
  395. if (Packet->SenseDataLength > Response->SenseLen) {
  396. Packet->SenseDataLength = (UINT8)Response->SenseLen;
  397. }
  398. //
  399. // Copy sense data from DMA communication buffer
  400. //
  401. CopyMem (
  402. Packet->SenseData,
  403. Dev->DmaBuf->SenseData,
  404. Packet->SenseDataLength
  405. );
  406. //
  407. // Copy device output from DMA communication buffer
  408. //
  409. if (Packet->DataDirection == EFI_EXT_SCSI_DATA_DIRECTION_READ) {
  410. CopyMem (Packet->InDataBuffer, Dev->DmaBuf->Data, Packet->InTransferLength);
  411. }
  412. //
  413. // Report target status
  414. // (Strangely, PVSCSI interface defines Response->ScsiStatus as UINT16.
  415. // But it should de-facto always have a value that fits UINT8. To avoid
  416. // unexpected behavior, verify value is in UINT8 bounds before casting)
  417. //
  418. ASSERT (Response->ScsiStatus <= MAX_UINT8);
  419. Packet->TargetStatus = (UINT8)Response->ScsiStatus;
  420. //
  421. // Host adapter status and function return value depend on
  422. // device response's host status
  423. //
  424. switch (Response->HostStatus) {
  425. case PvScsiBtStatSuccess:
  426. case PvScsiBtStatLinkedCommandCompleted:
  427. case PvScsiBtStatLinkedCommandCompletedWithFlag:
  428. Packet->HostAdapterStatus = EFI_EXT_SCSI_STATUS_HOST_ADAPTER_OK;
  429. return EFI_SUCCESS;
  430. case PvScsiBtStatDataUnderrun:
  431. //
  432. // Report transferred amount in underrun
  433. //
  434. if (Packet->DataDirection == EFI_EXT_SCSI_DATA_DIRECTION_READ) {
  435. Packet->InTransferLength = (UINT32)Response->DataLen;
  436. } else {
  437. Packet->OutTransferLength = (UINT32)Response->DataLen;
  438. }
  439. Packet->HostAdapterStatus =
  440. EFI_EXT_SCSI_STATUS_HOST_ADAPTER_DATA_OVERRUN_UNDERRUN;
  441. return EFI_SUCCESS;
  442. case PvScsiBtStatDatarun:
  443. Packet->HostAdapterStatus =
  444. EFI_EXT_SCSI_STATUS_HOST_ADAPTER_DATA_OVERRUN_UNDERRUN;
  445. return EFI_SUCCESS;
  446. case PvScsiBtStatSelTimeout:
  447. Packet->HostAdapterStatus =
  448. EFI_EXT_SCSI_STATUS_HOST_ADAPTER_SELECTION_TIMEOUT;
  449. return EFI_TIMEOUT;
  450. case PvScsiBtStatBusFree:
  451. Packet->HostAdapterStatus = EFI_EXT_SCSI_STATUS_HOST_ADAPTER_BUS_FREE;
  452. break;
  453. case PvScsiBtStatInvPhase:
  454. Packet->HostAdapterStatus = EFI_EXT_SCSI_STATUS_HOST_ADAPTER_PHASE_ERROR;
  455. break;
  456. case PvScsiBtStatSensFailed:
  457. Packet->HostAdapterStatus =
  458. EFI_EXT_SCSI_STATUS_HOST_ADAPTER_REQUEST_SENSE_FAILED;
  459. break;
  460. case PvScsiBtStatTagReject:
  461. case PvScsiBtStatBadMsg:
  462. Packet->HostAdapterStatus =
  463. EFI_EXT_SCSI_STATUS_HOST_ADAPTER_MESSAGE_REJECT;
  464. break;
  465. case PvScsiBtStatBusReset:
  466. Packet->HostAdapterStatus = EFI_EXT_SCSI_STATUS_HOST_ADAPTER_BUS_RESET;
  467. break;
  468. case PvScsiBtStatHaTimeout:
  469. Packet->HostAdapterStatus = EFI_EXT_SCSI_STATUS_HOST_ADAPTER_TIMEOUT;
  470. return EFI_TIMEOUT;
  471. case PvScsiBtStatScsiParity:
  472. Packet->HostAdapterStatus = EFI_EXT_SCSI_STATUS_HOST_ADAPTER_PARITY_ERROR;
  473. break;
  474. default:
  475. Packet->HostAdapterStatus = EFI_EXT_SCSI_STATUS_HOST_ADAPTER_OTHER;
  476. break;
  477. }
  478. return EFI_DEVICE_ERROR;
  479. }
  480. /**
  481. Check if Target argument to EXT_SCSI_PASS_THRU.GetNextTarget() and
  482. EXT_SCSI_PASS_THRU.GetNextTargetLun() is initialized
  483. **/
  484. STATIC
  485. BOOLEAN
  486. IsTargetInitialized (
  487. IN UINT8 *Target
  488. )
  489. {
  490. UINTN Idx;
  491. for (Idx = 0; Idx < TARGET_MAX_BYTES; ++Idx) {
  492. if (Target[Idx] != 0xFF) {
  493. return TRUE;
  494. }
  495. }
  496. return FALSE;
  497. }
  498. //
  499. // Ext SCSI Pass Thru
  500. //
  501. STATIC
  502. EFI_STATUS
  503. EFIAPI
  504. PvScsiPassThru (
  505. IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL *This,
  506. IN UINT8 *Target,
  507. IN UINT64 Lun,
  508. IN OUT EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet,
  509. IN EFI_EVENT Event OPTIONAL
  510. )
  511. {
  512. PVSCSI_DEV *Dev;
  513. EFI_STATUS Status;
  514. PVSCSI_RING_REQ_DESC *Request;
  515. PVSCSI_RING_CMP_DESC *Response;
  516. Dev = PVSCSI_FROM_PASS_THRU (This);
  517. if (PvScsiIsReqRingFull (Dev)) {
  518. return EFI_NOT_READY;
  519. }
  520. Request = PvScsiGetCurrentRequest (Dev);
  521. Status = PopulateRequest (Dev, Target, Lun, Packet, Request);
  522. if (EFI_ERROR (Status)) {
  523. return Status;
  524. }
  525. //
  526. // Writes to Request must be globally visible before making request
  527. // available to device
  528. //
  529. MemoryFence ();
  530. Dev->RingDesc.RingState->ReqProdIdx++;
  531. Status = PvScsiMmioWrite32 (Dev, PvScsiRegOffsetKickRwIo, 0);
  532. if (EFI_ERROR (Status)) {
  533. //
  534. // If kicking the host fails, we must fake a host adapter error.
  535. // EFI_NOT_READY would save us the effort, but it would also suggest that
  536. // the caller retry.
  537. //
  538. return ReportHostAdapterError (Packet);
  539. }
  540. Status = PvScsiWaitForRequestCompletion (Dev);
  541. if (EFI_ERROR (Status)) {
  542. //
  543. // If waiting for request completion fails, we must fake a host adapter
  544. // error. EFI_NOT_READY would save us the effort, but it would also suggest
  545. // that the caller retry.
  546. //
  547. return ReportHostAdapterError (Packet);
  548. }
  549. Response = PvScsiGetCurrentResponse (Dev);
  550. Status = HandleResponse (Dev, Packet, Response);
  551. //
  552. // Reads from response must complete before releasing completion entry
  553. // to device
  554. //
  555. MemoryFence ();
  556. Dev->RingDesc.RingState->CmpConsIdx++;
  557. return Status;
  558. }
  559. STATIC
  560. EFI_STATUS
  561. EFIAPI
  562. PvScsiGetNextTargetLun (
  563. IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL *This,
  564. IN OUT UINT8 **Target,
  565. IN OUT UINT64 *Lun
  566. )
  567. {
  568. UINT8 *TargetPtr;
  569. UINT8 LastTarget;
  570. PVSCSI_DEV *Dev;
  571. if (Target == NULL) {
  572. return EFI_INVALID_PARAMETER;
  573. }
  574. //
  575. // The Target input parameter is unnecessarily a pointer-to-pointer
  576. //
  577. TargetPtr = *Target;
  578. //
  579. // If target not initialized, return first target & LUN
  580. //
  581. if (!IsTargetInitialized (TargetPtr)) {
  582. ZeroMem (TargetPtr, TARGET_MAX_BYTES);
  583. *Lun = 0;
  584. return EFI_SUCCESS;
  585. }
  586. //
  587. // We only use first byte of target identifer
  588. //
  589. LastTarget = *TargetPtr;
  590. //
  591. // Increment (target, LUN) pair if valid on input
  592. //
  593. Dev = PVSCSI_FROM_PASS_THRU (This);
  594. if ((LastTarget > Dev->MaxTarget) || (*Lun > Dev->MaxLun)) {
  595. return EFI_INVALID_PARAMETER;
  596. }
  597. if (*Lun < Dev->MaxLun) {
  598. ++*Lun;
  599. return EFI_SUCCESS;
  600. }
  601. if (LastTarget < Dev->MaxTarget) {
  602. *Lun = 0;
  603. ++LastTarget;
  604. *TargetPtr = LastTarget;
  605. return EFI_SUCCESS;
  606. }
  607. return EFI_NOT_FOUND;
  608. }
  609. STATIC
  610. EFI_STATUS
  611. EFIAPI
  612. PvScsiBuildDevicePath (
  613. IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL *This,
  614. IN UINT8 *Target,
  615. IN UINT64 Lun,
  616. IN OUT EFI_DEVICE_PATH_PROTOCOL **DevicePath
  617. )
  618. {
  619. UINT8 TargetValue;
  620. PVSCSI_DEV *Dev;
  621. SCSI_DEVICE_PATH *ScsiDevicePath;
  622. if (DevicePath == NULL) {
  623. return EFI_INVALID_PARAMETER;
  624. }
  625. //
  626. // We only use first byte of target identifer
  627. //
  628. TargetValue = *Target;
  629. Dev = PVSCSI_FROM_PASS_THRU (This);
  630. if ((TargetValue > Dev->MaxTarget) || (Lun > Dev->MaxLun)) {
  631. return EFI_NOT_FOUND;
  632. }
  633. ScsiDevicePath = AllocatePool (sizeof (*ScsiDevicePath));
  634. if (ScsiDevicePath == NULL) {
  635. return EFI_OUT_OF_RESOURCES;
  636. }
  637. ScsiDevicePath->Header.Type = MESSAGING_DEVICE_PATH;
  638. ScsiDevicePath->Header.SubType = MSG_SCSI_DP;
  639. ScsiDevicePath->Header.Length[0] = (UINT8)sizeof (*ScsiDevicePath);
  640. ScsiDevicePath->Header.Length[1] = (UINT8)(sizeof (*ScsiDevicePath) >> 8);
  641. ScsiDevicePath->Pun = TargetValue;
  642. ScsiDevicePath->Lun = (UINT16)Lun;
  643. *DevicePath = &ScsiDevicePath->Header;
  644. return EFI_SUCCESS;
  645. }
  646. STATIC
  647. EFI_STATUS
  648. EFIAPI
  649. PvScsiGetTargetLun (
  650. IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL *This,
  651. IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
  652. OUT UINT8 **Target,
  653. OUT UINT64 *Lun
  654. )
  655. {
  656. SCSI_DEVICE_PATH *ScsiDevicePath;
  657. PVSCSI_DEV *Dev;
  658. if ((DevicePath == NULL) || (Target == NULL) || (*Target == NULL) || (Lun == NULL)) {
  659. return EFI_INVALID_PARAMETER;
  660. }
  661. if ((DevicePath->Type != MESSAGING_DEVICE_PATH) ||
  662. (DevicePath->SubType != MSG_SCSI_DP))
  663. {
  664. return EFI_UNSUPPORTED;
  665. }
  666. ScsiDevicePath = (SCSI_DEVICE_PATH *)DevicePath;
  667. Dev = PVSCSI_FROM_PASS_THRU (This);
  668. if ((ScsiDevicePath->Pun > Dev->MaxTarget) ||
  669. (ScsiDevicePath->Lun > Dev->MaxLun))
  670. {
  671. return EFI_NOT_FOUND;
  672. }
  673. //
  674. // We only use first byte of target identifer
  675. //
  676. **Target = (UINT8)ScsiDevicePath->Pun;
  677. ZeroMem (*Target + 1, TARGET_MAX_BYTES - 1);
  678. *Lun = ScsiDevicePath->Lun;
  679. return EFI_SUCCESS;
  680. }
  681. STATIC
  682. EFI_STATUS
  683. EFIAPI
  684. PvScsiResetChannel (
  685. IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL *This
  686. )
  687. {
  688. return EFI_UNSUPPORTED;
  689. }
  690. STATIC
  691. EFI_STATUS
  692. EFIAPI
  693. PvScsiResetTargetLun (
  694. IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL *This,
  695. IN UINT8 *Target,
  696. IN UINT64 Lun
  697. )
  698. {
  699. return EFI_UNSUPPORTED;
  700. }
  701. STATIC
  702. EFI_STATUS
  703. EFIAPI
  704. PvScsiGetNextTarget (
  705. IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL *This,
  706. IN OUT UINT8 **Target
  707. )
  708. {
  709. UINT8 *TargetPtr;
  710. UINT8 LastTarget;
  711. PVSCSI_DEV *Dev;
  712. if (Target == NULL) {
  713. return EFI_INVALID_PARAMETER;
  714. }
  715. //
  716. // The Target input parameter is unnecessarily a pointer-to-pointer
  717. //
  718. TargetPtr = *Target;
  719. //
  720. // If target not initialized, return first target
  721. //
  722. if (!IsTargetInitialized (TargetPtr)) {
  723. ZeroMem (TargetPtr, TARGET_MAX_BYTES);
  724. return EFI_SUCCESS;
  725. }
  726. //
  727. // We only use first byte of target identifer
  728. //
  729. LastTarget = *TargetPtr;
  730. //
  731. // Increment target if valid on input
  732. //
  733. Dev = PVSCSI_FROM_PASS_THRU (This);
  734. if (LastTarget > Dev->MaxTarget) {
  735. return EFI_INVALID_PARAMETER;
  736. }
  737. if (LastTarget < Dev->MaxTarget) {
  738. ++LastTarget;
  739. *TargetPtr = LastTarget;
  740. return EFI_SUCCESS;
  741. }
  742. return EFI_NOT_FOUND;
  743. }
  744. STATIC
  745. EFI_STATUS
  746. PvScsiSetPciAttributes (
  747. IN OUT PVSCSI_DEV *Dev
  748. )
  749. {
  750. EFI_STATUS Status;
  751. //
  752. // Backup original PCI Attributes
  753. //
  754. Status = Dev->PciIo->Attributes (
  755. Dev->PciIo,
  756. EfiPciIoAttributeOperationGet,
  757. 0,
  758. &Dev->OriginalPciAttributes
  759. );
  760. if (EFI_ERROR (Status)) {
  761. return Status;
  762. }
  763. //
  764. // Enable MMIO-Space & Bus-Mastering
  765. //
  766. Status = Dev->PciIo->Attributes (
  767. Dev->PciIo,
  768. EfiPciIoAttributeOperationEnable,
  769. (EFI_PCI_IO_ATTRIBUTE_MEMORY |
  770. EFI_PCI_IO_ATTRIBUTE_BUS_MASTER),
  771. NULL
  772. );
  773. if (EFI_ERROR (Status)) {
  774. return Status;
  775. }
  776. //
  777. // Signal device supports 64-bit DMA addresses
  778. //
  779. Status = Dev->PciIo->Attributes (
  780. Dev->PciIo,
  781. EfiPciIoAttributeOperationEnable,
  782. EFI_PCI_IO_ATTRIBUTE_DUAL_ADDRESS_CYCLE,
  783. NULL
  784. );
  785. if (EFI_ERROR (Status)) {
  786. //
  787. // Warn user that device will only be using 32-bit DMA addresses.
  788. //
  789. // Note that this does not prevent the device/driver from working
  790. // and therefore we only warn and continue as usual.
  791. //
  792. DEBUG ((
  793. DEBUG_WARN,
  794. "%a: failed to enable 64-bit DMA addresses\n",
  795. __FUNCTION__
  796. ));
  797. }
  798. return EFI_SUCCESS;
  799. }
  800. STATIC
  801. VOID
  802. PvScsiRestorePciAttributes (
  803. IN PVSCSI_DEV *Dev
  804. )
  805. {
  806. Dev->PciIo->Attributes (
  807. Dev->PciIo,
  808. EfiPciIoAttributeOperationSet,
  809. Dev->OriginalPciAttributes,
  810. NULL
  811. );
  812. }
  813. STATIC
  814. EFI_STATUS
  815. PvScsiAllocateSharedPages (
  816. IN PVSCSI_DEV *Dev,
  817. IN UINTN Pages,
  818. OUT VOID **HostAddress,
  819. OUT PVSCSI_DMA_DESC *DmaDesc
  820. )
  821. {
  822. EFI_STATUS Status;
  823. UINTN NumberOfBytes;
  824. Status = Dev->PciIo->AllocateBuffer (
  825. Dev->PciIo,
  826. AllocateAnyPages,
  827. EfiBootServicesData,
  828. Pages,
  829. HostAddress,
  830. EFI_PCI_ATTRIBUTE_MEMORY_CACHED
  831. );
  832. if (EFI_ERROR (Status)) {
  833. return Status;
  834. }
  835. NumberOfBytes = EFI_PAGES_TO_SIZE (Pages);
  836. Status = Dev->PciIo->Map (
  837. Dev->PciIo,
  838. EfiPciIoOperationBusMasterCommonBuffer,
  839. *HostAddress,
  840. &NumberOfBytes,
  841. &DmaDesc->DeviceAddress,
  842. &DmaDesc->Mapping
  843. );
  844. if (EFI_ERROR (Status)) {
  845. goto FreeBuffer;
  846. }
  847. if (NumberOfBytes != EFI_PAGES_TO_SIZE (Pages)) {
  848. Status = EFI_OUT_OF_RESOURCES;
  849. goto Unmap;
  850. }
  851. return EFI_SUCCESS;
  852. Unmap:
  853. Dev->PciIo->Unmap (Dev->PciIo, DmaDesc->Mapping);
  854. FreeBuffer:
  855. Dev->PciIo->FreeBuffer (Dev->PciIo, Pages, *HostAddress);
  856. return Status;
  857. }
  858. STATIC
  859. VOID
  860. PvScsiFreeSharedPages (
  861. IN PVSCSI_DEV *Dev,
  862. IN UINTN Pages,
  863. IN VOID *HostAddress,
  864. IN PVSCSI_DMA_DESC *DmaDesc
  865. )
  866. {
  867. Dev->PciIo->Unmap (Dev->PciIo, DmaDesc->Mapping);
  868. Dev->PciIo->FreeBuffer (Dev->PciIo, Pages, HostAddress);
  869. }
  870. STATIC
  871. EFI_STATUS
  872. PvScsiInitRings (
  873. IN OUT PVSCSI_DEV *Dev
  874. )
  875. {
  876. EFI_STATUS Status;
  877. Status = PvScsiAllocateSharedPages (
  878. Dev,
  879. 1,
  880. (VOID **)&Dev->RingDesc.RingState,
  881. &Dev->RingDesc.RingStateDmaDesc
  882. );
  883. if (EFI_ERROR (Status)) {
  884. return Status;
  885. }
  886. ZeroMem (Dev->RingDesc.RingState, EFI_PAGE_SIZE);
  887. Status = PvScsiAllocateSharedPages (
  888. Dev,
  889. 1,
  890. (VOID **)&Dev->RingDesc.RingReqs,
  891. &Dev->RingDesc.RingReqsDmaDesc
  892. );
  893. if (EFI_ERROR (Status)) {
  894. goto FreeRingState;
  895. }
  896. ZeroMem (Dev->RingDesc.RingReqs, EFI_PAGE_SIZE);
  897. Status = PvScsiAllocateSharedPages (
  898. Dev,
  899. 1,
  900. (VOID **)&Dev->RingDesc.RingCmps,
  901. &Dev->RingDesc.RingCmpsDmaDesc
  902. );
  903. if (EFI_ERROR (Status)) {
  904. goto FreeRingReqs;
  905. }
  906. ZeroMem (Dev->RingDesc.RingCmps, EFI_PAGE_SIZE);
  907. return EFI_SUCCESS;
  908. FreeRingReqs:
  909. PvScsiFreeSharedPages (
  910. Dev,
  911. 1,
  912. Dev->RingDesc.RingReqs,
  913. &Dev->RingDesc.RingReqsDmaDesc
  914. );
  915. FreeRingState:
  916. PvScsiFreeSharedPages (
  917. Dev,
  918. 1,
  919. Dev->RingDesc.RingState,
  920. &Dev->RingDesc.RingStateDmaDesc
  921. );
  922. return Status;
  923. }
  924. STATIC
  925. VOID
  926. PvScsiFreeRings (
  927. IN OUT PVSCSI_DEV *Dev
  928. )
  929. {
  930. PvScsiFreeSharedPages (
  931. Dev,
  932. 1,
  933. Dev->RingDesc.RingCmps,
  934. &Dev->RingDesc.RingCmpsDmaDesc
  935. );
  936. PvScsiFreeSharedPages (
  937. Dev,
  938. 1,
  939. Dev->RingDesc.RingReqs,
  940. &Dev->RingDesc.RingReqsDmaDesc
  941. );
  942. PvScsiFreeSharedPages (
  943. Dev,
  944. 1,
  945. Dev->RingDesc.RingState,
  946. &Dev->RingDesc.RingStateDmaDesc
  947. );
  948. }
  949. STATIC
  950. EFI_STATUS
  951. PvScsiSetupRings (
  952. IN OUT PVSCSI_DEV *Dev
  953. )
  954. {
  955. union {
  956. PVSCSI_CMD_DESC_SETUP_RINGS Cmd;
  957. UINT32 Uint32;
  958. } AlignedCmd;
  959. PVSCSI_CMD_DESC_SETUP_RINGS *Cmd;
  960. Cmd = &AlignedCmd.Cmd;
  961. ZeroMem (Cmd, sizeof (*Cmd));
  962. Cmd->ReqRingNumPages = 1;
  963. Cmd->CmpRingNumPages = 1;
  964. Cmd->RingsStatePPN = RShiftU64 (
  965. Dev->RingDesc.RingStateDmaDesc.DeviceAddress,
  966. EFI_PAGE_SHIFT
  967. );
  968. Cmd->ReqRingPPNs[0] = RShiftU64 (
  969. Dev->RingDesc.RingReqsDmaDesc.DeviceAddress,
  970. EFI_PAGE_SHIFT
  971. );
  972. Cmd->CmpRingPPNs[0] = RShiftU64 (
  973. Dev->RingDesc.RingCmpsDmaDesc.DeviceAddress,
  974. EFI_PAGE_SHIFT
  975. );
  976. STATIC_ASSERT (
  977. sizeof (*Cmd) % sizeof (UINT32) == 0,
  978. "Cmd must be multiple of 32-bit words"
  979. );
  980. return PvScsiWriteCmdDesc (
  981. Dev,
  982. PvScsiCmdSetupRings,
  983. (UINT32 *)Cmd,
  984. sizeof (*Cmd) / sizeof (UINT32)
  985. );
  986. }
  987. STATIC
  988. EFI_STATUS
  989. PvScsiInit (
  990. IN OUT PVSCSI_DEV *Dev
  991. )
  992. {
  993. EFI_STATUS Status;
  994. //
  995. // Init configuration
  996. //
  997. Dev->MaxTarget = PcdGet8 (PcdPvScsiMaxTargetLimit);
  998. Dev->MaxLun = PcdGet8 (PcdPvScsiMaxLunLimit);
  999. Dev->WaitForCmpStallInUsecs = PcdGet32 (PcdPvScsiWaitForCmpStallInUsecs);
  1000. //
  1001. // Set PCI Attributes
  1002. //
  1003. Status = PvScsiSetPciAttributes (Dev);
  1004. if (EFI_ERROR (Status)) {
  1005. return Status;
  1006. }
  1007. //
  1008. // Reset adapter
  1009. //
  1010. Status = PvScsiResetAdapter (Dev);
  1011. if (EFI_ERROR (Status)) {
  1012. goto RestorePciAttributes;
  1013. }
  1014. //
  1015. // Init PVSCSI rings
  1016. //
  1017. Status = PvScsiInitRings (Dev);
  1018. if (EFI_ERROR (Status)) {
  1019. goto RestorePciAttributes;
  1020. }
  1021. //
  1022. // Allocate DMA communication buffer
  1023. //
  1024. Status = PvScsiAllocateSharedPages (
  1025. Dev,
  1026. EFI_SIZE_TO_PAGES (sizeof (*Dev->DmaBuf)),
  1027. (VOID **)&Dev->DmaBuf,
  1028. &Dev->DmaBufDmaDesc
  1029. );
  1030. if (EFI_ERROR (Status)) {
  1031. goto FreeRings;
  1032. }
  1033. //
  1034. // Setup rings against device
  1035. //
  1036. Status = PvScsiSetupRings (Dev);
  1037. if (EFI_ERROR (Status)) {
  1038. goto FreeDmaCommBuffer;
  1039. }
  1040. //
  1041. // Populate the exported interface's attributes
  1042. //
  1043. Dev->PassThru.Mode = &Dev->PassThruMode;
  1044. Dev->PassThru.PassThru = &PvScsiPassThru;
  1045. Dev->PassThru.GetNextTargetLun = &PvScsiGetNextTargetLun;
  1046. Dev->PassThru.BuildDevicePath = &PvScsiBuildDevicePath;
  1047. Dev->PassThru.GetTargetLun = &PvScsiGetTargetLun;
  1048. Dev->PassThru.ResetChannel = &PvScsiResetChannel;
  1049. Dev->PassThru.ResetTargetLun = &PvScsiResetTargetLun;
  1050. Dev->PassThru.GetNextTarget = &PvScsiGetNextTarget;
  1051. //
  1052. // AdapterId is a target for which no handle will be created during bus scan.
  1053. // Prevent any conflict with real devices.
  1054. //
  1055. Dev->PassThruMode.AdapterId = MAX_UINT32;
  1056. //
  1057. // Set both physical and logical attributes for non-RAID SCSI channel
  1058. //
  1059. Dev->PassThruMode.Attributes = EFI_EXT_SCSI_PASS_THRU_ATTRIBUTES_PHYSICAL |
  1060. EFI_EXT_SCSI_PASS_THRU_ATTRIBUTES_LOGICAL;
  1061. //
  1062. // No restriction on transfer buffer alignment
  1063. //
  1064. Dev->PassThruMode.IoAlign = 0;
  1065. return EFI_SUCCESS;
  1066. FreeDmaCommBuffer:
  1067. PvScsiFreeSharedPages (
  1068. Dev,
  1069. EFI_SIZE_TO_PAGES (sizeof (*Dev->DmaBuf)),
  1070. Dev->DmaBuf,
  1071. &Dev->DmaBufDmaDesc
  1072. );
  1073. FreeRings:
  1074. PvScsiFreeRings (Dev);
  1075. RestorePciAttributes:
  1076. PvScsiRestorePciAttributes (Dev);
  1077. return Status;
  1078. }
  1079. STATIC
  1080. VOID
  1081. PvScsiUninit (
  1082. IN OUT PVSCSI_DEV *Dev
  1083. )
  1084. {
  1085. //
  1086. // Reset device to:
  1087. // - Make device stop processing all requests.
  1088. // - Stop device usage of the rings.
  1089. //
  1090. // This is required to safely free the DMA communication buffer
  1091. // and the rings.
  1092. //
  1093. PvScsiResetAdapter (Dev);
  1094. //
  1095. // Free DMA communication buffer
  1096. //
  1097. PvScsiFreeSharedPages (
  1098. Dev,
  1099. EFI_SIZE_TO_PAGES (sizeof (*Dev->DmaBuf)),
  1100. Dev->DmaBuf,
  1101. &Dev->DmaBufDmaDesc
  1102. );
  1103. PvScsiFreeRings (Dev);
  1104. PvScsiRestorePciAttributes (Dev);
  1105. }
  1106. /**
  1107. Event notification called by ExitBootServices()
  1108. **/
  1109. STATIC
  1110. VOID
  1111. EFIAPI
  1112. PvScsiExitBoot (
  1113. IN EFI_EVENT Event,
  1114. IN VOID *Context
  1115. )
  1116. {
  1117. PVSCSI_DEV *Dev;
  1118. Dev = Context;
  1119. DEBUG ((DEBUG_VERBOSE, "%a: Context=0x%p\n", __FUNCTION__, Context));
  1120. //
  1121. // Reset the device to stop device usage of the rings.
  1122. //
  1123. // We allocated said rings in EfiBootServicesData type memory, and code
  1124. // executing after ExitBootServices() is permitted to overwrite it.
  1125. //
  1126. PvScsiResetAdapter (Dev);
  1127. }
  1128. //
  1129. // Driver Binding
  1130. //
  1131. STATIC
  1132. EFI_STATUS
  1133. EFIAPI
  1134. PvScsiDriverBindingSupported (
  1135. IN EFI_DRIVER_BINDING_PROTOCOL *This,
  1136. IN EFI_HANDLE ControllerHandle,
  1137. IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
  1138. )
  1139. {
  1140. EFI_STATUS Status;
  1141. EFI_PCI_IO_PROTOCOL *PciIo;
  1142. PCI_TYPE00 Pci;
  1143. Status = gBS->OpenProtocol (
  1144. ControllerHandle,
  1145. &gEfiPciIoProtocolGuid,
  1146. (VOID **)&PciIo,
  1147. This->DriverBindingHandle,
  1148. ControllerHandle,
  1149. EFI_OPEN_PROTOCOL_BY_DRIVER
  1150. );
  1151. if (EFI_ERROR (Status)) {
  1152. return Status;
  1153. }
  1154. Status = PciIo->Pci.Read (
  1155. PciIo,
  1156. EfiPciIoWidthUint32,
  1157. 0,
  1158. sizeof (Pci) / sizeof (UINT32),
  1159. &Pci
  1160. );
  1161. if (EFI_ERROR (Status)) {
  1162. goto Done;
  1163. }
  1164. if ((Pci.Hdr.VendorId != PCI_VENDOR_ID_VMWARE) ||
  1165. (Pci.Hdr.DeviceId != PCI_DEVICE_ID_VMWARE_PVSCSI))
  1166. {
  1167. Status = EFI_UNSUPPORTED;
  1168. goto Done;
  1169. }
  1170. Status = EFI_SUCCESS;
  1171. Done:
  1172. gBS->CloseProtocol (
  1173. ControllerHandle,
  1174. &gEfiPciIoProtocolGuid,
  1175. This->DriverBindingHandle,
  1176. ControllerHandle
  1177. );
  1178. return Status;
  1179. }
  1180. STATIC
  1181. EFI_STATUS
  1182. EFIAPI
  1183. PvScsiDriverBindingStart (
  1184. IN EFI_DRIVER_BINDING_PROTOCOL *This,
  1185. IN EFI_HANDLE ControllerHandle,
  1186. IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
  1187. )
  1188. {
  1189. PVSCSI_DEV *Dev;
  1190. EFI_STATUS Status;
  1191. Dev = (PVSCSI_DEV *)AllocateZeroPool (sizeof (*Dev));
  1192. if (Dev == NULL) {
  1193. return EFI_OUT_OF_RESOURCES;
  1194. }
  1195. Status = gBS->OpenProtocol (
  1196. ControllerHandle,
  1197. &gEfiPciIoProtocolGuid,
  1198. (VOID **)&Dev->PciIo,
  1199. This->DriverBindingHandle,
  1200. ControllerHandle,
  1201. EFI_OPEN_PROTOCOL_BY_DRIVER
  1202. );
  1203. if (EFI_ERROR (Status)) {
  1204. goto FreePvScsi;
  1205. }
  1206. Status = PvScsiInit (Dev);
  1207. if (EFI_ERROR (Status)) {
  1208. goto ClosePciIo;
  1209. }
  1210. Status = gBS->CreateEvent (
  1211. EVT_SIGNAL_EXIT_BOOT_SERVICES,
  1212. TPL_CALLBACK,
  1213. &PvScsiExitBoot,
  1214. Dev,
  1215. &Dev->ExitBoot
  1216. );
  1217. if (EFI_ERROR (Status)) {
  1218. goto UninitDev;
  1219. }
  1220. //
  1221. // Setup complete, attempt to export the driver instance's PassThru interface
  1222. //
  1223. Dev->Signature = PVSCSI_SIG;
  1224. Status = gBS->InstallProtocolInterface (
  1225. &ControllerHandle,
  1226. &gEfiExtScsiPassThruProtocolGuid,
  1227. EFI_NATIVE_INTERFACE,
  1228. &Dev->PassThru
  1229. );
  1230. if (EFI_ERROR (Status)) {
  1231. goto CloseExitBoot;
  1232. }
  1233. return EFI_SUCCESS;
  1234. CloseExitBoot:
  1235. gBS->CloseEvent (Dev->ExitBoot);
  1236. UninitDev:
  1237. PvScsiUninit (Dev);
  1238. ClosePciIo:
  1239. gBS->CloseProtocol (
  1240. ControllerHandle,
  1241. &gEfiPciIoProtocolGuid,
  1242. This->DriverBindingHandle,
  1243. ControllerHandle
  1244. );
  1245. FreePvScsi:
  1246. FreePool (Dev);
  1247. return Status;
  1248. }
  1249. STATIC
  1250. EFI_STATUS
  1251. EFIAPI
  1252. PvScsiDriverBindingStop (
  1253. IN EFI_DRIVER_BINDING_PROTOCOL *This,
  1254. IN EFI_HANDLE ControllerHandle,
  1255. IN UINTN NumberOfChildren,
  1256. IN EFI_HANDLE *ChildHandleBuffer
  1257. )
  1258. {
  1259. EFI_STATUS Status;
  1260. EFI_EXT_SCSI_PASS_THRU_PROTOCOL *PassThru;
  1261. PVSCSI_DEV *Dev;
  1262. Status = gBS->OpenProtocol (
  1263. ControllerHandle,
  1264. &gEfiExtScsiPassThruProtocolGuid,
  1265. (VOID **)&PassThru,
  1266. This->DriverBindingHandle,
  1267. ControllerHandle,
  1268. EFI_OPEN_PROTOCOL_GET_PROTOCOL // Lookup only
  1269. );
  1270. if (EFI_ERROR (Status)) {
  1271. return Status;
  1272. }
  1273. Dev = PVSCSI_FROM_PASS_THRU (PassThru);
  1274. Status = gBS->UninstallProtocolInterface (
  1275. ControllerHandle,
  1276. &gEfiExtScsiPassThruProtocolGuid,
  1277. &Dev->PassThru
  1278. );
  1279. if (EFI_ERROR (Status)) {
  1280. return Status;
  1281. }
  1282. gBS->CloseEvent (Dev->ExitBoot);
  1283. PvScsiUninit (Dev);
  1284. gBS->CloseProtocol (
  1285. ControllerHandle,
  1286. &gEfiPciIoProtocolGuid,
  1287. This->DriverBindingHandle,
  1288. ControllerHandle
  1289. );
  1290. FreePool (Dev);
  1291. return EFI_SUCCESS;
  1292. }
  1293. STATIC EFI_DRIVER_BINDING_PROTOCOL mPvScsiDriverBinding = {
  1294. &PvScsiDriverBindingSupported,
  1295. &PvScsiDriverBindingStart,
  1296. &PvScsiDriverBindingStop,
  1297. PVSCSI_BINDING_VERSION,
  1298. NULL, // ImageHandle, filled by EfiLibInstallDriverBindingComponentName2()
  1299. NULL // DriverBindingHandle, filled as well
  1300. };
  1301. //
  1302. // Component Name
  1303. //
  1304. STATIC EFI_UNICODE_STRING_TABLE mDriverNameTable[] = {
  1305. { "eng;en", L"PVSCSI Host Driver" },
  1306. { NULL, NULL }
  1307. };
  1308. STATIC EFI_COMPONENT_NAME_PROTOCOL mComponentName;
  1309. STATIC
  1310. EFI_STATUS
  1311. EFIAPI
  1312. PvScsiGetDriverName (
  1313. IN EFI_COMPONENT_NAME_PROTOCOL *This,
  1314. IN CHAR8 *Language,
  1315. OUT CHAR16 **DriverName
  1316. )
  1317. {
  1318. return LookupUnicodeString2 (
  1319. Language,
  1320. This->SupportedLanguages,
  1321. mDriverNameTable,
  1322. DriverName,
  1323. (BOOLEAN)(This == &mComponentName) // Iso639Language
  1324. );
  1325. }
  1326. STATIC
  1327. EFI_STATUS
  1328. EFIAPI
  1329. PvScsiGetDeviceName (
  1330. IN EFI_COMPONENT_NAME_PROTOCOL *This,
  1331. IN EFI_HANDLE DeviceHandle,
  1332. IN EFI_HANDLE ChildHandle,
  1333. IN CHAR8 *Language,
  1334. OUT CHAR16 **ControllerName
  1335. )
  1336. {
  1337. return EFI_UNSUPPORTED;
  1338. }
  1339. STATIC EFI_COMPONENT_NAME_PROTOCOL mComponentName = {
  1340. &PvScsiGetDriverName,
  1341. &PvScsiGetDeviceName,
  1342. "eng" // SupportedLanguages, ISO 639-2 language codes
  1343. };
  1344. STATIC EFI_COMPONENT_NAME2_PROTOCOL mComponentName2 = {
  1345. (EFI_COMPONENT_NAME2_GET_DRIVER_NAME)&PvScsiGetDriverName,
  1346. (EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME)&PvScsiGetDeviceName,
  1347. "en" // SupportedLanguages, RFC 4646 language codes
  1348. };
  1349. //
  1350. // Entry Point
  1351. //
  1352. EFI_STATUS
  1353. EFIAPI
  1354. PvScsiEntryPoint (
  1355. IN EFI_HANDLE ImageHandle,
  1356. IN EFI_SYSTEM_TABLE *SystemTable
  1357. )
  1358. {
  1359. return EfiLibInstallDriverBindingComponentName2 (
  1360. ImageHandle,
  1361. SystemTable,
  1362. &mPvScsiDriverBinding,
  1363. ImageHandle,
  1364. &mComponentName,
  1365. &mComponentName2
  1366. );
  1367. }