2003-08-25 23:28:32 +00:00
|
|
|
/*-
|
2000-03-28 01:19:53 +00:00
|
|
|
* Copyright (c) 2000 Alfred Perlstein <alfred@freebsd.org>
|
|
|
|
* Copyright (c) 2000 Paul Saab <ps@freebsd.org>
|
|
|
|
* All rights reserved.
|
2019-03-06 22:11:45 +00:00
|
|
|
* Copyright (c) 2000 John Baldwin <jhb@freebsd.org>
|
2000-03-28 01:19:53 +00:00
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
2003-08-25 23:28:32 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
2000-03-28 01:19:53 +00:00
|
|
|
#include <stand.h>
|
2021-08-12 02:49:17 +00:00
|
|
|
#include <errno.h>
|
|
|
|
#include <stdbool.h>
|
2017-05-06 20:32:27 +00:00
|
|
|
#include <stddef.h>
|
2000-04-29 23:08:49 +00:00
|
|
|
#include <string.h>
|
|
|
|
#include <stdarg.h>
|
2017-05-06 20:32:27 +00:00
|
|
|
#include <sys/param.h>
|
2000-03-28 01:19:53 +00:00
|
|
|
|
2017-05-06 20:32:27 +00:00
|
|
|
#include <net/ethernet.h>
|
2000-04-08 01:22:14 +00:00
|
|
|
#include <netinet/in_systm.h>
|
|
|
|
#include <netinet/in.h>
|
2017-05-06 20:32:27 +00:00
|
|
|
#include <netinet/ip.h>
|
2000-04-08 01:22:14 +00:00
|
|
|
#include <netinet/udp.h>
|
2000-03-28 01:19:53 +00:00
|
|
|
|
2000-04-08 01:22:14 +00:00
|
|
|
#include <net.h>
|
|
|
|
#include <netif.h>
|
2000-09-05 22:32:31 +00:00
|
|
|
#include <nfsv2.h>
|
|
|
|
#include <iodesc.h>
|
2000-04-08 01:22:14 +00:00
|
|
|
|
2000-08-11 08:36:17 +00:00
|
|
|
#include <bootp.h>
|
2000-03-28 01:19:53 +00:00
|
|
|
#include <bootstrap.h>
|
2018-12-30 09:35:47 +00:00
|
|
|
#include "libi386.h"
|
2000-03-28 01:19:53 +00:00
|
|
|
#include "btxv86.h"
|
2000-04-04 00:38:59 +00:00
|
|
|
#include "pxe.h"
|
2000-03-28 01:19:53 +00:00
|
|
|
|
2017-03-09 05:13:07 +00:00
|
|
|
static pxenv_t *pxenv_p = NULL; /* PXENV+ */
|
|
|
|
static pxe_t *pxe_p = NULL; /* !PXE */
|
2000-04-08 01:22:14 +00:00
|
|
|
|
2017-05-06 20:32:27 +00:00
|
|
|
#ifdef PXE_DEBUG
|
2017-03-09 05:13:07 +00:00
|
|
|
static int pxe_debug = 0;
|
2017-05-06 20:32:27 +00:00
|
|
|
#endif
|
2000-03-28 01:19:53 +00:00
|
|
|
|
|
|
|
void pxe_enable(void *pxeinfo);
|
2018-12-30 09:35:47 +00:00
|
|
|
static void (*pxe_call)(int func, void *ptr);
|
|
|
|
static void pxenv_call(int func, void *ptr);
|
|
|
|
static void bangpxe_call(int func, void *ptr);
|
2000-04-08 01:22:14 +00:00
|
|
|
|
2000-03-28 01:19:53 +00:00
|
|
|
static int pxe_init(void);
|
2016-11-08 06:50:18 +00:00
|
|
|
static int pxe_print(int verbose);
|
2000-04-19 11:22:38 +00:00
|
|
|
static void pxe_cleanup(void);
|
2000-03-28 01:19:53 +00:00
|
|
|
|
|
|
|
static void pxe_perror(int error);
|
2000-04-08 01:22:14 +00:00
|
|
|
static int pxe_netif_match(struct netif *nif, void *machdep_hint);
|
|
|
|
static int pxe_netif_probe(struct netif *nif, void *machdep_hint);
|
|
|
|
static void pxe_netif_init(struct iodesc *desc, void *machdep_hint);
|
2017-05-06 20:32:27 +00:00
|
|
|
static ssize_t pxe_netif_get(struct iodesc *, void **, time_t);
|
|
|
|
static ssize_t pxe_netif_put(struct iodesc *desc, void *pkt, size_t len);
|
2000-04-08 01:22:14 +00:00
|
|
|
static void pxe_netif_end(struct netif *nif);
|
|
|
|
|
|
|
|
extern struct netif_stats pxe_st[];
|
2018-03-13 16:33:00 +00:00
|
|
|
extern uint16_t __bangpxeseg;
|
|
|
|
extern uint16_t __bangpxeoff;
|
2000-04-26 07:38:40 +00:00
|
|
|
extern void __bangpxeentry(void);
|
2018-03-13 16:33:00 +00:00
|
|
|
extern uint16_t __pxenvseg;
|
|
|
|
extern uint16_t __pxenvoff;
|
2000-04-26 07:38:40 +00:00
|
|
|
extern void __pxenventry(void);
|
2000-04-08 01:22:14 +00:00
|
|
|
|
|
|
|
struct netif_dif pxe_ifs[] = {
|
2017-03-09 05:13:07 +00:00
|
|
|
/* dif_unit dif_nsel dif_stats dif_private */
|
2000-04-08 01:22:14 +00:00
|
|
|
{0, 1, &pxe_st[0], 0}
|
|
|
|
};
|
2000-03-28 01:19:53 +00:00
|
|
|
|
2017-05-06 20:32:27 +00:00
|
|
|
struct netif_stats pxe_st[nitems(pxe_ifs)];
|
2000-04-08 01:22:14 +00:00
|
|
|
|
|
|
|
struct netif_driver pxenetif = {
|
2017-05-06 20:32:27 +00:00
|
|
|
.netif_bname = "pxenet",
|
|
|
|
.netif_match = pxe_netif_match,
|
|
|
|
.netif_probe = pxe_netif_probe,
|
|
|
|
.netif_init = pxe_netif_init,
|
|
|
|
.netif_get = pxe_netif_get,
|
|
|
|
.netif_put = pxe_netif_put,
|
|
|
|
.netif_end = pxe_netif_end,
|
|
|
|
.netif_ifs = pxe_ifs,
|
|
|
|
.netif_nifs = nitems(pxe_ifs)
|
2000-04-08 01:22:14 +00:00
|
|
|
};
|
2000-03-28 01:19:53 +00:00
|
|
|
|
2000-04-08 01:22:14 +00:00
|
|
|
struct netif_driver *netif_drivers[] = {
|
|
|
|
&pxenetif,
|
|
|
|
NULL
|
|
|
|
};
|
2000-03-28 01:19:53 +00:00
|
|
|
|
|
|
|
struct devsw pxedisk = {
|
2017-05-06 20:32:27 +00:00
|
|
|
.dv_name = "net",
|
|
|
|
.dv_type = DEVT_NET,
|
|
|
|
.dv_init = pxe_init,
|
|
|
|
.dv_strategy = NULL, /* Will be set in pxe_init */
|
|
|
|
.dv_open = NULL, /* Will be set in pxe_init */
|
|
|
|
.dv_close = NULL, /* Will be set in pxe_init */
|
|
|
|
.dv_ioctl = noioctl,
|
|
|
|
.dv_print = pxe_print,
|
2022-07-27 14:46:21 +00:00
|
|
|
.dv_cleanup = pxe_cleanup,
|
2000-03-28 01:19:53 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This function is called by the loader to enable PXE support if we
|
2017-03-09 05:13:07 +00:00
|
|
|
* are booted by PXE. The passed in pointer is a pointer to the PXENV+
|
|
|
|
* structure.
|
2000-03-28 01:19:53 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
pxe_enable(void *pxeinfo)
|
|
|
|
{
|
2000-04-26 07:38:40 +00:00
|
|
|
pxenv_p = (pxenv_t *)pxeinfo;
|
|
|
|
pxe_p = (pxe_t *)PTOV(pxenv_p->PXEPtr.segment * 16 +
|
|
|
|
pxenv_p->PXEPtr.offset);
|
|
|
|
pxe_call = NULL;
|
2000-03-28 01:19:53 +00:00
|
|
|
}
|
|
|
|
|
2017-03-09 05:13:07 +00:00
|
|
|
/*
|
2000-03-28 01:19:53 +00:00
|
|
|
* return true if pxe structures are found/initialized,
|
2017-03-09 05:13:07 +00:00
|
|
|
* also figures out our IP information via the pxe cached info struct
|
2000-03-28 01:19:53 +00:00
|
|
|
*/
|
|
|
|
static int
|
|
|
|
pxe_init(void)
|
|
|
|
{
|
2017-03-09 05:13:07 +00:00
|
|
|
t_PXENV_GET_CACHED_INFO *gci_p;
|
|
|
|
int counter;
|
2000-03-28 01:19:53 +00:00
|
|
|
uint8_t checksum;
|
|
|
|
uint8_t *checkptr;
|
2017-05-06 20:32:27 +00:00
|
|
|
extern struct devsw netdev;
|
2017-03-09 05:13:07 +00:00
|
|
|
|
|
|
|
if (pxenv_p == NULL)
|
2000-03-28 01:19:53 +00:00
|
|
|
return (0);
|
|
|
|
|
2017-03-09 05:13:07 +00:00
|
|
|
/* look for "PXENV+" */
|
2000-04-21 04:58:51 +00:00
|
|
|
if (bcmp((void *)pxenv_p->Signature, S_SIZE("PXENV+"))) {
|
|
|
|
pxenv_p = NULL;
|
2000-03-28 01:19:53 +00:00
|
|
|
return (0);
|
2000-04-21 04:58:51 +00:00
|
|
|
}
|
2000-03-28 01:19:53 +00:00
|
|
|
|
|
|
|
/* make sure the size is something we can handle */
|
|
|
|
if (pxenv_p->Length > sizeof(*pxenv_p)) {
|
2017-03-09 05:13:07 +00:00
|
|
|
printf("PXENV+ structure too large, ignoring\n");
|
2000-03-28 01:19:53 +00:00
|
|
|
pxenv_p = NULL;
|
|
|
|
return (0);
|
|
|
|
}
|
2017-03-09 05:13:07 +00:00
|
|
|
|
|
|
|
/*
|
2000-03-28 01:19:53 +00:00
|
|
|
* do byte checksum:
|
|
|
|
* add up each byte in the structure, the total should be 0
|
|
|
|
*/
|
2017-03-09 05:13:07 +00:00
|
|
|
checksum = 0;
|
2000-03-28 01:19:53 +00:00
|
|
|
checkptr = (uint8_t *) pxenv_p;
|
|
|
|
for (counter = 0; counter < pxenv_p->Length; counter++)
|
|
|
|
checksum += *checkptr++;
|
|
|
|
if (checksum != 0) {
|
|
|
|
printf("PXENV+ structure failed checksum, ignoring\n");
|
|
|
|
pxenv_p = NULL;
|
|
|
|
return (0);
|
|
|
|
}
|
2000-04-19 11:22:38 +00:00
|
|
|
|
2000-04-26 07:38:40 +00:00
|
|
|
/*
|
|
|
|
* PXENV+ passed, so use that if !PXE is not available or
|
|
|
|
* the checksum fails.
|
|
|
|
*/
|
|
|
|
pxe_call = pxenv_call;
|
|
|
|
if (pxenv_p->Version >= 0x0200) {
|
|
|
|
for (;;) {
|
|
|
|
if (bcmp((void *)pxe_p->Signature, S_SIZE("!PXE"))) {
|
|
|
|
pxe_p = NULL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
checksum = 0;
|
|
|
|
checkptr = (uint8_t *)pxe_p;
|
|
|
|
for (counter = 0; counter < pxe_p->StructLength;
|
2017-03-09 05:13:07 +00:00
|
|
|
counter++)
|
2000-04-26 07:38:40 +00:00
|
|
|
checksum += *checkptr++;
|
|
|
|
if (checksum != 0) {
|
|
|
|
pxe_p = NULL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
pxe_call = bangpxe_call;
|
|
|
|
break;
|
|
|
|
}
|
2000-04-19 11:22:38 +00:00
|
|
|
}
|
2017-05-06 20:32:27 +00:00
|
|
|
|
|
|
|
pxedisk.dv_open = netdev.dv_open;
|
|
|
|
pxedisk.dv_close = netdev.dv_close;
|
|
|
|
pxedisk.dv_strategy = netdev.dv_strategy;
|
|
|
|
|
2000-04-26 07:38:40 +00:00
|
|
|
printf("\nPXE version %d.%d, real mode entry point ",
|
2017-03-09 05:13:07 +00:00
|
|
|
(uint8_t) (pxenv_p->Version >> 8),
|
|
|
|
(uint8_t) (pxenv_p->Version & 0xFF));
|
2000-04-26 07:38:40 +00:00
|
|
|
if (pxe_call == bangpxe_call)
|
|
|
|
printf("@%04x:%04x\n",
|
2017-03-09 05:13:07 +00:00
|
|
|
pxe_p->EntryPointSP.segment,
|
|
|
|
pxe_p->EntryPointSP.offset);
|
2000-04-26 07:38:40 +00:00
|
|
|
else
|
|
|
|
printf("@%04x:%04x\n",
|
2017-03-09 05:13:07 +00:00
|
|
|
pxenv_p->RMEntry.segment, pxenv_p->RMEntry.offset);
|
2000-03-28 01:19:53 +00:00
|
|
|
|
2018-12-30 09:35:47 +00:00
|
|
|
gci_p = bio_alloc(sizeof(*gci_p));
|
|
|
|
if (gci_p == NULL) {
|
|
|
|
pxe_p = NULL;
|
|
|
|
return (0);
|
|
|
|
}
|
2000-03-28 01:19:53 +00:00
|
|
|
bzero(gci_p, sizeof(*gci_p));
|
2017-03-09 05:13:07 +00:00
|
|
|
gci_p->PacketType = PXENV_PACKET_TYPE_BINL_REPLY;
|
2018-12-30 09:35:47 +00:00
|
|
|
pxe_call(PXENV_GET_CACHED_INFO, gci_p);
|
2000-03-28 01:19:53 +00:00
|
|
|
if (gci_p->Status != 0) {
|
|
|
|
pxe_perror(gci_p->Status);
|
2018-12-30 09:35:47 +00:00
|
|
|
bio_free(gci_p, sizeof(*gci_p));
|
2000-04-21 03:04:16 +00:00
|
|
|
pxe_p = NULL;
|
2000-03-28 01:19:53 +00:00
|
|
|
return (0);
|
|
|
|
}
|
2017-05-06 20:32:27 +00:00
|
|
|
free(bootp_response);
|
|
|
|
if ((bootp_response = malloc(gci_p->BufferSize)) != NULL) {
|
|
|
|
bootp_response_size = gci_p->BufferSize;
|
|
|
|
bcopy(PTOV((gci_p->Buffer.segment << 4) + gci_p->Buffer.offset),
|
|
|
|
bootp_response, bootp_response_size);
|
2017-03-09 05:13:07 +00:00
|
|
|
}
|
2018-12-30 09:35:47 +00:00
|
|
|
bio_free(gci_p, sizeof(*gci_p));
|
2017-05-06 20:32:27 +00:00
|
|
|
return (1);
|
2000-04-08 01:22:14 +00:00
|
|
|
}
|
2000-03-28 01:19:53 +00:00
|
|
|
|
2016-11-08 06:50:18 +00:00
|
|
|
static int
|
2000-04-08 01:22:14 +00:00
|
|
|
pxe_print(int verbose)
|
|
|
|
{
|
2012-09-12 21:00:37 +00:00
|
|
|
if (pxe_call == NULL)
|
2016-11-08 06:50:18 +00:00
|
|
|
return (0);
|
2012-09-12 21:00:37 +00:00
|
|
|
|
2016-11-19 08:54:21 +00:00
|
|
|
printf("%s devices:", pxedisk.dv_name);
|
|
|
|
if (pager_output("\n") != 0)
|
|
|
|
return (1);
|
2017-05-06 20:32:27 +00:00
|
|
|
printf(" %s0:", pxedisk.dv_name);
|
2016-11-08 06:50:18 +00:00
|
|
|
if (verbose) {
|
2017-05-06 20:32:27 +00:00
|
|
|
printf(" %s:%s", inet_ntoa(rootip), rootpath);
|
2016-11-08 06:50:18 +00:00
|
|
|
}
|
2017-05-06 20:32:27 +00:00
|
|
|
return (pager_output("\n"));
|
2000-03-28 01:19:53 +00:00
|
|
|
}
|
|
|
|
|
2000-04-19 11:22:38 +00:00
|
|
|
static void
|
|
|
|
pxe_cleanup(void)
|
|
|
|
{
|
2018-12-30 09:35:47 +00:00
|
|
|
t_PXENV_UNLOAD_STACK *unload_stack_p;
|
|
|
|
t_PXENV_UNDI_SHUTDOWN *undi_shutdown_p;
|
2000-04-19 11:22:38 +00:00
|
|
|
|
2000-04-26 07:38:40 +00:00
|
|
|
if (pxe_call == NULL)
|
2000-04-21 03:04:16 +00:00
|
|
|
return;
|
|
|
|
|
2018-12-30 09:35:47 +00:00
|
|
|
undi_shutdown_p = bio_alloc(sizeof(*undi_shutdown_p));
|
|
|
|
if (undi_shutdown_p != NULL) {
|
|
|
|
bzero(undi_shutdown_p, sizeof(*undi_shutdown_p));
|
|
|
|
pxe_call(PXENV_UNDI_SHUTDOWN, undi_shutdown_p);
|
2000-05-01 17:55:05 +00:00
|
|
|
|
|
|
|
#ifdef PXE_DEBUG
|
2018-12-30 09:35:47 +00:00
|
|
|
if (pxe_debug && undi_shutdown_p->Status != 0)
|
|
|
|
printf("pxe_cleanup: UNDI_SHUTDOWN failed %x\n",
|
|
|
|
undi_shutdown_p->Status);
|
2000-05-01 17:55:05 +00:00
|
|
|
#endif
|
2018-12-30 09:35:47 +00:00
|
|
|
bio_free(undi_shutdown_p, sizeof(*undi_shutdown_p));
|
|
|
|
}
|
2000-04-20 00:06:15 +00:00
|
|
|
|
2018-12-30 09:35:47 +00:00
|
|
|
unload_stack_p = bio_alloc(sizeof(*unload_stack_p));
|
|
|
|
if (unload_stack_p != NULL) {
|
|
|
|
bzero(unload_stack_p, sizeof(*unload_stack_p));
|
|
|
|
pxe_call(PXENV_UNLOAD_STACK, unload_stack_p);
|
2000-05-01 17:55:05 +00:00
|
|
|
|
2017-03-09 05:13:07 +00:00
|
|
|
#ifdef PXE_DEBUG
|
2018-12-30 09:35:47 +00:00
|
|
|
if (pxe_debug && unload_stack_p->Status != 0)
|
|
|
|
printf("pxe_cleanup: UNLOAD_STACK failed %x\n",
|
|
|
|
unload_stack_p->Status);
|
2000-05-01 17:55:05 +00:00
|
|
|
#endif
|
2018-12-30 09:35:47 +00:00
|
|
|
bio_free(unload_stack_p, sizeof(*unload_stack_p));
|
|
|
|
}
|
2000-04-19 11:22:38 +00:00
|
|
|
}
|
2000-04-08 01:22:14 +00:00
|
|
|
|
2000-03-28 01:19:53 +00:00
|
|
|
void
|
|
|
|
pxe_perror(int err)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2018-12-30 09:35:47 +00:00
|
|
|
pxenv_call(int func, void *ptr)
|
2000-04-26 07:38:40 +00:00
|
|
|
{
|
|
|
|
#ifdef PXE_DEBUG
|
2000-08-03 09:14:02 +00:00
|
|
|
if (pxe_debug)
|
2000-04-26 07:38:40 +00:00
|
|
|
printf("pxenv_call %x\n", func);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
bzero(&v86, sizeof(v86));
|
|
|
|
|
|
|
|
__pxenvseg = pxenv_p->RMEntry.segment;
|
|
|
|
__pxenvoff = pxenv_p->RMEntry.offset;
|
|
|
|
|
|
|
|
v86.ctl = V86_ADDR | V86_CALLF | V86_FLAGS;
|
2018-12-30 09:35:47 +00:00
|
|
|
v86.es = VTOPSEG(ptr);
|
|
|
|
v86.edi = VTOPOFF(ptr);
|
2000-04-26 07:38:40 +00:00
|
|
|
v86.addr = (VTOPSEG(__pxenventry) << 16) | VTOPOFF(__pxenventry);
|
|
|
|
v86.ebx = func;
|
|
|
|
v86int();
|
|
|
|
v86.ctl = V86_FLAGS;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2018-12-30 09:35:47 +00:00
|
|
|
bangpxe_call(int func, void *ptr)
|
2000-03-28 01:19:53 +00:00
|
|
|
{
|
2000-04-26 07:38:40 +00:00
|
|
|
#ifdef PXE_DEBUG
|
2000-08-03 09:14:02 +00:00
|
|
|
if (pxe_debug)
|
2000-04-26 07:38:40 +00:00
|
|
|
printf("bangpxe_call %x\n", func);
|
|
|
|
#endif
|
2017-03-09 05:13:07 +00:00
|
|
|
|
2000-03-28 01:19:53 +00:00
|
|
|
bzero(&v86, sizeof(v86));
|
2000-04-19 11:22:38 +00:00
|
|
|
|
2000-04-26 07:38:40 +00:00
|
|
|
__bangpxeseg = pxe_p->EntryPointSP.segment;
|
|
|
|
__bangpxeoff = pxe_p->EntryPointSP.offset;
|
2017-03-09 05:13:07 +00:00
|
|
|
|
2000-04-19 11:22:38 +00:00
|
|
|
v86.ctl = V86_ADDR | V86_CALLF | V86_FLAGS;
|
2018-12-30 09:35:47 +00:00
|
|
|
v86.edx = VTOPSEG(ptr);
|
|
|
|
v86.eax = VTOPOFF(ptr);
|
2000-04-26 07:38:40 +00:00
|
|
|
v86.addr = (VTOPSEG(__bangpxeentry) << 16) | VTOPOFF(__bangpxeentry);
|
2000-04-19 11:22:38 +00:00
|
|
|
v86.ebx = func;
|
2000-03-28 01:19:53 +00:00
|
|
|
v86int();
|
2000-04-19 11:22:38 +00:00
|
|
|
v86.ctl = V86_FLAGS;
|
2000-03-28 01:19:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
2000-04-08 01:22:14 +00:00
|
|
|
pxe_netif_match(struct netif *nif, void *machdep_hint)
|
2000-03-28 01:19:53 +00:00
|
|
|
{
|
2017-05-06 20:32:27 +00:00
|
|
|
return (1);
|
2000-03-28 01:19:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2000-04-08 01:22:14 +00:00
|
|
|
pxe_netif_probe(struct netif *nif, void *machdep_hint)
|
2000-03-28 01:19:53 +00:00
|
|
|
{
|
2000-04-26 07:38:40 +00:00
|
|
|
if (pxe_call == NULL)
|
2017-05-06 20:32:27 +00:00
|
|
|
return (-1);
|
2000-03-28 01:19:53 +00:00
|
|
|
|
2017-05-06 20:32:27 +00:00
|
|
|
return (0);
|
2000-03-28 01:19:53 +00:00
|
|
|
}
|
|
|
|
|
2000-04-08 01:22:14 +00:00
|
|
|
static void
|
|
|
|
pxe_netif_end(struct netif *nif)
|
2000-03-28 01:19:53 +00:00
|
|
|
{
|
2017-05-06 20:32:27 +00:00
|
|
|
t_PXENV_UNDI_CLOSE *undi_close_p;
|
2000-03-28 01:19:53 +00:00
|
|
|
|
2018-12-30 09:35:47 +00:00
|
|
|
undi_close_p = bio_alloc(sizeof(*undi_close_p));
|
|
|
|
if (undi_close_p != NULL) {
|
|
|
|
bzero(undi_close_p, sizeof(*undi_close_p));
|
|
|
|
pxe_call(PXENV_UNDI_CLOSE, undi_close_p);
|
|
|
|
if (undi_close_p->Status != 0)
|
|
|
|
printf("undi close failed: %x\n", undi_close_p->Status);
|
|
|
|
bio_free(undi_close_p, sizeof(*undi_close_p));
|
|
|
|
}
|
2000-03-28 01:19:53 +00:00
|
|
|
}
|
|
|
|
|
2000-04-08 01:22:14 +00:00
|
|
|
static void
|
|
|
|
pxe_netif_init(struct iodesc *desc, void *machdep_hint)
|
2000-03-28 01:19:53 +00:00
|
|
|
{
|
2017-05-06 20:32:27 +00:00
|
|
|
t_PXENV_UNDI_GET_INFORMATION *undi_info_p;
|
|
|
|
t_PXENV_UNDI_OPEN *undi_open_p;
|
|
|
|
uint8_t *mac;
|
|
|
|
int i, len;
|
|
|
|
|
2018-12-30 09:35:47 +00:00
|
|
|
undi_info_p = bio_alloc(sizeof(*undi_info_p));
|
|
|
|
if (undi_info_p == NULL)
|
|
|
|
return;
|
|
|
|
|
2017-05-06 20:32:27 +00:00
|
|
|
bzero(undi_info_p, sizeof(*undi_info_p));
|
2018-12-30 09:35:47 +00:00
|
|
|
pxe_call(PXENV_UNDI_GET_INFORMATION, undi_info_p);
|
2017-05-06 20:32:27 +00:00
|
|
|
if (undi_info_p->Status != 0) {
|
|
|
|
printf("undi get info failed: %x\n", undi_info_p->Status);
|
2018-12-30 09:35:47 +00:00
|
|
|
bio_free(undi_info_p, sizeof(*undi_info_p));
|
2017-05-06 20:32:27 +00:00
|
|
|
return;
|
|
|
|
}
|
2000-03-28 01:19:53 +00:00
|
|
|
|
2017-05-06 20:32:27 +00:00
|
|
|
/* Make sure the CurrentNodeAddress is valid. */
|
|
|
|
for (i = 0; i < undi_info_p->HwAddrLen; ++i) {
|
|
|
|
if (undi_info_p->CurrentNodeAddress[i] != 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (i < undi_info_p->HwAddrLen) {
|
|
|
|
for (i = 0; i < undi_info_p->HwAddrLen; ++i) {
|
|
|
|
if (undi_info_p->CurrentNodeAddress[i] != 0xff)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (i < undi_info_p->HwAddrLen)
|
|
|
|
mac = undi_info_p->CurrentNodeAddress;
|
|
|
|
else
|
|
|
|
mac = undi_info_p->PermNodeAddress;
|
|
|
|
|
|
|
|
len = min(sizeof (desc->myea), undi_info_p->HwAddrLen);
|
|
|
|
for (i = 0; i < len; ++i)
|
|
|
|
desc->myea[i] = mac[i];
|
|
|
|
|
|
|
|
if (bootp_response != NULL)
|
|
|
|
desc->xid = bootp_response->bp_xid;
|
|
|
|
else
|
|
|
|
desc->xid = 0;
|
|
|
|
|
2018-12-30 09:35:47 +00:00
|
|
|
bio_free(undi_info_p, sizeof(*undi_info_p));
|
|
|
|
undi_open_p = bio_alloc(sizeof(*undi_open_p));
|
|
|
|
if (undi_open_p == NULL)
|
|
|
|
return;
|
2017-05-06 20:32:27 +00:00
|
|
|
bzero(undi_open_p, sizeof(*undi_open_p));
|
|
|
|
undi_open_p->PktFilter = FLTR_DIRECTED | FLTR_BRDCST;
|
2018-12-30 09:35:47 +00:00
|
|
|
pxe_call(PXENV_UNDI_OPEN, undi_open_p);
|
2017-05-06 20:32:27 +00:00
|
|
|
if (undi_open_p->Status != 0)
|
|
|
|
printf("undi open failed: %x\n", undi_open_p->Status);
|
2018-12-30 09:35:47 +00:00
|
|
|
bio_free(undi_open_p, sizeof(*undi_open_p));
|
2000-03-28 01:19:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2021-08-12 02:49:17 +00:00
|
|
|
pxe_netif_receive_isr(t_PXENV_UNDI_ISR *isr, void **pkt, ssize_t *retsize)
|
2000-03-28 01:19:53 +00:00
|
|
|
{
|
2021-08-12 02:49:17 +00:00
|
|
|
static bool data_pending;
|
2017-05-06 20:32:27 +00:00
|
|
|
char *buf, *ptr, *frame;
|
|
|
|
size_t size, rsize;
|
|
|
|
|
2021-08-12 02:49:17 +00:00
|
|
|
buf = NULL;
|
|
|
|
size = rsize = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We can save ourselves the next two pxe calls because we already know
|
|
|
|
* we weren't done grabbing everything.
|
|
|
|
*/
|
|
|
|
if (data_pending) {
|
|
|
|
data_pending = false;
|
|
|
|
goto nextbuf;
|
|
|
|
}
|
2018-12-30 09:35:47 +00:00
|
|
|
|
2021-08-12 02:49:17 +00:00
|
|
|
/*
|
|
|
|
* We explicitly don't check for OURS/NOT_OURS as a result of START;
|
|
|
|
* it's been reported that some cards are known to mishandle these.
|
|
|
|
*/
|
2017-05-06 20:32:27 +00:00
|
|
|
bzero(isr, sizeof(*isr));
|
|
|
|
isr->FuncFlag = PXENV_UNDI_ISR_IN_START;
|
2018-12-30 09:35:47 +00:00
|
|
|
pxe_call(PXENV_UNDI_ISR, isr);
|
2021-08-12 02:49:17 +00:00
|
|
|
/* We could translate Status... */
|
2018-12-30 09:35:47 +00:00
|
|
|
if (isr->Status != 0) {
|
2021-08-12 02:49:17 +00:00
|
|
|
return (ENXIO);
|
2018-12-30 09:35:47 +00:00
|
|
|
}
|
2017-05-06 20:32:27 +00:00
|
|
|
|
|
|
|
bzero(isr, sizeof(*isr));
|
|
|
|
isr->FuncFlag = PXENV_UNDI_ISR_IN_PROCESS;
|
2018-12-30 09:35:47 +00:00
|
|
|
pxe_call(PXENV_UNDI_ISR, isr);
|
|
|
|
if (isr->Status != 0) {
|
2021-08-12 02:49:17 +00:00
|
|
|
return (ENXIO);
|
2018-12-30 09:35:47 +00:00
|
|
|
}
|
2021-08-12 02:49:17 +00:00
|
|
|
if (isr->FuncFlag == PXENV_UNDI_ISR_OUT_BUSY) {
|
2017-05-06 20:32:27 +00:00
|
|
|
/*
|
2021-08-12 02:49:17 +00:00
|
|
|
* Let the caller decide if we need to be restarted. It will
|
|
|
|
* currently blindly restart us, but it could check timeout in
|
|
|
|
* the future.
|
2017-05-06 20:32:27 +00:00
|
|
|
*/
|
2021-08-12 02:49:17 +00:00
|
|
|
return (ERESTART);
|
2017-05-06 20:32:27 +00:00
|
|
|
}
|
2000-03-28 01:19:53 +00:00
|
|
|
|
2021-08-12 02:49:17 +00:00
|
|
|
/*
|
|
|
|
* By design, we'll hardly ever hit this terminal condition unless we
|
|
|
|
* pick up nothing but tx interrupts here. More frequently, we will
|
|
|
|
* process rx buffers until we hit the terminal condition in the middle.
|
|
|
|
*/
|
|
|
|
while (isr->FuncFlag != PXENV_UNDI_ISR_OUT_DONE) {
|
|
|
|
/*
|
|
|
|
* This might have given us PXENV_UNDI_ISR_OUT_TRANSMIT, in
|
|
|
|
* which case we can just disregard and move on to the next
|
|
|
|
* buffer/frame.
|
|
|
|
*/
|
|
|
|
if (isr->FuncFlag != PXENV_UNDI_ISR_OUT_RECEIVE)
|
|
|
|
goto nextbuf;
|
|
|
|
|
|
|
|
if (buf == NULL) {
|
|
|
|
/*
|
|
|
|
* Grab size from the first Frame that we picked up,
|
|
|
|
* allocate an rx buf to hold. Careful here, as we may
|
|
|
|
* see a fragmented frame that's spread out across
|
|
|
|
* multiple GET_NEXT calls.
|
|
|
|
*/
|
|
|
|
size = isr->FrameLength;
|
|
|
|
buf = malloc(size + ETHER_ALIGN);
|
|
|
|
if (buf == NULL)
|
|
|
|
return (ENOMEM);
|
|
|
|
|
|
|
|
ptr = buf + ETHER_ALIGN;
|
2017-05-06 20:32:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
frame = (char *)((uintptr_t)isr->Frame.segment << 4);
|
|
|
|
frame += isr->Frame.offset;
|
|
|
|
bcopy(PTOV(frame), ptr, isr->BufferLength);
|
|
|
|
ptr += isr->BufferLength;
|
|
|
|
rsize += isr->BufferLength;
|
|
|
|
|
2021-08-12 02:49:17 +00:00
|
|
|
/*
|
|
|
|
* Stop here before we risk catching the start of another frame.
|
|
|
|
* It would be nice to continue reading until we actually get a
|
|
|
|
* PXENV_UNDI_ISR_OUT_DONE, but our network stack in libsa isn't
|
|
|
|
* suitable for reading more than one packet at a time.
|
|
|
|
*/
|
|
|
|
if (rsize >= size) {
|
|
|
|
data_pending = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
nextbuf:
|
2017-05-06 20:32:27 +00:00
|
|
|
bzero(isr, sizeof(*isr));
|
|
|
|
isr->FuncFlag = PXENV_UNDI_ISR_IN_GET_NEXT;
|
2018-12-30 09:35:47 +00:00
|
|
|
pxe_call(PXENV_UNDI_ISR, isr);
|
2017-05-06 20:32:27 +00:00
|
|
|
if (isr->Status != 0) {
|
|
|
|
free(buf);
|
2021-08-12 02:49:17 +00:00
|
|
|
return (ENXIO);
|
2017-05-06 20:32:27 +00:00
|
|
|
}
|
2021-08-12 02:49:17 +00:00
|
|
|
}
|
2000-03-28 01:19:53 +00:00
|
|
|
|
2021-08-12 02:49:17 +00:00
|
|
|
/*
|
|
|
|
* We may have never picked up a frame at all (all tx), in which case
|
|
|
|
* the caller should restart us.
|
|
|
|
*/
|
|
|
|
if (rsize == 0) {
|
|
|
|
return (ERESTART);
|
2000-04-19 11:22:38 +00:00
|
|
|
}
|
2017-05-06 20:32:27 +00:00
|
|
|
|
|
|
|
*pkt = buf;
|
2021-08-12 02:49:17 +00:00
|
|
|
*retsize = rsize;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
pxe_netif_receive(void **pkt, ssize_t *size)
|
|
|
|
{
|
|
|
|
t_PXENV_UNDI_ISR *isr;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
isr = bio_alloc(sizeof(*isr));
|
|
|
|
if (isr == NULL)
|
|
|
|
return (ENOMEM);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This completely ignores the timeout specified in pxe_netif_get(), but
|
|
|
|
* we shouldn't be running long enough here for that to make a
|
|
|
|
* difference.
|
|
|
|
*/
|
|
|
|
for (;;) {
|
|
|
|
/* We'll only really re-enter for PXENV_UNDI_ISR_OUT_BUSY. */
|
|
|
|
ret = pxe_netif_receive_isr(isr, pkt, size);
|
|
|
|
if (ret != ERESTART)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2018-12-30 09:35:47 +00:00
|
|
|
bio_free(isr, sizeof(*isr));
|
2021-08-12 02:49:17 +00:00
|
|
|
return (ret);
|
2000-03-28 01:19:53 +00:00
|
|
|
}
|
|
|
|
|
2017-05-06 20:32:27 +00:00
|
|
|
static ssize_t
|
|
|
|
pxe_netif_get(struct iodesc *desc, void **pkt, time_t timeout)
|
2000-03-28 01:19:53 +00:00
|
|
|
{
|
2017-05-06 20:32:27 +00:00
|
|
|
time_t t;
|
|
|
|
void *ptr;
|
|
|
|
int ret = -1;
|
2021-08-12 02:49:17 +00:00
|
|
|
ssize_t size;
|
2017-05-06 20:32:27 +00:00
|
|
|
|
|
|
|
t = getsecs();
|
2021-08-12 02:49:17 +00:00
|
|
|
size = 0;
|
2017-05-06 20:32:27 +00:00
|
|
|
while ((getsecs() - t) < timeout) {
|
2021-08-12 02:49:17 +00:00
|
|
|
ret = pxe_netif_receive(&ptr, &size);
|
2017-05-06 20:32:27 +00:00
|
|
|
if (ret != -1) {
|
|
|
|
*pkt = ptr;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2021-08-12 02:49:17 +00:00
|
|
|
|
|
|
|
return (ret == 0 ? size : -1);
|
2017-05-06 20:32:27 +00:00
|
|
|
}
|
2017-03-09 05:13:07 +00:00
|
|
|
|
2017-05-06 20:32:27 +00:00
|
|
|
static ssize_t
|
|
|
|
pxe_netif_put(struct iodesc *desc, void *pkt, size_t len)
|
|
|
|
{
|
|
|
|
t_PXENV_UNDI_TRANSMIT *trans_p;
|
|
|
|
t_PXENV_UNDI_TBD *tbd_p;
|
|
|
|
char *data;
|
2018-12-30 09:35:47 +00:00
|
|
|
ssize_t rv = -1;
|
2017-03-09 05:13:07 +00:00
|
|
|
|
2018-12-30 09:35:47 +00:00
|
|
|
trans_p = bio_alloc(sizeof(*trans_p));
|
|
|
|
tbd_p = bio_alloc(sizeof(*tbd_p));
|
|
|
|
data = bio_alloc(len);
|
2000-03-28 01:19:53 +00:00
|
|
|
|
2018-12-30 09:35:47 +00:00
|
|
|
if (trans_p != NULL && tbd_p != NULL && data != NULL) {
|
|
|
|
bzero(trans_p, sizeof(*trans_p));
|
|
|
|
bzero(tbd_p, sizeof(*tbd_p));
|
2000-04-08 01:22:14 +00:00
|
|
|
|
2018-12-30 09:35:47 +00:00
|
|
|
trans_p->TBD.segment = VTOPSEG(tbd_p);
|
|
|
|
trans_p->TBD.offset = VTOPOFF(tbd_p);
|
2017-05-06 20:32:27 +00:00
|
|
|
|
2018-12-30 09:35:47 +00:00
|
|
|
tbd_p->ImmedLength = len;
|
|
|
|
tbd_p->Xmit.segment = VTOPSEG(data);
|
|
|
|
tbd_p->Xmit.offset = VTOPOFF(data);
|
|
|
|
bcopy(pkt, data, len);
|
2017-05-06 20:32:27 +00:00
|
|
|
|
2018-12-30 09:35:47 +00:00
|
|
|
pxe_call(PXENV_UNDI_TRANSMIT, trans_p);
|
|
|
|
if (trans_p->Status == 0)
|
|
|
|
rv = len;
|
2000-04-19 11:22:38 +00:00
|
|
|
}
|
2017-05-06 20:32:27 +00:00
|
|
|
|
2018-12-30 09:35:47 +00:00
|
|
|
bio_free(data, len);
|
|
|
|
bio_free(tbd_p, sizeof(*tbd_p));
|
|
|
|
bio_free(trans_p, sizeof(*trans_p));
|
|
|
|
return (rv);
|
2000-03-28 01:19:53 +00:00
|
|
|
}
|