efidp_make_scsi(uint8_t *buf, ssize_t size, uint16_t target, uint16_t lun)
{
efidp_scsi *scsi = (efidp_scsi *)buf;
ssize_t req = sizeof (*scsi);
ssize_t sz = efidp_make_generic(buf, size, EFIDP_MESSAGE_TYPE,
EFIDP_MSG_SCSI, sizeof (*scsi));
if (size && sz == req) {
scsi->target = target;
scsi->lun = lun;
}
return sz;
}
efidp_make_pci(uint8_t *buf, ssize_t size, uint8_t device, uint8_t function)
{
efidp_pci *pci = (efidp_pci *)buf;
ssize_t sz;
ssize_t req = sizeof (*pci);
sz = efidp_make_generic(buf, size, EFIDP_HARDWARE_TYPE, EFIDP_HW_PCI,
req);
if (size && sz == req) {
pci->device = device;
pci->function = function;
}
return sz;
}
efidp_make_edd10(uint8_t *buf, ssize_t size, uint32_t hardware_device)
{
efi_guid_t edd10_guid = EDD10_HARDWARE_VENDOR_PATH_GUID;
efidp_edd10 *edd_dp = (efidp_edd10 *)buf;
ssize_t sz;
ssize_t req = sizeof (*edd_dp);
sz = efidp_make_generic(buf, size, EFIDP_HARDWARE_TYPE, EFIDP_HW_VENDOR,
req);
if (size && sz == req) {
memcpy(&edd_dp->vendor_guid, &edd10_guid, sizeof (edd10_guid));
edd_dp->hardware_device = hardware_device;
}
return sz;
}
efidp_make_mac_addr(uint8_t *buf, ssize_t size, uint8_t if_type,
const uint8_t * const mac_addr, ssize_t mac_addr_size)
{
efidp_mac_addr *mac = (efidp_mac_addr *)buf;
ssize_t sz = efidp_make_generic(buf, size, EFIDP_MESSAGE_TYPE,
EFIDP_MSG_MAC_ADDR, sizeof (*mac));
ssize_t req = sizeof (*mac);
if (size && sz == req) {
mac->if_type = if_type;
memcpy(mac->mac_addr, mac_addr,
mac_addr_size > 32 ? 32 : mac_addr_size);
}
return sz;
}
efidp_make_file(uint8_t *buf, ssize_t size, char *filepath)
{
efidp_file *file = (efidp_file *)buf;
unsigned char *lf = (unsigned char *)filepath;
ssize_t sz;
ssize_t len = utf8len(lf, -1) + 1;
ssize_t req = sizeof (*file) + len * sizeof (uint16_t);
sz = efidp_make_generic(buf, size, EFIDP_MEDIA_TYPE, EFIDP_MEDIA_FILE,
req);
if (size && sz == req) {
memset(buf+4, 0, req-4);
utf8_to_ucs2(file->name, req-4, 1, lf);
}
return sz;
}
efidp_make_atapi(uint8_t *buf, ssize_t size, uint16_t primary,
uint16_t slave, uint16_t lun)
{
efidp_atapi *atapi = (efidp_atapi *)buf;
ssize_t req = sizeof (*atapi);
ssize_t sz;
sz = efidp_make_generic(buf, size, EFIDP_MESSAGE_TYPE,
EFIDP_MSG_ATAPI, sizeof (*atapi));
if (size && sz == req) {
atapi->primary = primary;
atapi->slave = slave;
atapi->lun = lun;
}
return sz;
}
efidp_make_sata(uint8_t *buf, ssize_t size, uint16_t hba_port,
uint16_t port_multiplier_port, uint16_t lun)
{
efidp_sata *sata = (efidp_sata *)buf;
ssize_t req = sizeof (*sata);
ssize_t sz;
sz = efidp_make_generic(buf, size, EFIDP_MESSAGE_TYPE,
EFIDP_MSG_SATA, sizeof (*sata));
if (size && sz == req) {
sata->hba_port = hba_port;
sata->port_multiplier_port = port_multiplier_port;
sata->lun = lun;
}
return sz;
}
efidp_make_sas(uint8_t *buf, ssize_t size, uint64_t sas_address)
{
efidp_sas *sas = (efidp_sas *)buf;
ssize_t req = sizeof (*sas);
ssize_t sz;
sz = efidp_make_generic(buf, size, EFIDP_MESSAGE_TYPE,
EFIDP_MSG_VENDOR, sizeof (*sas));
if (size && sz == req) {
sas->vendor_guid = EFIDP_MSG_SAS_GUID;
sas->reserved = 0;
sas->sas_address = sas_address;
sas->lun = 0;
sas->device_topology_info = 0;
sas->drive_bay_id = 0;
sas->rtp = 0;
}
return sz;
}
efidp_make_nvme(uint8_t *buf, ssize_t size, uint32_t namespace_id,
uint8_t *ieee_eui_64)
{
efidp_nvme *nvme = (efidp_nvme *)buf;
ssize_t req = sizeof (*nvme);
ssize_t sz;
sz = efidp_make_generic(buf, size, EFIDP_MESSAGE_TYPE,
EFIDP_MSG_NVME, sizeof (*nvme));
if (size && sz == req) {
nvme->namespace_id = namespace_id;
if (ieee_eui_64)
memcpy(nvme->ieee_eui_64, ieee_eui_64,
sizeof (nvme->ieee_eui_64));
else
memset(nvme->ieee_eui_64, '\0',
sizeof (nvme->ieee_eui_64));
}
return sz;
}
efidp_make_hd(uint8_t *buf, ssize_t size, uint32_t num, uint64_t part_start,
uint64_t part_size, uint8_t *signature, uint8_t format,
uint8_t signature_type)
{
efidp_hd *hd = (efidp_hd *)buf;
ssize_t sz;
ssize_t req = sizeof (*hd);
sz = efidp_make_generic(buf, size, EFIDP_MEDIA_TYPE, EFIDP_MEDIA_HD,
req);
if (size && sz == req) {
hd->partition_number = num;
hd->start = part_start;
hd->size = part_size;
if (signature)
memcpy(hd->signature, signature,
sizeof (hd->signature));
hd->format = format;
hd->signature_type = signature_type;
}
return sz;
}
efidp_make_ipv4(uint8_t *buf, ssize_t size, uint32_t local, uint32_t remote,
uint32_t gateway, uint32_t netmask,
uint16_t local_port, uint16_t remote_port,
uint16_t protocol, int is_static)
{
efidp_ipv4_addr *ipv4 = (efidp_ipv4_addr *)buf;
ssize_t sz = efidp_make_generic(buf, size, EFIDP_MESSAGE_TYPE,
EFIDP_MSG_IPv4, sizeof (*ipv4));
ssize_t req = sizeof (*ipv4);
if (size && sz == req) {
*((char *)ipv4->local_ipv4_addr) = htonl(local);
*((char *)ipv4->remote_ipv4_addr) = htonl(remote);
ipv4->local_port = htons(local_port);
ipv4->remote_port = htons(remote_port);
ipv4->protocol = htons(protocol);
ipv4->static_ip_addr = 0;
if (is_static)
ipv4->static_ip_addr = 1;
*((char *)ipv4->gateway) = htonl(gateway);
*((char *)ipv4->netmask) = htonl(netmask);
}
return sz;
}
