[Feature] add GA346 baseline version
Change-Id: Ic62933698569507dcf98240cdf5d9931ae34348f
diff --git a/src/kernel/linux/v4.19/drivers/mtd/gptpart.c b/src/kernel/linux/v4.19/drivers/mtd/gptpart.c
new file mode 100644
index 0000000..9602dde
--- /dev/null
+++ b/src/kernel/linux/v4.19/drivers/mtd/gptpart.c
@@ -0,0 +1,383 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (c) 2019 MediaTek Inc.
+ * Author: Guochun Mao <guochun.mao@mediatek.com>
+ * Xiaolei Li <xiaolei.li@mediatek.com>
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/partitions.h>
+#include <asm/div64.h>
+
+/* GPT Signature should be 0x5452415020494645 */
+#define GPT_SIGNATURE_1 0x54524150U
+#define GPT_SIGNATURE_2 0x20494645U
+
+/* GPT Offsets */
+#define HEADER_SIZE_OFFSET 12
+#define HEADER_CRC_OFFSET 16
+#define PRIMARY_HEADER_OFFSET 24
+#define BACKUP_HEADER_OFFSET 32
+#define FIRST_USABLE_LBA_OFFSET 40
+#define LAST_USABLE_LBA_OFFSET 48
+#define PARTITION_ENTRIES_OFFSET 72
+#define PARTITION_COUNT_OFFSET 80
+#define PENTRY_SIZE_OFFSET 84
+#define PARTITION_CRC_OFFSET 88
+
+#define ENTRY_SIZE 0x80
+
+#define UNIQUE_GUID_OFFSET 16
+#define FIRST_LBA_OFFSET 32
+#define LAST_LBA_OFFSET 40
+#define ATTRIBUTE_FLAG_OFFSET 48
+#define PARTITION_NAME_OFFSET 56
+
+#define MAX_GPT_NAME_SIZE 72
+#define PARTITION_TYPE_GUID_SIZE 16
+#define UNIQUE_PARTITION_GUID_SIZE 16
+#define NUM_PARTITIONS 128
+
+#define GET_LWORD_FROM_BYTE(ptr) (*(uint32_t *)((unsigned long)(ptr)))
+#define GET_LLWORD_FROM_BYTE(ptr) (*(uint64_t *)((unsigned long)(ptr)))
+
+struct chs {
+ uint8_t c;
+ uint8_t h;
+ uint8_t s;
+};
+
+struct mbr_part {
+ uint8_t status;
+ struct chs start;
+ uint8_t type;
+ struct chs end;
+ uint32_t lba_start;
+ uint32_t lba_length;
+};
+
+struct gpt_info {
+ uint64_t first_usable_lba;
+ uint64_t backup_header_lba;
+ uint32_t partition_entry_size;
+ uint32_t header_size;
+ uint32_t max_partition_count;
+};
+
+static int validate_mbr_partition(struct mtd_info *master,
+ const struct mbr_part *part)
+{
+ u32 lba_size, lba_number;
+ uint64_t temp;
+
+ if (mtd_type_is_nand(master) != 0)
+ lba_size = master->writesize;
+ else
+ lba_size = 512;
+
+ /* check for invalid types */
+ if ((int8_t)part->type == 0)
+ return -1;
+ /* check for invalid status */
+ if (part->status != (uint8_t)0x80 &&
+ part->status != (uint8_t)0x00)
+ return -1;
+
+ /* make sure the range fits within the device */
+ temp = (uint64_t)master->size;
+ do_div(temp, lba_size);
+ lba_number = temp;
+ if (part->lba_start >= lba_number)
+ return -1;
+ if ((part->lba_start + part->lba_length) > lba_number)
+ return -1;
+
+ return 0;
+}
+
+/*
+ * Parse the gpt header and get the required header fields
+ * Return 0 on valid signature
+ */
+static int partition_parse_gpt_header(unsigned char *buffer,
+ struct gpt_info *info)
+{
+ /* Check GPT Signature */
+ if (GET_LWORD_FROM_BYTE(&buffer[0]) != GPT_SIGNATURE_2 ||
+ GET_LWORD_FROM_BYTE(&buffer[4]) != GPT_SIGNATURE_1)
+ return 1;
+
+ info->header_size = GET_LWORD_FROM_BYTE(&buffer[HEADER_SIZE_OFFSET]);
+ info->backup_header_lba =
+ GET_LLWORD_FROM_BYTE(&buffer[BACKUP_HEADER_OFFSET]);
+ info->first_usable_lba =
+ GET_LLWORD_FROM_BYTE(&buffer[FIRST_USABLE_LBA_OFFSET]);
+ info->max_partition_count =
+ GET_LWORD_FROM_BYTE(&buffer[PARTITION_COUNT_OFFSET]);
+ info->partition_entry_size =
+ GET_LWORD_FROM_BYTE(&buffer[PENTRY_SIZE_OFFSET]);
+
+ return 0;
+}
+
+static void gpt_add_part(struct mtd_partition *part, char *name,
+ u64 offset, uint32_t mask_flags, uint64_t size)
+{
+ part->name = name;
+ part->offset = offset;
+ part->mask_flags = mask_flags;
+ part->size = size;
+}
+
+#define BBT_RESERVED_BLOCK 4
+#define SGPT_RESERVED_BLOCK 4
+#define PGPT_RESERVED_BLOCK 2
+/*
+ * @master: master mtd device description object pointer
+ * @ofs: the start address
+ */
+static int find_next_good_gpt_block(struct mtd_info *master, loff_t *ofs)
+{
+ loff_t addr = *ofs;
+ u32 count;
+ /* the block search order. 0: forward; otherwise: backward */
+ int order;
+ int i = 0;
+
+ /* PGPT start from address 0 */
+ if (addr < master->erasesize) {
+ count = PGPT_RESERVED_BLOCK;
+ order = 0;
+ } else {
+ count = SGPT_RESERVED_BLOCK;
+ order = 1;
+ }
+ while (i < count) {
+ if (!mtd_block_isbad(master, addr)) {
+ if (i)
+ dev_err(&master->dev, "GPT: map from 0x%llx to 0x%llx\n",
+ *ofs, addr);
+ *ofs = addr;
+ return 0;
+ }
+ addr = order ? (addr - master->erasesize) :
+ (addr + master->erasesize);
+ i++;
+ }
+
+ dev_err(&master->dev,
+ "all bad blocks are bad, addr:0x%llx, count:%d\n",
+ addr, count);
+
+ return -ENOMEM;
+}
+
+static int mtd_read_gpt(struct mtd_info *master, loff_t from, size_t len,
+ size_t *retlen, u_char *buf)
+{
+ loff_t addr = from;
+ int ret;
+
+ if (mtd_type_is_nand(master) != 0) {
+ ret = find_next_good_gpt_block(master, &addr);
+ if (ret)
+ return ret;
+ }
+
+ return mtd_read(master, addr, len, retlen, buf);
+}
+
+static int gpt_parse(struct mtd_info *master,
+ const struct mtd_partition **pparts,
+ struct mtd_part_parser_data *data)
+{
+ struct mtd_partition *parts;
+ int curr_part = 0;
+ int err;
+ u_char *buf, *temp_buf;
+ size_t bytes_read = 0;
+ int i, j, n, part_entry_cnt, gpt_entries;
+ int gpt_partitions_exist = 0;
+ struct mbr_part part[4];
+ struct gpt_info gptinfo = {0, 0, 0, 0, 0};
+ loff_t partition_0, sgpt_addr = master->size;
+ u32 lba_size;
+ int tmp;
+
+ dev_dbg(&master->dev, "GPT: enter gpt parser...\n");
+
+ if (mtd_type_is_nand(master) != 0) {
+ lba_size = master->writesize;
+ sgpt_addr -= BBT_RESERVED_BLOCK * master->erasesize;
+ } else {
+ lba_size = 512;
+ sgpt_addr -= lba_size;
+ }
+
+ buf = kzalloc(lba_size, GFP_KERNEL);
+ if (buf == NULL)
+ return -ENOMEM;
+
+ err = mtd_read_gpt(master, 0, lba_size, &bytes_read, buf);
+ if (err < 0)
+ goto freebuf;
+
+ /* look for the aa55 tag */
+ if (buf[510] != (u_char)0x55 || buf[511] != (u_char)0xaa) {
+ dev_err(&master->dev, "GPT: not find aa55 @ 510,511\n");
+ goto freebuf;
+ }
+
+ /* see if a partition table makes sense here */
+ temp_buf = (u_char *)&part[0];
+ memcpy(temp_buf, &buf[446], sizeof(part));
+
+ /* validate each of the partition entries */
+ for (i = 0; i < 4; i++) {
+ if (validate_mbr_partition(master, &part[i]) >= 0) {
+ /*
+ * Type 0xEE indicates end of MBR
+ * and GPT partitions exist
+ */
+ if (part[i].type == (uint8_t)0xee) {
+ gpt_partitions_exist = 1;
+ break;
+ }
+ }
+ }
+
+ if (gpt_partitions_exist == 0) {
+ dev_err(&master->dev, "GPT: not find GPT\n");
+ goto freebuf;
+ }
+
+ err = mtd_read_gpt(master, (loff_t)lba_size, lba_size, &bytes_read,
+ buf);
+ if (err < 0)
+ goto freebuf;
+
+ err = partition_parse_gpt_header(buf, &gptinfo);
+ if (err != 0) {
+ dev_warn(&master->dev, "GPT: Read GPT header fail, try to check the backup gpt.\n");
+ err = mtd_read(master, sgpt_addr - (loff_t)lba_size,
+ lba_size, &bytes_read, buf);
+ if (err < 0) {
+ dev_err(&master->dev, "GPT: Could not read backup gpt.\n");
+ goto freebuf;
+ }
+
+ err = partition_parse_gpt_header(buf, &gptinfo);
+ if (err != 0) {
+ dev_err(&master->dev, "GPT: Primary and backup signatures invalid.\n");
+ goto freebuf;
+ }
+ }
+
+ parts = kcalloc(gptinfo.max_partition_count,
+ sizeof(struct mtd_partition), GFP_KERNEL);
+ if (parts == NULL)
+ goto freebuf;
+
+ part_entry_cnt = (int)lba_size / ENTRY_SIZE;
+ partition_0 =
+ (loff_t)GET_LLWORD_FROM_BYTE(&buf[PARTITION_ENTRIES_OFFSET]);
+
+ /* Read GPT Entries */
+ gpt_entries = roundup((int)gptinfo.max_partition_count, part_entry_cnt);
+ gpt_entries /= part_entry_cnt;
+ for (i = 0; i < gpt_entries; i++) {
+ err = mtd_read_gpt(master,
+ ((partition_0 + (loff_t)i) * (loff_t)lba_size),
+ lba_size, &bytes_read, buf);
+ if (err < 0) {
+ dev_err(&master->dev, "GPT: read failed reading partition entries.\n");
+ goto freeparts;
+ }
+
+ for (j = 0; j < part_entry_cnt; j++) {
+ int8_t type_guid[PARTITION_TYPE_GUID_SIZE];
+ char *name = kzalloc(MAX_GPT_NAME_SIZE,
+ GFP_KERNEL);
+ char UTF16_name[MAX_GPT_NAME_SIZE];
+ uint64_t first_lba, last_lba, size;
+
+ temp_buf = (u_char *)&type_guid[0];
+ memcpy(temp_buf,
+ &buf[(u32)j * gptinfo.partition_entry_size],
+ PARTITION_TYPE_GUID_SIZE);
+ if (type_guid[0] == 0 && type_guid[1] == 0) {
+ kfree(name);
+ goto parsedone;
+ }
+
+ tmp = j * (int)gptinfo.partition_entry_size;
+ tmp += FIRST_LBA_OFFSET;
+ first_lba = GET_LLWORD_FROM_BYTE(&buf[tmp]);
+ tmp = j * (int)gptinfo.partition_entry_size;
+ tmp += LAST_LBA_OFFSET;
+ last_lba = GET_LLWORD_FROM_BYTE(&buf[tmp]);
+ size = last_lba - first_lba + 1ULL;
+
+ memset(&UTF16_name[0], 0x00, MAX_GPT_NAME_SIZE);
+ temp_buf = (u_char *)&UTF16_name[0];
+ memcpy(temp_buf,
+ &buf[(u32)j * gptinfo.partition_entry_size +
+ (uint32_t)PARTITION_NAME_OFFSET],
+ MAX_GPT_NAME_SIZE);
+
+ /*
+ * Currently partition names in *.xml are UTF-8 and
+ * lowercase only supporting english for now so removing
+ * 2nd byte of UTF-16
+ */
+ for (n = 0; n < MAX_GPT_NAME_SIZE / 2; n++)
+ name[n] = UTF16_name[n * 2];
+
+ dev_dbg(&master->dev, "partition(%s) first_lba(%llu), last_lba(%llu), size(%llu)\n",
+ name, first_lba, last_lba, size);
+
+ gpt_add_part(&parts[curr_part++], name,
+ first_lba * lba_size, 0,
+ (last_lba - first_lba + 1ULL) * lba_size);
+
+ dev_dbg(&master->dev, "gpt there are <%d> parititons.\n",
+ curr_part);
+ }
+ }
+
+parsedone:
+ *pparts = parts;
+ kfree(buf);
+ return curr_part;
+
+freeparts:
+ kfree(parts);
+freebuf:
+ kfree(buf);
+ return 0;
+};
+
+static struct mtd_part_parser gpt_parser = {
+ .owner = THIS_MODULE,
+ .parse_fn = gpt_parse,
+ .name = "gptpart",
+};
+
+static int __init gptpart_init(void)
+{
+ return register_mtd_parser(&gpt_parser);
+}
+
+static void __exit gptpart_exit(void)
+{
+ deregister_mtd_parser(&gpt_parser);
+}
+
+module_init(gptpart_init);
+module_exit(gptpart_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("GPT partitioning for flash memories");