bcm47xxpart.c

Go to the documentation of this file.

/*
 * BCM47XX MTD partitioning
 *
 * Copyright © 2012 Rafał Miłecki <[email protected]>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/partitions.h>
#include <asm/mach-bcm47xx/nvram.h>

/* 10 parts were found on sflash on Netgear WNDR4500 */
#define BCM47XXPART_MAX_PARTS       12

/*
 * Amount of bytes we read when analyzing each block of flash memory.
 * Set it big enough to allow detecting partition and reading important data.
 */
#define BCM47XXPART_BYTES_TO_READ   0x404

/* Magics */
#define BOARD_DATA_MAGIC        0x5246504D  /* MPFR */
#define POT_MAGIC1          0x54544f50  /* POTT */
#define POT_MAGIC2          0x504f      /* OP */
#define ML_MAGIC1           0x39685a42
#define ML_MAGIC2           0x26594131
#define TRX_MAGIC           0x30524448

struct trx_header {
    uint32_t magic;
    uint32_t length;
    uint32_t crc32;
    uint16_t flags;
    uint16_t version;
    uint32_t offset[3];
} __packed;

static void bcm47xxpart_add_part(struct mtd_partition *part, char *name,
                 u64 offset, uint32_t mask_flags)
{
    part->name = name;
    part->offset = offset;
    part->mask_flags = mask_flags;
}

static int bcm47xxpart_parse(struct mtd_info *master,
                 struct mtd_partition **pparts,
                 struct mtd_part_parser_data *data)
{
    struct mtd_partition *parts;
    uint8_t i, curr_part = 0;
    uint32_t *buf;
    size_t bytes_read;
    uint32_t offset;
    uint32_t blocksize = 0x10000;
    struct trx_header *trx;

    /* Alloc */
    parts = kzalloc(sizeof(struct mtd_partition) * BCM47XXPART_MAX_PARTS,
            GFP_KERNEL);
    buf = kzalloc(BCM47XXPART_BYTES_TO_READ, GFP_KERNEL);

    /* Parse block by block looking for magics */
    for (offset = 0; offset <= master->size - blocksize;
         offset += blocksize) {
        /* Nothing more in higher memory */
        if (offset >= 0x2000000)
            break;

        if (curr_part > BCM47XXPART_MAX_PARTS) {
            pr_warn("Reached maximum number of partitions, scanning stopped!\n");
            break;
        }

        /* Read beginning of the block */
        if (mtd_read(master, offset, BCM47XXPART_BYTES_TO_READ,
                 &bytes_read, (uint8_t *)buf) < 0) {
            pr_err("mtd_read error while parsing (offset: 0x%X)!\n",
                   offset);
            continue;
        }

        /* CFE has small NVRAM at 0x400 */
        if (buf[0x400 / 4] == NVRAM_HEADER) {
            bcm47xxpart_add_part(&parts[curr_part++], "boot",
                         offset, MTD_WRITEABLE);
            continue;
        }

        /* Standard NVRAM */
        if (buf[0x000 / 4] == NVRAM_HEADER) {
            bcm47xxpart_add_part(&parts[curr_part++], "nvram",
                         offset, 0);
            continue;
        }

        /*
         * board_data starts with board_id which differs across boards,
         * but we can use 'MPFR' (hopefully) magic at 0x100
         */
        if (buf[0x100 / 4] == BOARD_DATA_MAGIC) {
            bcm47xxpart_add_part(&parts[curr_part++], "board_data",
                         offset, MTD_WRITEABLE);
            continue;
        }

        /* POT(TOP) */
        if (buf[0x000 / 4] == POT_MAGIC1 &&
            (buf[0x004 / 4] & 0xFFFF) == POT_MAGIC2) {
            bcm47xxpart_add_part(&parts[curr_part++], "POT", offset,
                         MTD_WRITEABLE);
            continue;
        }

        /* ML */
        if (buf[0x010 / 4] == ML_MAGIC1 &&
            buf[0x014 / 4] == ML_MAGIC2) {
            bcm47xxpart_add_part(&parts[curr_part++], "ML", offset,
                         MTD_WRITEABLE);
            continue;
        }

        /* TRX */
        if (buf[0x000 / 4] == TRX_MAGIC) {
            trx = (struct trx_header *)buf;

            i = 0;
            /* We have LZMA loader if offset[2] points to sth */
            if (trx->offset[2]) {
                bcm47xxpart_add_part(&parts[curr_part++],
                             "loader",
                             offset + trx->offset[i],
                             0);
                i++;
            }

            bcm47xxpart_add_part(&parts[curr_part++], "linux",
                         offset + trx->offset[i], 0);
            i++;

            /*
             * Pure rootfs size is known and can be calculated as:
             * trx->length - trx->offset[i]. We don't fill it as
             * we want to have jffs2 (overlay) in the same mtd.
             */
            bcm47xxpart_add_part(&parts[curr_part++], "rootfs",
                         offset + trx->offset[i], 0);
            i++;

            /*
             * We have whole TRX scanned, skip to the next part. Use
             * roundown (not roundup), as the loop will increase
             * offset in next step.
             */
            offset = rounddown(offset + trx->length, blocksize);
            continue;
        }
    }
    kfree(buf);

    /*
     * Assume that partitions end at the beginning of the one they are
     * followed by.
     */
    for (i = 0; i < curr_part - 1; i++)
        parts[i].size = parts[i + 1].offset - parts[i].offset;
    if (curr_part > 0)
        parts[curr_part - 1].size =
                master->size - parts[curr_part - 1].offset;

    *pparts = parts;
    return curr_part;
};

static struct mtd_part_parser bcm47xxpart_mtd_parser = {
    .owner = THIS_MODULE,
    .parse_fn = bcm47xxpart_parse,
    .name = "bcm47xxpart",
};

static int __init bcm47xxpart_init(void)
{
    return register_mtd_parser(&bcm47xxpart_mtd_parser);
}

static void __exit bcm47xxpart_exit(void)
{
    deregister_mtd_parser(&bcm47xxpart_mtd_parser);
}

module_init(bcm47xxpart_init);
module_exit(bcm47xxpart_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("MTD partitioning for BCM47XX flash memories");