Snp.c@ 99396

最後變更在這個檔案從99396是 85718,由 vboxsync 提交於 5 年前
Devices/EFI: Merge edk-stable202005 and make it build, bugref:4643
屬性 svn:eol-style 設為 `native`
檔案大小: 24.5 KB

行
1	/** @file
2	Implementation of driver entry point and driver binding protocol.
3
4	Copyright (c) 2004 - 2019, Intel Corporation. All rights reserved.<BR>
5	Copyright (c) Microsoft Corporation.<BR>
6	SPDX-License-Identifier: BSD-2-Clause-Patent
7
8	**/
9
10	#include "Snp.h"
11
12	/**
13	One notified function to stop UNDI device when gBS->ExitBootServices() called.
14
15	@param Event Pointer to this event
16	@param Context Event handler private data
17
18	**/
19	VOID
20	EFIAPI
21	SnpNotifyExitBootServices (
22	EFI_EVENT Event,
23	VOID *Context
24	)
25	{
26	SNP_DRIVER *Snp;
27
28	Snp = (SNP_DRIVER *)Context;
29
30	//
31	// Shutdown and stop UNDI driver
32	//
33	PxeShutdown (Snp);
34	PxeStop (Snp);
35	}
36
37	/**
38	Send command to UNDI. It does nothing currently.
39
40	@param Cdb command to be sent to UNDI.
41
42	@retval EFI_INVALID_PARAMETER The command is 0.
43	@retval EFI_UNSUPPORTED Default return status because it's not
44	supported currently.
45
46	**/
47	EFI_STATUS
48	EFIAPI
49	IssueHwUndiCommand (
50	UINT64 Cdb
51	)
52	{
53	DEBUG ((EFI_D_ERROR, "\nIssueHwUndiCommand() - This should not be called!"));
54
55	if (Cdb == 0) {
56	return EFI_INVALID_PARAMETER;
57
58	}
59	//
60	// %%TBD - For now, nothing is done.
61	//
62	return EFI_UNSUPPORTED;
63	}
64
65
66	/**
67	Compute 8-bit checksum of a buffer.
68
69	@param Buffer Pointer to buffer.
70	@param Length Length of buffer in bytes.
71
72	@return 8-bit checksum of all bytes in buffer, or zero if ptr is NULL or len
73	is zero.
74
75	**/
76	UINT8
77	Calc8BitCksum (
78	VOID *Buffer,
79	UINTN Length
80	)
81	{
82	UINT8 *Ptr;
83	UINT8 Cksum;
84
85	Ptr = Buffer;
86	Cksum = 0;
87
88	if (Ptr == NULL \|\| Length == 0) {
89	return 0;
90	}
91
92	while (Length-- != 0) {
93	Cksum = (UINT8) (Cksum + *Ptr++);
94	}
95
96	return Cksum;
97	}
98
99	/**
100	Test to see if this driver supports ControllerHandle. This service
101	is called by the EFI boot service ConnectController(). In
102	order to make drivers as small as possible, there are a few calling
103	restrictions for this service. ConnectController() must
104	follow these calling restrictions. If any other agent wishes to call
105	Supported() it must also follow these calling restrictions.
106
107	@param This Protocol instance pointer.
108	@param ControllerHandle Handle of device to test.
109	@param RemainingDevicePath Optional parameter use to pick a specific child
110	device to start.
111
112	@retval EFI_SUCCESS This driver supports this device.
113	@retval EFI_ALREADY_STARTED This driver is already running on this device.
114	@retval other This driver does not support this device.
115
116	**/
117	EFI_STATUS
118	EFIAPI
119	SimpleNetworkDriverSupported (
120	IN EFI_DRIVER_BINDING_PROTOCOL *This,
121	IN EFI_HANDLE Controller,
122	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
123	)
124	{
125	EFI_STATUS Status;
126	EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL *NiiProtocol;
127	PXE_UNDI *Pxe;
128
129	Status = gBS->OpenProtocol (
130	Controller,
131	&gEfiDevicePathProtocolGuid,
132	NULL,
133	This->DriverBindingHandle,
134	Controller,
135	EFI_OPEN_PROTOCOL_TEST_PROTOCOL
136	);
137	if (EFI_ERROR (Status)) {
138	return Status;
139	}
140
141	Status = gBS->OpenProtocol (
142	Controller,
143	&gEfiNetworkInterfaceIdentifierProtocolGuid_31,
144	(VOID **) &NiiProtocol,
145	This->DriverBindingHandle,
146	Controller,
147	EFI_OPEN_PROTOCOL_BY_DRIVER
148	);
149
150	if (EFI_ERROR (Status)) {
151	if (Status == EFI_ALREADY_STARTED) {
152	DEBUG ((EFI_D_INFO, "Support(): Already Started. on handle %p\n", Controller));
153	}
154	return Status;
155	}
156
157	DEBUG ((EFI_D_INFO, "Support(): UNDI3.1 found on handle %p\n", Controller));
158
159	//
160	// check the version, we don't want to connect to the undi16
161	//
162	if (NiiProtocol->Type != EfiNetworkInterfaceUndi) {
163	Status = EFI_UNSUPPORTED;
164	goto Done;
165	}
166	//
167	// Check to see if !PXE structure is valid. Paragraph alignment of !PXE structure is required.
168	//
169	if ((NiiProtocol->Id & 0x0F) != 0) {
170	DEBUG ((EFI_D_NET, "\n!PXE structure is not paragraph aligned.\n"));
171	Status = EFI_UNSUPPORTED;
172	goto Done;
173	}
174
175	Pxe = (PXE_UNDI *) (UINTN) (NiiProtocol->Id);
176
177	//
178	// Verify !PXE revisions.
179	//
180	if (Pxe->hw.Signature != PXE_ROMID_SIGNATURE) {
181	DEBUG ((EFI_D_NET, "\n!PXE signature is not valid.\n"));
182	Status = EFI_UNSUPPORTED;
183	goto Done;
184	}
185
186	if (Pxe->hw.Rev < PXE_ROMID_REV) {
187	DEBUG ((EFI_D_NET, "\n!PXE.Rev is not supported.\n"));
188	Status = EFI_UNSUPPORTED;
189	goto Done;
190	}
191
192	if (Pxe->hw.MajorVer < PXE_ROMID_MAJORVER) {
193
194	DEBUG ((EFI_D_NET, "\n!PXE.MajorVer is not supported.\n"));
195	Status = EFI_UNSUPPORTED;
196	goto Done;
197
198	} else if (Pxe->hw.MajorVer == PXE_ROMID_MAJORVER && Pxe->hw.MinorVer < PXE_ROMID_MINORVER) {
199	DEBUG ((EFI_D_NET, "\n!PXE.MinorVer is not supported."));
200	Status = EFI_UNSUPPORTED;
201	goto Done;
202	}
203	//
204	// Do S/W UNDI specific checks.
205	//
206	if ((Pxe->hw.Implementation & PXE_ROMID_IMP_HW_UNDI) == 0) {
207	if (Pxe->sw.EntryPoint < Pxe->sw.Len) {
208	DEBUG ((EFI_D_NET, "\n!PXE S/W entry point is not valid."));
209	Status = EFI_UNSUPPORTED;
210	goto Done;
211	}
212
213	if (Pxe->sw.BusCnt == 0) {
214	DEBUG ((EFI_D_NET, "\n!PXE.BusCnt is zero."));
215	Status = EFI_UNSUPPORTED;
216	goto Done;
217	}
218	}
219
220	Status = EFI_SUCCESS;
221	DEBUG ((EFI_D_INFO, "Support(): supported on %p\n", Controller));
222
223	Done:
224	gBS->CloseProtocol (
225	Controller,
226	&gEfiNetworkInterfaceIdentifierProtocolGuid_31,
227	This->DriverBindingHandle,
228	Controller
229	);
230
231	return Status;
232	}
233
234	/**
235	Start this driver on ControllerHandle. This service is called by the
236	EFI boot service ConnectController(). In order to make
237	drivers as small as possible, there are a few calling restrictions for
238	this service. ConnectController() must follow these
239	calling restrictions. If any other agent wishes to call Start() it
240	must also follow these calling restrictions.
241
242	@param This Protocol instance pointer.
243	@param ControllerHandle Handle of device to bind driver to.
244	@param RemainingDevicePath Optional parameter use to pick a specific child
245	device to start.
246
247	@retval EFI_SUCCESS This driver is added to ControllerHandle
248	@retval EFI_DEVICE_ERROR This driver could not be started due to a device error
249	@retval other This driver does not support this device
250
251	**/
252	EFI_STATUS
253	EFIAPI
254	SimpleNetworkDriverStart (
255	IN EFI_DRIVER_BINDING_PROTOCOL *This,
256	IN EFI_HANDLE Controller,
257	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
258	)
259	{
260	EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL *Nii;
261	EFI_DEVICE_PATH_PROTOCOL *NiiDevicePath;
262	EFI_STATUS Status;
263	PXE_UNDI *Pxe;
264	SNP_DRIVER *Snp;
265	VOID *Address;
266	EFI_HANDLE Handle;
267	UINT8 BarIndex;
268	PXE_STATFLAGS InitStatFlags;
269	EFI_PCI_IO_PROTOCOL *PciIo;
270	EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR *BarDesc;
271	BOOLEAN FoundIoBar;
272	BOOLEAN FoundMemoryBar;
273
274	DEBUG ((EFI_D_NET, "\nSnpNotifyNetworkInterfaceIdentifier() "));
275
276	Status = gBS->OpenProtocol (
277	Controller,
278	&gEfiDevicePathProtocolGuid,
279	(VOID **) &NiiDevicePath,
280	This->DriverBindingHandle,
281	Controller,
282	EFI_OPEN_PROTOCOL_BY_DRIVER
283	);
284
285	if (EFI_ERROR (Status)) {
286	return Status;
287	}
288
289	Status = gBS->LocateDevicePath (
290	&gEfiPciIoProtocolGuid,
291	&NiiDevicePath,
292	&Handle
293	);
294
295	if (EFI_ERROR (Status)) {
296	return Status;
297	}
298
299	Status = gBS->OpenProtocol (
300	Handle,
301	&gEfiPciIoProtocolGuid,
302	(VOID **) &PciIo,
303	This->DriverBindingHandle,
304	Controller,
305	EFI_OPEN_PROTOCOL_GET_PROTOCOL
306	);
307	if (EFI_ERROR (Status)) {
308	return Status;
309	}
310	//
311	// Get the NII interface.
312	//
313	Status = gBS->OpenProtocol (
314	Controller,
315	&gEfiNetworkInterfaceIdentifierProtocolGuid_31,
316	(VOID **) &Nii,
317	This->DriverBindingHandle,
318	Controller,
319	EFI_OPEN_PROTOCOL_BY_DRIVER
320	);
321	if (EFI_ERROR (Status)) {
322	gBS->CloseProtocol (
323	Controller,
324	&gEfiDevicePathProtocolGuid,
325	This->DriverBindingHandle,
326	Controller
327	);
328	return Status;
329	}
330
331	DEBUG ((EFI_D_INFO, "Start(): UNDI3.1 found\n"));
332
333	Pxe = (PXE_UNDI *) (UINTN) (Nii->Id);
334
335	if (Calc8BitCksum (Pxe, Pxe->hw.Len) != 0) {
336	DEBUG ((EFI_D_NET, "\n!PXE checksum is not correct.\n"));
337	goto NiiError;
338	}
339
340	if ((Pxe->hw.Implementation & PXE_ROMID_IMP_PROMISCUOUS_RX_SUPPORTED) != 0) {
341	//
342	// We can get any packets.
343	//
344	} else if ((Pxe->hw.Implementation & PXE_ROMID_IMP_BROADCAST_RX_SUPPORTED) != 0) {
345	//
346	// We need to be able to get broadcast packets for DHCP.
347	// If we do not have promiscuous support, we must at least have
348	// broadcast support or we cannot do DHCP!
349	//
350	} else {
351	DEBUG ((EFI_D_NET, "\nUNDI does not have promiscuous or broadcast support."));
352	goto NiiError;
353	}
354	//
355	// OK, we like this UNDI, and we know snp is not already there on this handle
356	// Allocate and initialize a new simple network protocol structure.
357	//
358	Status = PciIo->AllocateBuffer (
359	PciIo,
360	AllocateAnyPages,
361	EfiBootServicesData,
362	SNP_MEM_PAGES (sizeof (SNP_DRIVER)),
363	&Address,
364	0
365	);
366
367	if (Status != EFI_SUCCESS) {
368	DEBUG ((EFI_D_NET, "\nCould not allocate SNP_DRIVER structure.\n"));
369	goto NiiError;
370	}
371
372	Snp = (SNP_DRIVER *) (UINTN) Address;
373
374	ZeroMem (Snp, sizeof (SNP_DRIVER));
375
376	Snp->PciIo = PciIo;
377	Snp->Signature = SNP_DRIVER_SIGNATURE;
378
379	EfiInitializeLock (&Snp->Lock, TPL_NOTIFY);
380
381	Snp->Snp.Revision = EFI_SIMPLE_NETWORK_PROTOCOL_REVISION;
382	Snp->Snp.Start = SnpUndi32Start;
383	Snp->Snp.Stop = SnpUndi32Stop;
384	Snp->Snp.Initialize = SnpUndi32Initialize;
385	Snp->Snp.Reset = SnpUndi32Reset;
386	Snp->Snp.Shutdown = SnpUndi32Shutdown;
387	Snp->Snp.ReceiveFilters = SnpUndi32ReceiveFilters;
388	Snp->Snp.StationAddress = SnpUndi32StationAddress;
389	Snp->Snp.Statistics = SnpUndi32Statistics;
390	Snp->Snp.MCastIpToMac = SnpUndi32McastIpToMac;
391	Snp->Snp.NvData = SnpUndi32NvData;
392	Snp->Snp.GetStatus = SnpUndi32GetStatus;
393	Snp->Snp.Transmit = SnpUndi32Transmit;
394	Snp->Snp.Receive = SnpUndi32Receive;
395	Snp->Snp.WaitForPacket = NULL;
396
397	Snp->Snp.Mode = &Snp->Mode;
398
399	Snp->TxRxBufferSize = 0;
400	Snp->TxRxBuffer = NULL;
401
402	Snp->RecycledTxBuf = AllocatePool (sizeof (UINT64) * SNP_TX_BUFFER_INCREASEMENT);
403	if (Snp->RecycledTxBuf == NULL) {
404	Status = EFI_OUT_OF_RESOURCES;
405	goto Error_DeleteSNP;
406	}
407	Snp->MaxRecycledTxBuf = SNP_TX_BUFFER_INCREASEMENT;
408	Snp->RecycledTxBufCount = 0;
409
410	if (Nii->Revision >= EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL_REVISION) {
411	Snp->IfNum = Nii->IfNum;
412
413	} else {
414	Snp->IfNum = (UINT8) (Nii->IfNum & 0xFF);
415	}
416
417	if ((Pxe->hw.Implementation & PXE_ROMID_IMP_HW_UNDI) != 0) {
418	Snp->IsSwUndi = FALSE;
419	Snp->IssueUndi32Command = &IssueHwUndiCommand;
420	} else {
421	Snp->IsSwUndi = TRUE;
422
423	if ((Pxe->sw.Implementation & PXE_ROMID_IMP_SW_VIRT_ADDR) != 0) {
424	Snp->IssueUndi32Command = (ISSUE_UNDI32_COMMAND) (UINTN) Pxe->sw.EntryPoint;
425	} else {
426	Snp->IssueUndi32Command = (ISSUE_UNDI32_COMMAND) (UINTN) ((UINT8) (UINTN) Pxe + Pxe->sw.EntryPoint);
427	}
428	}
429	//
430	// Allocate a global CPB and DB buffer for this UNDI interface.
431	// we do this because:
432	//
433	// -UNDI 3.0 wants all the addresses passed to it (even the cpb and db) to be
434	// within 2GB limit, create them here and map them so that when undi calls
435	// v2p callback to check if the physical address is < 2gb, we will pass.
436	//
437	// -This is not a requirement for 3.1 or later UNDIs but the code looks
438	// simpler if we use the same cpb, db variables for both old and new undi
439	// interfaces from all the SNP interface calls (we don't map the buffers
440	// for the newer undi interfaces though)
441	// .
442	// -it is OK to allocate one global set of CPB, DB pair for each UNDI
443	// interface as EFI does not multi-task and so SNP will not be re-entered!
444	//
445	Status = PciIo->AllocateBuffer (
446	PciIo,
447	AllocateAnyPages,
448	EfiBootServicesData,
449	SNP_MEM_PAGES (4096),
450	&Address,
451	0
452	);
453
454	if (Status != EFI_SUCCESS) {
455	DEBUG ((EFI_D_NET, "\nCould not allocate CPB and DB structures.\n"));
456	goto Error_DeleteSNP;
457	}
458
459	Snp->Cpb = (VOID *) (UINTN) Address;
460	Snp->Db = (VOID *) ((UINTN) Address + 2048);
461
462	//
463	// Find the correct BAR to do IO.
464	//
465	// Enumerate through the PCI BARs for the device to determine which one is
466	// the IO BAR. Save the index of the BAR into the adapter info structure.
467	// for regular 32bit BARs, 0 is memory mapped, 1 is io mapped
468	//
469	Snp->MemoryBarIndex = PCI_MAX_BAR;
470	Snp->IoBarIndex = PCI_MAX_BAR;
471	FoundMemoryBar = FALSE;
472	FoundIoBar = FALSE;
473	for (BarIndex = 0; BarIndex < PCI_MAX_BAR; BarIndex++) {
474	Status = PciIo->GetBarAttributes (
475	PciIo,
476	BarIndex,
477	NULL,
478	(VOID**) &BarDesc
479	);
480	if (Status == EFI_UNSUPPORTED) {
481	continue;
482	} else if (EFI_ERROR (Status)) {
483	goto Error_DeleteSNP;
484	}
485
486	if ((!FoundMemoryBar) && (BarDesc->ResType == ACPI_ADDRESS_SPACE_TYPE_MEM)) {
487	Snp->MemoryBarIndex = BarIndex;
488	FoundMemoryBar = TRUE;
489	} else if ((!FoundIoBar) && (BarDesc->ResType == ACPI_ADDRESS_SPACE_TYPE_IO)) {
490	Snp->IoBarIndex = BarIndex;
491	FoundIoBar = TRUE;
492	}
493
494	FreePool (BarDesc);
495
496	if (FoundMemoryBar && FoundIoBar) {
497	break;
498	}
499	}
500
501	Status = PxeStart (Snp);
502
503	if (Status != EFI_SUCCESS) {
504	goto Error_DeleteSNP;
505	}
506
507	Snp->Cdb.OpCode = PXE_OPCODE_GET_INIT_INFO;
508	Snp->Cdb.OpFlags = PXE_OPFLAGS_NOT_USED;
509
510	Snp->Cdb.CPBsize = PXE_CPBSIZE_NOT_USED;
511	Snp->Cdb.CPBaddr = PXE_DBADDR_NOT_USED;
512
513	Snp->Cdb.DBsize = (UINT16) sizeof (Snp->InitInfo);
514	Snp->Cdb.DBaddr = (UINT64)(UINTN) (&Snp->InitInfo);
515
516	Snp->Cdb.StatCode = PXE_STATCODE_INITIALIZE;
517	Snp->Cdb.StatFlags = PXE_STATFLAGS_INITIALIZE;
518
519	Snp->Cdb.IFnum = Snp->IfNum;
520	Snp->Cdb.Control = PXE_CONTROL_LAST_CDB_IN_LIST;
521
522	DEBUG ((EFI_D_NET, "\nSnp->undi.get_init_info() "));
523
524	(*Snp->IssueUndi32Command) ((UINT64)(UINTN) &Snp->Cdb);
525
526	//
527	// Save the INIT Stat Code...
528	//
529	InitStatFlags = Snp->Cdb.StatFlags;
530
531	if (Snp->Cdb.StatCode != PXE_STATCODE_SUCCESS) {
532	DEBUG ((EFI_D_NET, "\nSnp->undi.init_info() %xh:%xh\n", Snp->Cdb.StatFlags, Snp->Cdb.StatCode));
533	PxeStop (Snp);
534	goto Error_DeleteSNP;
535	}
536
537	//
538	// Initialize simple network protocol mode structure
539	//
540	Snp->Mode.State = EfiSimpleNetworkStopped;
541	Snp->Mode.HwAddressSize = Snp->InitInfo.HWaddrLen;
542	Snp->Mode.MediaHeaderSize = Snp->InitInfo.MediaHeaderLen;
543	Snp->Mode.MaxPacketSize = Snp->InitInfo.FrameDataLen;
544	Snp->Mode.NvRamAccessSize = Snp->InitInfo.NvWidth;
545	Snp->Mode.NvRamSize = Snp->InitInfo.NvCount * Snp->Mode.NvRamAccessSize;
546	Snp->Mode.IfType = Snp->InitInfo.IFtype;
547	Snp->Mode.MaxMCastFilterCount = Snp->InitInfo.MCastFilterCnt;
548	Snp->Mode.MCastFilterCount = 0;
549
550	switch (InitStatFlags & PXE_STATFLAGS_CABLE_DETECT_MASK) {
551	case PXE_STATFLAGS_CABLE_DETECT_SUPPORTED:
552	Snp->CableDetectSupported = TRUE;
553	break;
554
555	case PXE_STATFLAGS_CABLE_DETECT_NOT_SUPPORTED:
556	default:
557	Snp->CableDetectSupported = FALSE;
558	}
559
560	switch (InitStatFlags & PXE_STATFLAGS_GET_STATUS_NO_MEDIA_MASK) {
561	case PXE_STATFLAGS_GET_STATUS_NO_MEDIA_SUPPORTED:
562	Snp->MediaStatusSupported = TRUE;
563	break;
564
565	case PXE_STATFLAGS_GET_STATUS_NO_MEDIA_NOT_SUPPORTED:
566	default:
567	Snp->MediaStatusSupported = FALSE;
568	}
569
570	if (Snp->CableDetectSupported \|\| Snp->MediaStatusSupported) {
571	Snp->Mode.MediaPresentSupported = TRUE;
572	}
573
574	if ((Pxe->hw.Implementation & PXE_ROMID_IMP_STATION_ADDR_SETTABLE) != 0) {
575	Snp->Mode.MacAddressChangeable = TRUE;
576	} else {
577	Snp->Mode.MacAddressChangeable = FALSE;
578	}
579
580	if ((Pxe->hw.Implementation & PXE_ROMID_IMP_MULTI_FRAME_SUPPORTED) != 0) {
581	Snp->Mode.MultipleTxSupported = TRUE;
582	} else {
583	Snp->Mode.MultipleTxSupported = FALSE;
584	}
585
586	Snp->Mode.ReceiveFilterMask = EFI_SIMPLE_NETWORK_RECEIVE_UNICAST;
587
588	if ((Pxe->hw.Implementation & PXE_ROMID_IMP_PROMISCUOUS_MULTICAST_RX_SUPPORTED) != 0) {
589	Snp->Mode.ReceiveFilterMask \|= EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST;
590
591	}
592
593	if ((Pxe->hw.Implementation & PXE_ROMID_IMP_PROMISCUOUS_RX_SUPPORTED) != 0) {
594	Snp->Mode.ReceiveFilterMask \|= EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS;
595
596	}
597
598	if ((Pxe->hw.Implementation & PXE_ROMID_IMP_BROADCAST_RX_SUPPORTED) != 0) {
599	Snp->Mode.ReceiveFilterMask \|= EFI_SIMPLE_NETWORK_RECEIVE_BROADCAST;
600
601	}
602
603	if ((Pxe->hw.Implementation & PXE_ROMID_IMP_FILTERED_MULTICAST_RX_SUPPORTED) != 0) {
604	Snp->Mode.ReceiveFilterMask \|= EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST;
605
606	}
607
608	if ((Pxe->hw.Implementation & PXE_ROMID_IMP_PROMISCUOUS_MULTICAST_RX_SUPPORTED) != 0) {
609	Snp->Mode.ReceiveFilterMask \|= EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST;
610
611	}
612
613	Snp->Mode.ReceiveFilterSetting = 0;
614
615	//
616	// need to get the station address to save in the mode structure. we need to
617	// initialize the UNDI first for this.
618	//
619	Snp->TxRxBufferSize = Snp->InitInfo.MemoryRequired;
620	Status = PxeInit (Snp, PXE_OPFLAGS_INITIALIZE_DO_NOT_DETECT_CABLE);
621
622	if (EFI_ERROR (Status)) {
623	PxeStop (Snp);
624	goto Error_DeleteSNP;
625	}
626
627	Status = PxeGetStnAddr (Snp);
628
629	if (Status != EFI_SUCCESS) {
630	DEBUG ((EFI_D_ERROR, "\nSnp->undi.get_station_addr() failed.\n"));
631	PxeShutdown (Snp);
632	PxeStop (Snp);
633	goto Error_DeleteSNP;
634	}
635
636	Snp->Mode.MediaPresent = FALSE;
637
638	//
639	// We should not leave UNDI started and initialized here. this DriverStart()
640	// routine must only find and attach the SNP interface to UNDI layer that it
641	// finds on the given handle!
642	// The UNDI layer will be started when upper layers call Snp->start.
643	// How ever, this DriverStart() must fill up the snp mode structure which
644	// contains the MAC address of the NIC. For this reason we started and
645	// initialized UNDI here, now we are done, do a shutdown and stop of the
646	// UNDI interface!
647	//
648	PxeShutdown (Snp);
649	PxeStop (Snp);
650
651	if (PcdGetBool (PcdSnpCreateExitBootServicesEvent)) {
652	//
653	// Create EXIT_BOOT_SERIVES Event
654	//
655	Status = gBS->CreateEventEx (
656	EVT_NOTIFY_SIGNAL,
657	TPL_CALLBACK,
658	SnpNotifyExitBootServices,
659	Snp,
660	&gEfiEventExitBootServicesGuid,
661	&Snp->ExitBootServicesEvent
662	);
663	if (EFI_ERROR (Status)) {
664	goto Error_DeleteSNP;
665	}
666	}
667
668	//
669	// add SNP to the undi handle
670	//
671	Status = gBS->InstallProtocolInterface (
672	&Controller,
673	&gEfiSimpleNetworkProtocolGuid,
674	EFI_NATIVE_INTERFACE,
675	&(Snp->Snp)
676	);
677
678	if (!EFI_ERROR (Status)) {
679	return Status;
680	}
681
682	PciIo->FreeBuffer (
683	PciIo,
684	SNP_MEM_PAGES (4096),
685	Snp->Cpb
686	);
687
688	Error_DeleteSNP:
689
690	if (Snp->RecycledTxBuf != NULL) {
691	FreePool (Snp->RecycledTxBuf);
692	}
693
694	PciIo->FreeBuffer (
695	PciIo,
696	SNP_MEM_PAGES (sizeof (SNP_DRIVER)),
697	Snp
698	);
699	NiiError:
700	gBS->CloseProtocol (
701	Controller,
702	&gEfiNetworkInterfaceIdentifierProtocolGuid_31,
703	This->DriverBindingHandle,
704	Controller
705	);
706
707	gBS->CloseProtocol (
708	Controller,
709	&gEfiDevicePathProtocolGuid,
710	This->DriverBindingHandle,
711	Controller
712	);
713
714	//
715	// If we got here that means we are in error state.
716	//
717	if (!EFI_ERROR (Status)) {
718	Status = EFI_DEVICE_ERROR;
719	}
720
721	return Status;
722	}
723
724	/**
725	Stop this driver on ControllerHandle. This service is called by the
726	EFI boot service DisconnectController(). In order to
727	make drivers as small as possible, there are a few calling
728	restrictions for this service. DisconnectController()
729	must follow these calling restrictions. If any other agent wishes
730	to call Stop() it must also follow these calling restrictions.
731
732	@param This Protocol instance pointer.
733	@param ControllerHandle Handle of device to stop driver on
734	@param NumberOfChildren Number of Handles in ChildHandleBuffer. If number of
735	children is zero stop the entire bus driver.
736	@param ChildHandleBuffer List of Child Handles to Stop.
737
738	@retval EFI_SUCCESS This driver is removed ControllerHandle
739	@retval other This driver was not removed from this device
740
741	**/
742	EFI_STATUS
743	EFIAPI
744	SimpleNetworkDriverStop (
745	IN EFI_DRIVER_BINDING_PROTOCOL *This,
746	IN EFI_HANDLE Controller,
747	IN UINTN NumberOfChildren,
748	IN EFI_HANDLE *ChildHandleBuffer
749	)
750	{
751	EFI_STATUS Status;
752	EFI_SIMPLE_NETWORK_PROTOCOL *SnpProtocol;
753	SNP_DRIVER *Snp;
754	EFI_PCI_IO_PROTOCOL *PciIo;
755
756	//
757	// Get our context back.
758	//
759	Status = gBS->OpenProtocol (
760	Controller,
761	&gEfiSimpleNetworkProtocolGuid,
762	(VOID **) &SnpProtocol,
763	This->DriverBindingHandle,
764	Controller,
765	EFI_OPEN_PROTOCOL_GET_PROTOCOL
766	);
767
768	if (EFI_ERROR (Status)) {
769	return EFI_UNSUPPORTED;
770	}
771
772	Snp = EFI_SIMPLE_NETWORK_DEV_FROM_THIS (SnpProtocol);
773
774	Status = gBS->UninstallProtocolInterface (
775	Controller,
776	&gEfiSimpleNetworkProtocolGuid,
777	&Snp->Snp
778	);
779
780	if (EFI_ERROR (Status)) {
781	return Status;
782	}
783
784	if (PcdGetBool (PcdSnpCreateExitBootServicesEvent)) {
785	//
786	// Close EXIT_BOOT_SERVICES Event
787	//
788	gBS->CloseEvent (Snp->ExitBootServicesEvent);
789	}
790
791	Status = gBS->CloseProtocol (
792	Controller,
793	&gEfiNetworkInterfaceIdentifierProtocolGuid_31,
794	This->DriverBindingHandle,
795	Controller
796	);
797
798	Status = gBS->CloseProtocol (
799	Controller,
800	&gEfiDevicePathProtocolGuid,
801	This->DriverBindingHandle,
802	Controller
803	);
804
805	PxeShutdown (Snp);
806	PxeStop (Snp);
807
808	FreePool (Snp->RecycledTxBuf);
809
810	PciIo = Snp->PciIo;
811	PciIo->FreeBuffer (
812	PciIo,
813	SNP_MEM_PAGES (4096),
814	Snp->Cpb
815	);
816
817	PciIo->FreeBuffer (
818	PciIo,
819	SNP_MEM_PAGES (sizeof (SNP_DRIVER)),
820	Snp
821	);
822
823	return Status;
824	}
825
826	//
827	// Simple Network Protocol Driver Global Variables
828	//
829	EFI_DRIVER_BINDING_PROTOCOL gSimpleNetworkDriverBinding = {
830	SimpleNetworkDriverSupported,
831	SimpleNetworkDriverStart,
832	SimpleNetworkDriverStop,
833	0xa,
834	NULL,
835	NULL
836	};
837
838	/**
839	The SNP driver entry point.
840
841	@param ImageHandle The driver image handle.
842	@param SystemTable The system table.
843
844	@retval EFI_SUCCESS Initialization routine has found UNDI hardware,
845	loaded it's ROM, and installed a notify event for
846	the Network Identifier Interface Protocol
847	successfully.
848	@retval Other Return value from HandleProtocol for
849	DeviceIoProtocol or LoadedImageProtocol
850
851	**/
852	EFI_STATUS
853	EFIAPI
854	InitializeSnpNiiDriver (
855	IN EFI_HANDLE ImageHandle,
856	IN EFI_SYSTEM_TABLE *SystemTable
857	)
858	{
859	return EfiLibInstallDriverBindingComponentName2 (
860	ImageHandle,
861	SystemTable,
862	&gSimpleNetworkDriverBinding,
863	ImageHandle,
864	&gSimpleNetworkComponentName,
865	&gSimpleNetworkComponentName2
866	);
867	}

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/NetworkPkg/SnpDxe/Snp.c@ 99396

以其他格式下載: