[PATCH 1/2] efi: SPI NOR flash support

[Michael Lawnick]

Add EFI SPI NOR driver

Use UEFI interface for accessing SPI NOR flashes.
If supported the implementation of UEFI boot software abstracts
away all those ugly H/W details like SPI controller or protocol.
Provided functions:
grub_efi_spi_nor_
        init
        erase
        write
        read
        flash_size
        flash_id
        erase_block_size

This driver might be used for further abstraction to a common
(SPI) flash interface.

Signed-off-by: Michael Lawnick <michael.lawnick@nokia.com>
---
diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def
index 68b9e9f68..4d775e5f6 100644
--- a/grub-core/Makefile.core.def
+++ b/grub-core/Makefile.core.def
@@ -446,7 +446,7 @@ image = {
   i386_pc = boot/i386/pc/boot.S;

   cppflags = '-DHYBRID_BOOT=1';
-
+
   i386_pc_ldflags = '$(TARGET_IMG_LDFLAGS)';
   i386_pc_ldflags = '$(TARGET_IMG_BASE_LDOPT),0x7C00';

@@ -656,6 +656,12 @@ module = {
   enable = i386_multiboot;
 };

+module = {
+  name = efi_spi_nor;
+  common = bus/spi/efi_spi_nor.c;
+  enable = efi;
+};
+
 module = {
   name = nativedisk;
   common = commands/nativedisk.c;
diff --git a/grub-core/bus/spi/efi_spi_nor.c
b/grub-core/bus/spi/efi_spi_nor.c
new file mode 100644
index 000000000..0e073b436
--- /dev/null
+++ b/grub-core/bus/spi/efi_spi_nor.c
@@ -0,0 +1,298 @@
+/*  efi_spi_nor.c  - Give access to SPI NOR flash through UEFI interface.
+ *  Copyright 2021 Nokia
+ *  Licensed under the GNU General Public License v3.0 only
+ *  SPDX-License-Identifier: GPL-3.0-only
+ *
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008  Free Software Foundation, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include <grub/command.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+#include <grub/types.h>
+#include <grub/efi/api.h>
+#include <grub/efi/efi.h>
+#include <grub/efi/efi_spi_nor.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+#define EFI_SPI_NOR_FLASH_PROTOCOL_GUID \
+       { 0xb57ec3fe, 0xf833, 0x4ba6, \
+               {0x85, 0x78, 0x2a, 0x7d, 0x6a, 0x87, 0x44, 0x4b} \
+       }
+
+#define EFI_FLASHID_LEN 3
+
+struct efi_spi_nor_flash_protocol {
+       struct spi_nor  *spi_peripheral;
+       grub_efi_uint32_t       flash_size;
+       grub_efi_uint8_t        device_id[EFI_FLASHID_LEN];
+       grub_efi_uint32_t       erase_block_size;
+
+       grub_efi_status_t (* get_flash_id)(struct efi_spi_nor_flash_protocol
*this,
+                                            grub_uint8_t *buffer);
+       grub_efi_status_t (* read_data)(struct efi_spi_nor_flash_protocol *this,
+                                         grub_uint32_t offset, grub_uint32_t 
len, grub_uint8_t *data);
+       grub_efi_status_t (* lf_read_data)(struct efi_spi_nor_flash_protocol
*this,
+                                            grub_uint32_t offset, 
grub_uint32_t len, grub_uint8_t *data);
+       grub_efi_status_t (* write_data)(struct efi_spi_nor_flash_protocol 
*this,
+                                          grub_uint32_t offset, grub_uint32_t 
len, grub_uint8_t *data);
+       grub_efi_status_t (* read_status)(struct efi_spi_nor_flash_protocol 
*this,
+                                           grub_uint32_t num_bytes, 
grub_uint8_t *status);
+       grub_efi_status_t (* write_status)(struct efi_spi_nor_flash_protocol
*this,
+                                            grub_uint32_t num_bytes, 
grub_uint8_t *status);
+       grub_efi_status_t (* erase_blocks)(struct efi_spi_nor_flash_protocol
*this,
+                                            grub_uint32_t offset, 
grub_uint32_t blk_count);
+};
+
+/* grub_efi_spi_nor_init - initialize access to SPI NOR flash device
+ *
+ * Search pool of SPI NOR flash devices known to underlying EFI bootware.
+ * Use <flash_id> and <instance> to filter out devices.
+ *
+ * IN: flash_id     - optional, pointer to max 3 bytes
(EFI_FLASHID_LEN) to match against
+ *                    SPI flash JEDEC ID, use NULL if no filtering.
+ * IN: num_id_bytes - number of bytes in flash_id. Maximum 3 bytes
+ *                    are used for comparison.
+ * IN: instance     - number of device occurances to skip
+ *
+ * returns : pointer to flash device or NULL on failure
+ */
+void *
+grub_efi_spi_nor_init(grub_uint8_t *flash_id, grub_uint32_t
num_id_bytes, grub_uint32_t instance)
+{
+       grub_efi_guid_t efi_guid_spi_nor_flash_protocol =
EFI_SPI_NOR_FLASH_PROTOCOL_GUID;
+       grub_efi_status_t ret;
+       grub_efi_uintn_t num_handles;
+       grub_efi_handle_t *handles;
+       grub_uint8_t found_id[EFI_FLASHID_LEN];
+       grub_uint32_t idx, match_cnt=0;
+       struct efi_spi_nor_flash_protocol *spi_nor;
+
+       handles = grub_efi_locate_handle(GRUB_EFI_BY_PROTOCOL,
+                               &efi_guid_spi_nor_flash_protocol, 0,
+                               &num_handles);
+       grub_boot_time("found %ld SPI NOR flash devices\n", num_handles);
+
+       if ((num_handles == 0) || (num_handles < instance + 1))
+               return NULL;
+
+       for (idx = 0; idx < num_handles; idx++) {
+               spi_nor = grub_efi_open_protocol(handles[idx],
+                                               
&efi_guid_spi_nor_flash_protocol,
+                                               
GRUB_EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+               if (! spi_nor) {
+                       grub_error(GRUB_ERR_UNKNOWN_DEVICE, "Failed to open device 
protocol\n");
+                       grub_free(handles);
+                       return NULL;
+               }
+
+               ret = spi_nor->get_flash_id(spi_nor, found_id);
+               if (ret != GRUB_EFI_SUCCESS) {
+                       grub_error(GRUB_ERR_READ_ERROR, "Failed to read 
flash_id\n");
+                       grub_free(handles);
+                       return NULL;
+               }
+
+               /* if caller requests filtering by id */
+               if (flash_id != NULL) {
+                       grub_uint32_t id;
+
+                       if (num_id_bytes > EFI_FLASHID_LEN)
+                               num_id_bytes = EFI_FLASHID_LEN;
+
+                       for (id = 0; id < num_id_bytes; id++)
+                               if (flash_id[id] != found_id[id])
+                                       break;
+
+                       if (id != num_id_bytes)
+                               continue;
+               }
+
+               if (match_cnt < instance) {
+                       match_cnt++;
+                       continue;
+               }
+
+               grub_boot_time("Found flash with ID 0x%02x 0x%02x 0x%02x\n",
+                                               found_id[0], found_id[1], 
found_id[2]);
+
+               grub_free(handles);
+               return spi_nor;
+       }
+
+       grub_free(handles);
+       return NULL;
+}
+
+/* grub_efi_spi_nor_flash_size - get memory size of SPI NOR flash device
+ *
+ * IN: efi_flash_dev - device identifier returned by grub_efi_spi_nor_init.
+ *
+ * returns : memory size of flash device or 0 on failure
+ */
+grub_uint32_t
+grub_efi_spi_nor_flash_size(void *efi_flash_dev)
+{
+       struct efi_spi_nor_flash_protocol *spi_nor = efi_flash_dev;
+
+       if (spi_nor == NULL)
+               return 0;
+
+       return spi_nor->flash_size;
+}
+
+/* grub_efi_spi_nor_device_id - get three byte JEDEC ID of SPI NOR
flash device
+ *
+ * IN: efi_flash_dev - device identifier returned by grub_efi_spi_nor_init.
+ *
+ * returns : three byte JEDEC ID as a uint32 or 0 on failure
+ */
+grub_uint32_t
+grub_efi_spi_nor_device_id(void *efi_flash_dev)
+{
+       struct efi_spi_nor_flash_protocol *spi_nor = efi_flash_dev;
+       grub_uint32_t devId = 0;
+       grub_efi_status_t ret;
+       grub_uint8_t device_id[3];
+       int i;
+
+       if (spi_nor == NULL)
+               return 0;
+
+       ret = spi_nor->get_flash_id(spi_nor, device_id);
+       if (ret != GRUB_EFI_SUCCESS)
+               return 0;
+
+       for(i=0; i<3;i++)
+               devId = (devId<<8) + device_id[i];
+
+       return devId;
+}
+
+/* grub_efi_spi_nor_erase_block_size - get erase block size of SPI NOR
flash device
+ *
+ * Parameters for calls to grub_efi_spi_nor_erase() need to be erase
block size
+ * aligned.
+ *
+ * IN: efi_flash_dev - device identifier returned by grub_efi_spi_nor_init.
+ *
+ * returns : size of erase block of flash device or 0 on failure
+ */
+grub_uint32_t
+grub_efi_spi_nor_erase_block_size(void *efi_flash_dev)
+{
+       struct efi_spi_nor_flash_protocol *spi_nor = efi_flash_dev;
+
+       if (spi_nor == NULL)
+               return 0;
+
+       return spi_nor->erase_block_size;
+}
+
+/* grub_efi_spi_nor_read - read from SPI NOR flash device
+ *
+ * IN:  efi_flash_dev - device identifier returned by
grub_efi_spi_nor_init.
+ * OUT: buffer        - pointer to an preallocated buffer of min. bytes
size
+ * IN:  offset        - starting point where to start to read from
+ * IN:  bytes         - number of bytes to read from flash and write to
buffer
+ *
+ * returns : GRUB_EFI_SUCCESS if all ok
+ *           GRUB_EFI_INVALID_PARAMETER if an argument is bad
+ *
+ */
+grub_err_t
+grub_efi_spi_nor_read(void *efi_flash_dev, grub_uint8_t *buffer,
grub_uint32_t offset, grub_uint32_t bytes)
+{
+       struct efi_spi_nor_flash_protocol *spi_nor = efi_flash_dev;
+       grub_efi_status_t ret;
+
+       if (spi_nor == NULL || buffer == NULL)
+               return GRUB_ERR_BAD_ARGUMENT;
+
+       ret = (spi_nor->read_data(spi_nor, offset, bytes, buffer));
+       if (ret != GRUB_EFI_SUCCESS)
+               return grub_error(GRUB_ERR_READ_ERROR, "Failed to read data 
@0x%x\n",
offset);
+
+       return GRUB_ERR_NONE;
+}
+
+/* grub_efi_spi_nor_write - write to SPI NOR flash device
+ *
+ * IN: efi_flash_dev - device identifier returned by grub_efi_spi_nor_init.
+ * IN: buffer        - pointer to buffer containig min. bytes size data
to write
+ * IN: offset        - starting point where to start to write to
+ * IN: bytes         - number of bytes to write to buffer
+ *
+ * returns : GRUB_EFI_SUCCESS if all ok
+ *           GRUB_EFI_INVALID_PARAMETER if an argument is bad
+ *
+ */
+grub_err_t
+grub_efi_spi_nor_write(void *efi_flash_dev, grub_uint8_t *buffer,
grub_uint32_t offset, grub_uint32_t bytes)
+{
+       struct efi_spi_nor_flash_protocol *spi_nor = efi_flash_dev;
+       grub_efi_status_t ret;
+
+       if (spi_nor == NULL || buffer == NULL)
+               return GRUB_ERR_BAD_ARGUMENT;
+
+       ret = (spi_nor->write_data(spi_nor, offset, bytes, buffer));
+       if (ret != GRUB_EFI_SUCCESS)
+               return grub_error(GRUB_ERR_WRITE_ERROR, "Failed to write data
@0x%x\n", offset);
+
+       return GRUB_ERR_NONE;
+}
+
+/* grub_efi_spi_nor_erase - erase sectors on SPI NOR flash device
+ *
+ * Parameters offset and bytes need to be erase sector aligned, i.e.
+ * multiples of the size returned by function
grub_efi_spi_nor_erase_block_size()
+ *
+ * IN: efi_flash_dev - device identifier returned by grub_efi_spi_nor_init.
+ * IN: offset        - offset of first sector to erase
+ * IN: bytes         - length of region to erase
+ *
+ * returns : GRUB_EFI_SUCCESS if all ok
+ *           GRUB_EFI_INVALID_PARAMETER if an argument is bad
+ *
+ */
+grub_err_t
+grub_efi_spi_nor_erase(void *efi_flash_dev, grub_uint32_t offset,
grub_uint32_t bytes)
+{
+       struct efi_spi_nor_flash_protocol *spi_nor = efi_flash_dev;
+       grub_efi_status_t ret;
+       grub_uint32_t sect_sz;
+       grub_uint32_t sect_mask;
+
+       if (spi_nor == NULL || bytes == 0)
+               return GRUB_ERR_BAD_ARGUMENT;
+
+       sect_sz = grub_efi_spi_nor_erase_block_size(spi_nor);
+       sect_mask = sect_sz - 1;
+       if ((offset & sect_mask) != 0)
+               return grub_error(GRUB_ERR_BAD_ARGUMENT, "SPI NOR erase offset 
not at
sector boundary");
+
+       if (((offset + bytes) & sect_mask) != 0)
+               return grub_error(GRUB_ERR_BAD_ARGUMENT, "SPI NOR erase end not 
at
sector boundary");
+
+       ret = spi_nor->erase_blocks(spi_nor, offset, (bytes-1) / sect_sz + 1);
+
+       if (ret != GRUB_EFI_SUCCESS)
+               return grub_error(GRUB_ERR_WRITE_ERROR, "SPI NOR erase operation
failed");
+
+       return GRUB_ERR_NONE;
+}
diff --git a/include/grub/efi/efi_spi_nor.h b/include/grub/efi/efi_spi_nor.h
new file mode 100644
index 000000000..d09f0c9b7
--- /dev/null
+++ b/include/grub/efi/efi_spi_nor.h
@@ -0,0 +1,37 @@
+/*  efi_spi_nor.h  - Give access to SPI NOR flash through UEFI interface.
+ *  Copyright 2021 Nokia
+ *  Licensed under the GNU General Public License v3.0 only
+ *  SPDX-License-Identifier: GPL-3.0-only
+ *
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008  Free Software Foundation, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef GRUB_EFI_SPI_NOR_HEADER
+#define GRUB_EFI_SPI_NOR_HEADER
+
+#include <grub/types.h>
+
+void *grub_efi_spi_nor_init(grub_uint8_t *flash_id, grub_uint32_t
num_id_bytes, grub_uint32_t instance);
+
+grub_uint32_t grub_efi_spi_nor_flash_size(void *efi_flash_dev);
+grub_uint32_t grub_efi_spi_nor_device_id(void *efi_flash_dev);
+grub_uint32_t grub_efi_spi_nor_erase_block_size(void *efi_flash_dev);
+
+grub_err_t grub_efi_spi_nor_read(void *efi_flash_dev, grub_uint8_t
*buffer, grub_uint32_t offset, grub_uint32_t bytes);
+grub_err_t grub_efi_spi_nor_write(void *efi_flash_dev, grub_uint8_t
*buffer, grub_uint32_t offset, grub_uint32_t bytes);
+grub_err_t grub_efi_spi_nor_erase(void *efi_flash_dev, grub_uint32_t
offset, grub_uint32_t bytes);
+
+#endif /*GRUB_EFISPINOR*/