/* SPDX-License-Identifier: GPL-2.0 */
|
#include <linux/kernel.h>
|
#include <linux/slab.h>
|
#include <linux/bootmem.h>
|
#include "check.h"
|
#include "rk.h"
|
|
/* rkpart_setup() parses into here */
|
static struct cmdline_rk_partition *partitions;
|
/* the command line passed to mtdpart_setupd() */
|
static char *cmdline;
|
static int cmdline_parsed;
|
|
/*
|
* Parse one partition definition for an rkpart. Since there can be many
|
* comma separated partition definitions, this function calls itself
|
* recursively until no more partition definitions are found. Nice side
|
* effect: the memory to keep the rk_partition structs and the names
|
* is allocated upon the last definition being found. At that point the
|
* syntax has been verified ok.
|
*/
|
static struct rk_partition *newpart(char *s,
|
char **retptr,
|
int *num_parts,
|
int this_part,
|
unsigned char **extra_mem_ptr,
|
int extra_mem_size)
|
{
|
struct rk_partition *parts;
|
sector_t size;
|
sector_t from = OFFSET_CONTINUOUS;
|
char *name;
|
int name_len;
|
unsigned char *extra_mem;
|
char delim;
|
|
/* fetch the partition size */
|
if (*s == '-')
|
{ /* assign all remaining space to this partition */
|
size = SIZE_REMAINING;
|
s++;
|
}
|
else
|
{
|
size = memparse(s, &s);
|
/* No sense support partition less than 8B */
|
if (size < ((PAGE_SIZE) >> 9))
|
{
|
printk(KERN_ERR ERRP "partition size too small (%llx)\n", (u64)size);
|
return NULL;
|
}
|
}
|
|
/* fetch partition name */
|
delim = 0;
|
/* check for from */
|
if (*s == '@')
|
{
|
s++;
|
from = memparse(s, &s);
|
}
|
/* now look for name */
|
if (*s == '(')
|
{
|
delim = ')';
|
}
|
|
if (delim)
|
{
|
char *p;
|
|
name = ++s;
|
p = strchr(name, delim);
|
if (!p)
|
{
|
printk(KERN_ERR ERRP "no closing %c found in partition name\n", delim);
|
return NULL;
|
}
|
name_len = p - name;
|
s = p + 1;
|
}
|
else
|
{
|
name = NULL;
|
name_len = 13; /* Partition_000 */
|
}
|
|
/* record name length for memory allocation later */
|
extra_mem_size += name_len + 1;
|
|
/* test if more partitions are following */
|
if (*s == ',')
|
{
|
if (size == SIZE_REMAINING)
|
{
|
printk(KERN_ERR ERRP "no partitions allowed after a fill-up partition\n");
|
return NULL;
|
}
|
/* more partitions follow, parse them */
|
parts = newpart(s + 1, &s, num_parts, this_part + 1,
|
&extra_mem, extra_mem_size);
|
if (!parts)
|
return NULL;
|
}
|
else
|
{ /* this is the last partition: allocate space for all */
|
int alloc_size;
|
|
*num_parts = this_part + 1;
|
alloc_size = *num_parts * sizeof(struct rk_partition) +
|
extra_mem_size;
|
parts = kzalloc(alloc_size, GFP_KERNEL);
|
if (!parts)
|
{
|
printk(KERN_ERR ERRP "out of memory\n");
|
return NULL;
|
}
|
extra_mem = (unsigned char *)(parts + *num_parts);
|
}
|
/* enter this partition (from will be calculated later if it is zero at this point) */
|
parts[this_part].size = size;
|
parts[this_part].from = from;
|
if (name)
|
{
|
strlcpy(extra_mem, name, name_len + 1);
|
}
|
else
|
{
|
sprintf(extra_mem, "Partition_%03d", this_part);
|
}
|
parts[this_part].name = extra_mem;
|
extra_mem += name_len + 1;
|
|
dbg(("partition %d: name <%s>, from %llx, size %llx\n",
|
this_part,
|
parts[this_part].name,
|
parts[this_part].from,
|
parts[this_part].size));
|
|
/* return (updated) pointer to extra_mem memory */
|
if (extra_mem_ptr)
|
*extra_mem_ptr = extra_mem;
|
|
/* return (updated) pointer command line string */
|
*retptr = s;
|
|
/* return partition table */
|
return parts;
|
}
|
|
/*
|
* Parse the command line.
|
*/
|
static int rkpart_setup_real(char *s)
|
{
|
cmdline_parsed = 1;
|
|
for( ; s != NULL; )
|
{
|
struct cmdline_rk_partition *this_rk;
|
struct rk_partition *parts;
|
int rk_id_len;
|
int num_parts;
|
char *p, *rk_id;
|
|
rk_id = s;
|
/* fetch <rk-id> */
|
if (!(p = strchr(s, ':')))
|
{
|
dbg(( "no rk-id\n"));
|
return 0;
|
}
|
rk_id_len = p - rk_id;
|
|
dbg(("parsing <%s>\n", p + 1));
|
|
/*
|
* parse one mtd. have it reserve memory for the
|
* struct cmdline_mtd_partition and the mtd-id string.
|
*/
|
parts = newpart(p + 1, /* cmdline */
|
&s, /* out: updated cmdline ptr */
|
&num_parts, /* out: number of parts */
|
0, /* first partition */
|
(unsigned char**)&this_rk, /* out: extra mem */
|
rk_id_len + 1 + sizeof(*this_rk) +
|
sizeof(void*)-1 /*alignment*/);
|
if(!parts)
|
{
|
/*
|
* An error occurred. We're either:
|
* a) out of memory, or
|
* b) in the middle of the partition spec
|
* Either way, this mtd is hosed and we're
|
* unlikely to succeed in parsing any more
|
*/
|
return 0;
|
}
|
|
/* align this_rk */
|
this_rk = (struct cmdline_rk_partition *)
|
ALIGN((unsigned long)this_rk, sizeof(void*));
|
/* enter results */
|
this_rk->parts = parts;
|
this_rk->num_parts = num_parts;
|
this_rk->rk_id = (char*)(this_rk + 1);
|
strlcpy(this_rk->rk_id, rk_id, rk_id_len + 1);
|
|
/* link into chain */
|
this_rk->next = partitions;
|
partitions = this_rk;
|
|
dbg(("rkid=<%s> num_parts=<%d>\n",
|
this_rk->mtd_id, this_rk->num_parts));
|
|
/* EOS - we're done */
|
if (*s == 0)
|
break;
|
s++;
|
}
|
return 1;
|
}
|
|
/*
|
* Main function to be called from the MTD mapping driver/device to
|
* obtain the partitioning information. At this point the command line
|
* arguments will actually be parsed and turned to struct mtd_partition
|
* information. It returns partitions for the requested mtd device, or
|
* the first one in the chain if a NULL mtd_id is passed in.
|
*/
|
static int parse_cmdline_partitions(sector_t n,
|
struct rk_partition **pparts,
|
unsigned long origin)
|
{
|
unsigned long from;
|
int i;
|
struct cmdline_rk_partition *part;
|
/* Fixme: parameter should be coherence with part table id */
|
const char *rk_id = "rk29xxnand";
|
|
/* parse command line */
|
if (!cmdline_parsed)
|
rkpart_setup_real(cmdline);
|
|
for(part = partitions; part; part = part->next)
|
{
|
if ((!rk_id) || (!strcmp(part->rk_id, rk_id)))
|
{
|
for(i = 0, from = 0; i < part->num_parts; i++)
|
{
|
if (part->parts[i].from == OFFSET_CONTINUOUS)
|
part->parts[i].from = from;
|
else
|
from = part->parts[i].from;
|
if (part->parts[i].size == SIZE_REMAINING)
|
part->parts[i].size = n - from - FROM_OFFSET;
|
if (from + part->parts[i].size > n)
|
{
|
printk(KERN_WARNING ERRP
|
"%s: partitioning exceeds flash size, truncating\n",
|
part->rk_id);
|
part->parts[i].size = n - from;
|
part->num_parts = i;
|
}
|
from += part->parts[i].size;
|
}
|
*pparts = kmemdup(part->parts,
|
sizeof(*part->parts) * part->num_parts,
|
GFP_KERNEL);
|
if (!*pparts)
|
return -ENOMEM;
|
return part->num_parts;
|
}
|
}
|
return 0;
|
}
|
|
static void rkpart_bootmode_fixup(void)
|
{
|
const char mode_emmc[] = " androidboot.mode=emmc";
|
const char mode_nvme[] = " androidboot.mode=nvme";
|
const char charger[] = " androidboot.charger.emmc=1";
|
char *new_command_line;
|
size_t saved_command_line_len = strlen(saved_command_line);
|
|
if (strstr(saved_command_line, "androidboot.mode=charger")) {
|
new_command_line = kzalloc(saved_command_line_len +
|
strlen(charger) + 1, GFP_KERNEL);
|
sprintf(new_command_line, "%s%s",
|
saved_command_line, charger);
|
} else {
|
new_command_line = kzalloc(saved_command_line_len +
|
strlen(mode_emmc) + 1, GFP_KERNEL);
|
if (strstr(saved_command_line, "storagemedia=nvme"))
|
sprintf(new_command_line, "%s%s",
|
saved_command_line, mode_nvme);
|
else
|
sprintf(new_command_line, "%s%s",
|
saved_command_line, mode_emmc);
|
}
|
saved_command_line = new_command_line;
|
}
|
|
int rkpart_partition(struct parsed_partitions *state)
|
{
|
int num_parts = 0, i;
|
sector_t n = get_capacity(state->bdev->bd_disk);
|
struct rk_partition *parts = NULL;
|
|
if (n < SECTOR_1G)
|
return 0;
|
|
if (!state->bdev->bd_disk->is_rk_disk)
|
return 0;
|
|
/* Fixme: parameter should be coherence with part table */
|
cmdline = strstr(saved_command_line, "mtdparts=");
|
if (!cmdline)
|
return 0;
|
cmdline += 9;
|
cmdline_parsed = 0;
|
|
num_parts = parse_cmdline_partitions(n, &parts, 0);
|
if (num_parts < 0)
|
return num_parts;
|
|
for (i = 0; i < num_parts; i++) {
|
put_partition( state,
|
i+1,
|
parts[i].from + FROM_OFFSET,
|
parts[i].size);
|
strcpy(state->parts[i+1].info.volname, parts[i].name);
|
printk(KERN_INFO "%10s: 0x%09llx -- 0x%09llx (%llu MB)\n",
|
parts[i].name,
|
(u64)parts[i].from * 512,
|
(u64)(parts[i].from + parts[i].size) * 512,
|
(u64)parts[i].size / 2048);
|
}
|
|
rkpart_bootmode_fixup();
|
|
return 1;
|
}
|
