[mirror_edk2.git] / MdeModulePkg / Universal / Network / SnpDxe / receive.c

/** @file\r
Copyright (c) 2004 - 2007, Intel Corporation\r
All rights reserved. This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution.  The full text of the license may be found at\r
http://opensource.org/licenses/bsd-license.php\r
\r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
Module name:\r
    receive.c\r
\r
Abstract:\r
\r
Revision history:\r
    2000-Feb-03 M(f)J   Genesis.\r
\r
**/\r
\r
\r
#include "Snp.h"\r
\r
/**\r
  this routine calls undi to receive a packet and fills in the data in the\r
  input pointers!\r
\r
  @param  snp                 pointer to snp driver structure\r
  @param  BufferPtr           pointer to the memory for the received data\r
  @param  BuffSizePtr         is a pointer to the length of the buffer on entry and\r
                              contains the length of the received data on return\r
  @param  HeaderSizePtr       pointer to the header portion of the data received.\r
  @param  SourceAddrPtr       optional parameter, is a pointer to contain the\r
                              source ethernet address on return\r
  @param  DestinationAddrPtr  optional parameter, is a pointer to contain the\r
                              destination ethernet address on return\r
  @param  ProtocolPtr         optional parameter, is a pointer to contain the\r
                              protocol type from the ethernet header on return\r
\r
\r
**/\r
STATIC\r
EFI_STATUS\r
pxe_receive (\r
  SNP_DRIVER      *snp,\r
  VOID            *BufferPtr,\r
  UINTN           *BuffSizePtr,\r
  UINTN           *HeaderSizePtr,\r
  EFI_MAC_ADDRESS *SourceAddrPtr,\r
  EFI_MAC_ADDRESS *DestinationAddrPtr,\r
  UINT16          *ProtocolPtr\r
  )\r
{\r
  PXE_CPB_RECEIVE *cpb;\r
  PXE_DB_RECEIVE  *db;\r
  UINTN           buf_size;\r
  UINT64          TempData;\r
\r
  cpb       = snp->cpb;\r
  db        = snp->db;\r
  buf_size  = *BuffSizePtr;\r
  //\r
  // IMPORTANT NOTE:\r
  // In case of the older 3.0 UNDI, if the input buffer address is beyond 4GB,\r
  // DO NOT call the map function on the given buffer, instead use\r
  // a global buffer. The reason is that UNDI3.0 has some unnecessary check of\r
  // making sure that all the addresses (whether or not they will be given\r
  // to the NIC ) supplied to it are below 4GB. It may or may not use\r
  // the mapped address after all (like in case of CPB and DB)!\r
  // Instead of using the global buffer whose address is allocated within the\r
  // 2GB limit if I start mapping the given buffer we lose the data, here is\r
  // why!!!\r
  // if our address is > 4GB, the map call creates another buffer below 2GB and\r
  // copies data to/from the original buffer to the mapped buffer either at\r
  // map time or unmap time depending on the map direction.\r
  // UNDI will not complain since we already mapped the buffer to be\r
  // within the 2GB limit but will not use (I know undi) the mapped address\r
  // since it does not give the user buffers to the NIC's receive unit,\r
  // It just copies the received packet into the user buffer using the virtual\r
  // (CPU) address rather than the mapped (device or physical) address.\r
  // When the UNDI call returns, if we then unmap the buffer, we will lose\r
  // the contents because unmap copies the contents of the mapped buffer into\r
  // the original buffer (since the direction is FROM_DEVICE) !!!\r
  //\r
  // this is not a problem in Undi 3.1 because this undi uses it's map callback\r
  // routine to map a cpu address to device address and it does it only if\r
  // it is giving the address to the device and unmaps it before using the cpu\r
  // address!\r
  //\r
  TempData = (UINT64) (UINTN) BufferPtr;\r
  if (snp->IsOldUndi && (TempData >= FOUR_GIGABYTES)) {\r
    cpb->BufferAddr = (UINT64)(UINTN) snp->receive_buf;\r
    cpb->BufferLen  = (UINT32) (snp->init_info.MediaHeaderLen + snp->init_info.FrameDataLen);\r
  } else {\r
    cpb->BufferAddr = (UINT64)(UINTN) BufferPtr;\r
    cpb->BufferLen  = (UINT32) *BuffSizePtr;\r
  }\r
\r
  cpb->reserved       = 0;\r
\r
  snp->cdb.OpCode     = PXE_OPCODE_RECEIVE;\r
  snp->cdb.OpFlags    = PXE_OPFLAGS_NOT_USED;\r
\r
  snp->cdb.CPBsize    = sizeof (PXE_CPB_RECEIVE);\r
  snp->cdb.CPBaddr    = (UINT64)(UINTN) cpb;\r
\r
  snp->cdb.DBsize     = sizeof (PXE_DB_RECEIVE);\r
  snp->cdb.DBaddr     = (UINT64)(UINTN) db;\r
\r
  snp->cdb.StatCode   = PXE_STATCODE_INITIALIZE;\r
  snp->cdb.StatFlags  = PXE_STATFLAGS_INITIALIZE;\r
  snp->cdb.IFnum      = snp->if_num;\r
  snp->cdb.Control    = PXE_CONTROL_LAST_CDB_IN_LIST;\r
\r
  //\r
  // Issue UNDI command and check result.\r
  //\r
  DEBUG ((EFI_D_NET, "\nsnp->undi.receive ()  "));\r
\r
  (*snp->issue_undi32_command) ((UINT64)(UINTN) &snp->cdb);\r
\r
  switch (snp->cdb.StatCode) {\r
  case PXE_STATCODE_SUCCESS:\r
    break;\r
\r
  case PXE_STATCODE_NO_DATA:\r
    DEBUG (\r
      (EFI_D_NET,\r
      "\nsnp->undi.receive ()  %xh:%xh\n",\r
      snp->cdb.StatFlags,\r
      snp->cdb.StatCode)\r
      );\r
\r
    return EFI_NOT_READY;\r
\r
  default:\r
    DEBUG (\r
      (EFI_D_ERROR,\r
      "\nsnp->undi.receive()  %xh:%xh\n",\r
      snp->cdb.StatFlags,\r
      snp->cdb.StatCode)\r
      );\r
\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  *BuffSizePtr = db->FrameLen;\r
\r
  if (HeaderSizePtr != NULL) {\r
    *HeaderSizePtr = db->MediaHeaderLen;\r
  }\r
\r
  if (SourceAddrPtr != NULL) {\r
    CopyMem (SourceAddrPtr, &db->SrcAddr, snp->mode.HwAddressSize);\r
  }\r
\r
  if (DestinationAddrPtr != NULL) {\r
    CopyMem (DestinationAddrPtr, &db->DestAddr, snp->mode.HwAddressSize);\r
  }\r
\r
  if (ProtocolPtr != NULL) {\r
    *ProtocolPtr = (UINT16) PXE_SWAP_UINT16 (db->Protocol); /*  we need to do the byte swapping */\r
  }\r
\r
  TempData = (UINT64) (UINTN) BufferPtr;\r
  if (snp->IsOldUndi && (TempData >= FOUR_GIGABYTES)) {\r
    CopyMem (BufferPtr, snp->receive_buf, snp->init_info.MediaHeaderLen + snp->init_info.FrameDataLen);\r
  }\r
\r
  return (*BuffSizePtr <= buf_size) ? EFI_SUCCESS : EFI_BUFFER_TOO_SMALL;\r
}\r
\r
\r
/**\r
  This is the SNP interface routine for receiving network data.\r
  This routine basically retrieves snp structure, checks the SNP state and\r
  calls the pxe_receive routine to actually do the receive!\r
\r
  @param  this                context pointer\r
  @param  HeaderSizePtr       optional parameter and is a pointer to the header\r
                              portion of the data received.\r
  @param  BuffSizePtr         is a pointer to the length of the buffer on entry and\r
                              contains the length of the received data on return\r
  @param  BufferPtr           pointer to the memory for the received data\r
  @param  SourceAddrPtr       optional parameter, is a pointer to contain the\r
                              source ethernet address on return\r
  @param  DestinationAddrPtr  optional parameter, is a pointer to contain the\r
                              destination ethernet address on return\r
  @param  ProtocolPtr         optional parameter, is a pointer to contain the\r
                              protocol type from the ethernet header on return\r
\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
snp_undi32_receive (\r
  IN EFI_SIMPLE_NETWORK_PROTOCOL * this,\r
  OUT UINTN                      *HeaderSizePtr OPTIONAL,\r
  IN OUT UINTN                   *BuffSizePtr,\r
  OUT VOID                       *BufferPtr,\r
  OUT EFI_MAC_ADDRESS            * SourceAddrPtr OPTIONAL,\r
  OUT EFI_MAC_ADDRESS            * DestinationAddrPtr OPTIONAL,\r
  OUT UINT16                     *ProtocolPtr OPTIONAL\r
  )\r
{\r
  SNP_DRIVER  *snp;\r
  EFI_TPL     OldTpl;\r
  EFI_STATUS  Status;\r
\r
  if (this == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  snp = EFI_SIMPLE_NETWORK_DEV_FROM_THIS (this);\r
\r
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
\r
  switch (snp->mode.State) {\r
  case EfiSimpleNetworkInitialized:\r
    break;\r
\r
  case EfiSimpleNetworkStopped:\r
    Status = EFI_NOT_STARTED;\r
    goto ON_EXIT;\r
\r
  default:\r
    Status = EFI_DEVICE_ERROR;\r
    goto ON_EXIT;\r
  }\r
\r
  if ((BuffSizePtr == NULL) || (BufferPtr == NULL)) {\r
    Status = EFI_INVALID_PARAMETER;\r
    goto ON_EXIT;\r
  }\r
\r
  if (!snp->mode.ReceiveFilterSetting) {\r
    Status = EFI_DEVICE_ERROR;\r
    goto ON_EXIT;\r
  }\r
\r
  Status = pxe_receive (\r
             snp,\r
             BufferPtr,\r
             BuffSizePtr,\r
             HeaderSizePtr,\r
             SourceAddrPtr,\r
             DestinationAddrPtr,\r
             ProtocolPtr\r
             );\r
\r
ON_EXIT:\r
  gBS->RestoreTPL (OldTpl);\r
\r
  return Status;\r
}\r
Commit	Line	Data
8a67d61d	1	/** @file\r
	2	Copyright (c) 2004 - 2007, Intel Corporation\r
	3	All rights reserved. This program and the accompanying materials\r
	4	are licensed and made available under the terms and conditions of the BSD License\r
	5	which accompanies this distribution. The full text of the license may be found at\r
	6	http://opensource.org/licenses/bsd-license.php\r
	7	\r
	8	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
	9	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
	10	\r
	11	Module name:\r
	12	receive.c\r
	13	\r
	14	Abstract:\r
	15	\r
	16	Revision history:\r
	17	2000-Feb-03 M(f)J Genesis.\r
	18	\r
	19	**/\r
	20	\r
	21	\r
	22	#include "Snp.h"\r
	23	\r
	24	/**\r
	25	this routine calls undi to receive a packet and fills in the data in the\r
	26	input pointers!\r
	27	\r
	28	@param snp pointer to snp driver structure\r
	29	@param BufferPtr pointer to the memory for the received data\r
	30	@param BuffSizePtr is a pointer to the length of the buffer on entry and\r
	31	contains the length of the received data on return\r
	32	@param HeaderSizePtr pointer to the header portion of the data received.\r
	33	@param SourceAddrPtr optional parameter, is a pointer to contain the\r
	34	source ethernet address on return\r
	35	@param DestinationAddrPtr optional parameter, is a pointer to contain the\r
	36	destination ethernet address on return\r
	37	@param ProtocolPtr optional parameter, is a pointer to contain the\r
	38	protocol type from the ethernet header on return\r
	39	\r
	40	\r
	41	**/\r
	42	STATIC\r
	43	EFI_STATUS\r
	44	pxe_receive (\r
	45	SNP_DRIVER *snp,\r
	46	VOID *BufferPtr,\r
	47	UINTN *BuffSizePtr,\r
	48	UINTN *HeaderSizePtr,\r
	49	EFI_MAC_ADDRESS *SourceAddrPtr,\r
	50	EFI_MAC_ADDRESS *DestinationAddrPtr,\r
	51	UINT16 *ProtocolPtr\r
	52	)\r
	53	{\r
	54	PXE_CPB_RECEIVE *cpb;\r
	55	PXE_DB_RECEIVE *db;\r
	56	UINTN buf_size;\r
	57	UINT64 TempData;\r
	58	\r
	59	cpb = snp->cpb;\r
	60	db = snp->db;\r
	61	buf_size = *BuffSizePtr;\r
	62	//\r
	63	// IMPORTANT NOTE:\r
	64	// In case of the older 3.0 UNDI, if the input buffer address is beyond 4GB,\r
65	// DO NOT call the map function on the given buffer, instead use\r
66	// a global buffer. The reason is that UNDI3.0 has some unnecessary check of\r
67	// making sure that all the addresses (whether or not they will be given\r
68	// to the NIC ) supplied to it are below 4GB. It may or may not use\r
69	// the mapped address after all (like in case of CPB and DB)!\r
70	// Instead of using the global buffer whose address is allocated within the\r
71	// 2GB limit if I start mapping the given buffer we lose the data, here is\r
72	// why!!!\r
73	// if our address is > 4GB, the map call creates another buffer below 2GB and\r
74	// copies data to/from the original buffer to the mapped buffer either at\r
75	// map time or unmap time depending on the map direction.\r
76	// UNDI will not complain since we already mapped the buffer to be\r
77	// within the 2GB limit but will not use (I know undi) the mapped address\r
78	// since it does not give the user buffers to the NIC's receive unit,\r
79	// It just copies the received packet into the user buffer using the virtual\r
80	// (CPU) address rather than the mapped (device or physical) address.\r
81	// When the UNDI call returns, if we then unmap the buffer, we will lose\r
82	// the contents because unmap copies the contents of the mapped buffer into\r
83	// the original buffer (since the direction is FROM_DEVICE) !!!\r
84	//\r
85	// this is not a problem in Undi 3.1 because this undi uses it's map callback\r
86	// routine to map a cpu address to device address and it does it only if\r
87	// it is giving the address to the device and unmaps it before using the cpu\r
88	// address!\r
89	//\r
90	TempData = (UINT64) (UINTN) BufferPtr;\r
91	if (snp->IsOldUndi && (TempData >= FOUR_GIGABYTES)) {\r
92	cpb->BufferAddr = (UINT64)(UINTN) snp->receive_buf;\r
93	cpb->BufferLen = (UINT32) (snp->init_info.MediaHeaderLen + snp->init_info.FrameDataLen);\r
94	} else {\r
95	cpb->BufferAddr = (UINT64)(UINTN) BufferPtr;\r
96	cpb->BufferLen = (UINT32) *BuffSizePtr;\r
97	}\r
98	\r
99	cpb->reserved = 0;\r
100	\r
101	snp->cdb.OpCode = PXE_OPCODE_RECEIVE;\r
102	snp->cdb.OpFlags = PXE_OPFLAGS_NOT_USED;\r
103	\r
104	snp->cdb.CPBsize = sizeof (PXE_CPB_RECEIVE);\r
105	snp->cdb.CPBaddr = (UINT64)(UINTN) cpb;\r
106	\r
107	snp->cdb.DBsize = sizeof (PXE_DB_RECEIVE);\r
108	snp->cdb.DBaddr = (UINT64)(UINTN) db;\r
109	\r
110	snp->cdb.StatCode = PXE_STATCODE_INITIALIZE;\r
111	snp->cdb.StatFlags = PXE_STATFLAGS_INITIALIZE;\r
112	snp->cdb.IFnum = snp->if_num;\r
113	snp->cdb.Control = PXE_CONTROL_LAST_CDB_IN_LIST;\r
114	\r
115	//\r
116	// Issue UNDI command and check result.\r
117	//\r
d01c093a	118	DEBUG ((EFI_D_NET, "\nsnp->undi.receive () "));\r
8a67d61d	119	\r
	120	(*snp->issue_undi32_command) ((UINT64)(UINTN) &snp->cdb);\r
	121	\r
	122	switch (snp->cdb.StatCode) {\r
	123	case PXE_STATCODE_SUCCESS:\r
	124	break;\r
	125	\r
	126	case PXE_STATCODE_NO_DATA:\r
	127	DEBUG (\r
d01c093a	128	(EFI_D_NET,\r
8a67d61d	129	"\nsnp->undi.receive () %xh:%xh\n",\r
	130	snp->cdb.StatFlags,\r
	131	snp->cdb.StatCode)\r
	132	);\r
	133	\r
	134	return EFI_NOT_READY;\r
	135	\r
	136	default:\r
	137	DEBUG (\r
	138	(EFI_D_ERROR,\r
	139	"\nsnp->undi.receive() %xh:%xh\n",\r
	140	snp->cdb.StatFlags,\r
	141	snp->cdb.StatCode)\r
	142	);\r
	143	\r
	144	return EFI_DEVICE_ERROR;\r
	145	}\r
	146	\r
	147	*BuffSizePtr = db->FrameLen;\r
	148	\r
	149	if (HeaderSizePtr != NULL) {\r
	150	*HeaderSizePtr = db->MediaHeaderLen;\r
	151	}\r
	152	\r
	153	if (SourceAddrPtr != NULL) {\r
	154	CopyMem (SourceAddrPtr, &db->SrcAddr, snp->mode.HwAddressSize);\r
	155	}\r
	156	\r
	157	if (DestinationAddrPtr != NULL) {\r
	158	CopyMem (DestinationAddrPtr, &db->DestAddr, snp->mode.HwAddressSize);\r
	159	}\r
	160	\r
	161	if (ProtocolPtr != NULL) {\r
	162	ProtocolPtr = (UINT16) PXE_SWAP_UINT16 (db->Protocol); / we need to do the byte swapping */\r
	163	}\r
	164	\r
	165	TempData = (UINT64) (UINTN) BufferPtr;\r
	166	if (snp->IsOldUndi && (TempData >= FOUR_GIGABYTES)) {\r
	167	CopyMem (BufferPtr, snp->receive_buf, snp->init_info.MediaHeaderLen + snp->init_info.FrameDataLen);\r
	168	}\r
	169	\r
	170	return (*BuffSizePtr <= buf_size) ? EFI_SUCCESS : EFI_BUFFER_TOO_SMALL;\r
	171	}\r
	172	\r
	173	\r
	174	/**\r
	175	This is the SNP interface routine for receiving network data.\r
	176	This routine basically retrieves snp structure, checks the SNP state and\r
	177	calls the pxe_receive routine to actually do the receive!\r
	178	\r
	179	@param this context pointer\r
	180	@param HeaderSizePtr optional parameter and is a pointer to the header\r
	181	portion of the data received.\r
	182	@param BuffSizePtr is a pointer to the length of the buffer on entry and\r
	183	contains the length of the received data on return\r
	184	@param BufferPtr pointer to the memory for the received data\r
	185	@param SourceAddrPtr optional parameter, is a pointer to contain the\r
	186	source ethernet address on return\r
	187	@param DestinationAddrPtr optional parameter, is a pointer to contain the\r
	188	destination ethernet address on return\r
	189	@param ProtocolPtr optional parameter, is a pointer to contain the\r
	190	protocol type from the ethernet header on return\r
	191	\r
	192	\r
193	**/\r
194	EFI_STATUS\r
195	EFIAPI\r
196	snp_undi32_receive (\r
197	IN EFI_SIMPLE_NETWORK_PROTOCOL * this,\r
198	OUT UINTN *HeaderSizePtr OPTIONAL,\r
199	IN OUT UINTN *BuffSizePtr,\r
200	OUT VOID *BufferPtr,\r
201	OUT EFI_MAC_ADDRESS * SourceAddrPtr OPTIONAL,\r
202	OUT EFI_MAC_ADDRESS * DestinationAddrPtr OPTIONAL,\r
203	OUT UINT16 *ProtocolPtr OPTIONAL\r
204	)\r
205	{\r
206	SNP_DRIVER *snp;\r
207	EFI_TPL OldTpl;\r
208	EFI_STATUS Status;\r
209	\r
210	if (this == NULL) {\r
211	return EFI_INVALID_PARAMETER;\r
212	}\r
213	\r
214	snp = EFI_SIMPLE_NETWORK_DEV_FROM_THIS (this);\r
215	\r
216	OldTpl = gBS->RaiseTPL (TPL_CALLBACK);\r
217	\r
218	switch (snp->mode.State) {\r
219	case EfiSimpleNetworkInitialized:\r
220	break;\r
221	\r
222	case EfiSimpleNetworkStopped:\r
223	Status = EFI_NOT_STARTED;\r
224	goto ON_EXIT;\r
225	\r
226	default:\r
227	Status = EFI_DEVICE_ERROR;\r
228	goto ON_EXIT;\r
229	}\r
230	\r
231	if ((BuffSizePtr == NULL) \|\| (BufferPtr == NULL)) {\r
232	Status = EFI_INVALID_PARAMETER;\r
233	goto ON_EXIT;\r
234	}\r
235	\r
236	if (!snp->mode.ReceiveFilterSetting) {\r
237	Status = EFI_DEVICE_ERROR;\r
238	goto ON_EXIT;\r
239	}\r
240	\r
241	Status = pxe_receive (\r
242	snp,\r
243	BufferPtr,\r
244	BuffSizePtr,\r
245	HeaderSizePtr,\r
246	SourceAddrPtr,\r
247	DestinationAddrPtr,\r
248	ProtocolPtr\r
249	);\r
250	\r
251	ON_EXIT:\r
252	gBS->RestoreTPL (OldTpl);\r
253	\r
254	return Status;\r
255	}\r