1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Qualcomm SMEM NAND flash partition parser 4 * 5 * Copyright (C) 2020, Linaro Ltd. 6 */ 7 8 #include <linux/ctype.h> 9 #include <linux/module.h> 10 #include <linux/mtd/mtd.h> 11 #include <linux/mtd/partitions.h> 12 #include <linux/slab.h> 13 #include <linux/soc/qcom/smem.h> 14 15 #define SMEM_AARM_PARTITION_TABLE 9 16 #define SMEM_APPS 0 17 18 #define SMEM_FLASH_PART_MAGIC1 0x55ee73aa 19 #define SMEM_FLASH_PART_MAGIC2 0xe35ebddb 20 #define SMEM_FLASH_PTABLE_V3 3 21 #define SMEM_FLASH_PTABLE_V4 4 22 #define SMEM_FLASH_PTABLE_MAX_PARTS_V3 16 23 #define SMEM_FLASH_PTABLE_MAX_PARTS_V4 48 24 #define SMEM_FLASH_PTABLE_HDR_LEN (4 * sizeof(u32)) 25 #define SMEM_FLASH_PTABLE_NAME_SIZE 16 26 27 /** 28 * struct smem_flash_pentry - SMEM Flash partition entry 29 * @name: Name of the partition 30 * @offset: Offset in blocks 31 * @length: Length of the partition in blocks 32 * @attr: Flags for this partition 33 */ 34 struct smem_flash_pentry { 35 char name[SMEM_FLASH_PTABLE_NAME_SIZE]; 36 __le32 offset; 37 __le32 length; 38 u8 attr; 39 } __packed __aligned(4); 40 41 /** 42 * struct smem_flash_ptable - SMEM Flash partition table 43 * @magic1: Partition table Magic 1 44 * @magic2: Partition table Magic 2 45 * @version: Partition table version 46 * @numparts: Number of partitions in this ptable 47 * @pentry: Flash partition entries belonging to this ptable 48 */ 49 struct smem_flash_ptable { 50 __le32 magic1; 51 __le32 magic2; 52 __le32 version; 53 __le32 numparts; 54 struct smem_flash_pentry pentry[SMEM_FLASH_PTABLE_MAX_PARTS_V4]; 55 } __packed __aligned(4); 56 57 static int parse_qcomsmem_part(struct mtd_info *mtd, 58 const struct mtd_partition **pparts, 59 struct mtd_part_parser_data *data) 60 { 61 size_t len = SMEM_FLASH_PTABLE_HDR_LEN; 62 int ret, i, j, tmpparts, numparts = 0; 63 struct smem_flash_pentry *pentry; 64 struct smem_flash_ptable *ptable; 65 struct mtd_partition *parts; 66 char *name, *c; 67 68 if (IS_ENABLED(CONFIG_MTD_SPI_NOR_USE_4K_SECTORS) 69 && mtd->type == MTD_NORFLASH) { 70 pr_err("%s: SMEM partition parser is incompatible with 4K sectors\n", 71 mtd->name); 72 return -EINVAL; 73 } 74 75 pr_debug("Parsing partition table info from SMEM\n"); 76 ptable = qcom_smem_get(SMEM_APPS, SMEM_AARM_PARTITION_TABLE, &len); 77 if (IS_ERR(ptable)) { 78 if (PTR_ERR(ptable) != -EPROBE_DEFER) 79 pr_err("Error reading partition table header\n"); 80 return PTR_ERR(ptable); 81 } 82 83 /* Verify ptable magic */ 84 if (le32_to_cpu(ptable->magic1) != SMEM_FLASH_PART_MAGIC1 || 85 le32_to_cpu(ptable->magic2) != SMEM_FLASH_PART_MAGIC2) { 86 pr_err("Partition table magic verification failed\n"); 87 return -EINVAL; 88 } 89 90 /* Ensure that # of partitions is less than the max we have allocated */ 91 tmpparts = le32_to_cpu(ptable->numparts); 92 if (tmpparts > SMEM_FLASH_PTABLE_MAX_PARTS_V4) { 93 pr_err("Partition numbers exceed the max limit\n"); 94 return -EINVAL; 95 } 96 97 /* Find out length of partition data based on table version */ 98 if (le32_to_cpu(ptable->version) <= SMEM_FLASH_PTABLE_V3) { 99 len = SMEM_FLASH_PTABLE_HDR_LEN + SMEM_FLASH_PTABLE_MAX_PARTS_V3 * 100 sizeof(struct smem_flash_pentry); 101 } else if (le32_to_cpu(ptable->version) == SMEM_FLASH_PTABLE_V4) { 102 len = SMEM_FLASH_PTABLE_HDR_LEN + SMEM_FLASH_PTABLE_MAX_PARTS_V4 * 103 sizeof(struct smem_flash_pentry); 104 } else { 105 pr_err("Unknown ptable version (%d)", le32_to_cpu(ptable->version)); 106 return -EINVAL; 107 } 108 109 /* 110 * Now that the partition table header has been parsed, verified 111 * and the length of the partition table calculated, read the 112 * complete partition table 113 */ 114 ptable = qcom_smem_get(SMEM_APPS, SMEM_AARM_PARTITION_TABLE, &len); 115 if (IS_ERR(ptable)) { 116 pr_err("Error reading partition table\n"); 117 return PTR_ERR(ptable); 118 } 119 120 for (i = 0; i < tmpparts; i++) { 121 pentry = &ptable->pentry[i]; 122 if (pentry->name[0] != '\0') 123 numparts++; 124 } 125 126 parts = kcalloc(numparts, sizeof(*parts), GFP_KERNEL); 127 if (!parts) 128 return -ENOMEM; 129 130 for (i = 0, j = 0; i < tmpparts; i++) { 131 pentry = &ptable->pentry[i]; 132 if (pentry->name[0] == '\0') 133 continue; 134 135 name = kstrdup(pentry->name, GFP_KERNEL); 136 if (!name) { 137 ret = -ENOMEM; 138 goto out_free_parts; 139 } 140 141 /* Convert name to lower case */ 142 for (c = name; *c != '\0'; c++) 143 *c = tolower(*c); 144 145 parts[j].name = name; 146 parts[j].offset = le32_to_cpu(pentry->offset) * mtd->erasesize; 147 parts[j].mask_flags = pentry->attr; 148 parts[j].size = le32_to_cpu(pentry->length) * mtd->erasesize; 149 pr_debug("%d: %s offs=0x%08x size=0x%08x attr:0x%08x\n", 150 i, pentry->name, le32_to_cpu(pentry->offset), 151 le32_to_cpu(pentry->length), pentry->attr); 152 j++; 153 } 154 155 pr_debug("SMEM partition table found: ver: %d len: %d\n", 156 le32_to_cpu(ptable->version), tmpparts); 157 *pparts = parts; 158 159 return numparts; 160 161 out_free_parts: 162 while (--j >= 0) 163 kfree(parts[j].name); 164 kfree(parts); 165 *pparts = NULL; 166 167 return ret; 168 } 169 170 static void parse_qcomsmem_cleanup(const struct mtd_partition *pparts, 171 int nr_parts) 172 { 173 int i; 174 175 for (i = 0; i < nr_parts; i++) 176 kfree(pparts[i].name); 177 178 kfree(pparts); 179 } 180 181 static const struct of_device_id qcomsmem_of_match_table[] = { 182 { .compatible = "qcom,smem-part" }, 183 {}, 184 }; 185 MODULE_DEVICE_TABLE(of, qcomsmem_of_match_table); 186 187 static struct mtd_part_parser mtd_parser_qcomsmem = { 188 .parse_fn = parse_qcomsmem_part, 189 .cleanup = parse_qcomsmem_cleanup, 190 .name = "qcomsmem", 191 .of_match_table = qcomsmem_of_match_table, 192 }; 193 module_mtd_part_parser(mtd_parser_qcomsmem); 194 195 MODULE_LICENSE("GPL v2"); 196 MODULE_AUTHOR("Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org>"); 197 MODULE_DESCRIPTION("Qualcomm SMEM NAND flash partition parser"); 198