Snp.c@ 80721

Last change on this file since 80721 was 80721, checked in by vboxsync, 5 years ago
Devices/EFI/FirmwareNew: Start upgrade process to edk2-stable201908 (compiles on Windows and works to some extent), bugref:4643
Property svn:eol-style set to `native`
File size: 24.3 KB

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

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: