You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
266 lines
8.0 KiB
C
266 lines
8.0 KiB
C
/*
|
|
* Infineon/ADMTek ADM8668 (WildPass) partition parser support
|
|
*
|
|
* Copyright (C) 2010 Scott Nicholas <neutronscott@scottn.us>
|
|
* Copyright (C) 2012 Florian Fainelli <florian@openwrt.org>
|
|
*
|
|
* original functions for finding root filesystem from Mike Baker
|
|
*
|
|
* This program 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 2 of the License, or (at your
|
|
* option) any later version.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
|
|
* NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
|
|
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
|
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*
|
|
*
|
|
* Copyright 2004, Broadcom Corporation
|
|
* All Rights Reserved.
|
|
*
|
|
* THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
|
|
* KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
|
|
* SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
|
|
* FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/types.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/wait.h>
|
|
#include <linux/mtd/mtd.h>
|
|
#include <linux/mtd/partitions.h>
|
|
#include <linux/vmalloc.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/crc32.h>
|
|
#include <linux/magic.h>
|
|
|
|
#define PFX "adm8668-part: "
|
|
|
|
/* first a little bit about the headers i need.. */
|
|
|
|
/* just interested in part of the full struct */
|
|
struct squashfs_super_block {
|
|
__le32 s_magic;
|
|
__le32 pad0[9]; /* it's not really padding */
|
|
__le64 bytes_used;
|
|
};
|
|
|
|
#define IH_MAGIC 0x56190527 /* Image Magic Number */
|
|
struct uboot_header {
|
|
uint32_t ih_magic; /* Image Header Magic Number */
|
|
uint32_t ih_hcrc; /* Image Header CRC Checksum */
|
|
uint32_t ih_time; /* Image Creation Timestamp */
|
|
uint32_t ih_size; /* Image Data Size */
|
|
uint32_t ih_load; /* Data Load Address */
|
|
uint32_t ih_ep; /* Entry Point Address */
|
|
uint32_t ih_dcrc; /* Image Data CRC Checksum */
|
|
uint8_t ih_os; /* Operating System */
|
|
uint8_t ih_arch; /* CPU architecture */
|
|
uint8_t ih_type; /* Image Type */
|
|
uint8_t ih_comp; /* Compression Type */
|
|
char ih_name[32]; /* image name */
|
|
};
|
|
|
|
/* in case i wanna change stuff later, and to clarify the math section... */
|
|
#define PART_LINUX 0
|
|
#define PART_ROOTFS 1
|
|
#define PART_UBOOT_ENV 2
|
|
#define NR_PARTS 3
|
|
|
|
static int adm8668_parse_partitions(struct mtd_info *master,
|
|
struct mtd_partition **pparts,
|
|
struct mtd_part_parser_data *data)
|
|
{
|
|
int ret;
|
|
struct uboot_header uhdr;
|
|
int off, blocksize;
|
|
size_t len, linux_len;
|
|
struct squashfs_super_block shdr;
|
|
struct erase_info erase_info;
|
|
struct mtd_partition *adm8668_parts;
|
|
|
|
memset(&erase_info, 0, sizeof(erase_info));
|
|
|
|
blocksize = master->erasesize;
|
|
|
|
if (blocksize < 0x10000)
|
|
blocksize = 0x10000;
|
|
|
|
adm8668_parts = kzalloc(sizeof(*adm8668_parts) * NR_PARTS, GFP_KERNEL);
|
|
if (!adm8668_parts)
|
|
return -ENOMEM;
|
|
|
|
adm8668_parts[PART_LINUX].name = kstrdup("linux", GFP_KERNEL);
|
|
adm8668_parts[PART_LINUX].offset = 0x40000;
|
|
adm8668_parts[PART_LINUX].size = master->size - 0x40000;
|
|
adm8668_parts[PART_ROOTFS].name = kstrdup("rootfs", GFP_KERNEL);
|
|
adm8668_parts[PART_ROOTFS].offset = 0xe0000;
|
|
adm8668_parts[PART_ROOTFS].size = 0x140000;
|
|
adm8668_parts[PART_UBOOT_ENV].name = kstrdup("uboot_env", GFP_KERNEL);
|
|
adm8668_parts[PART_UBOOT_ENV].offset = 0x20000;
|
|
adm8668_parts[PART_UBOOT_ENV].size = 0x20000;
|
|
|
|
/* now find squashfs */
|
|
memset(&shdr, 0xe5, sizeof(shdr));
|
|
|
|
for (off = 0x40000; off < master->size; off += blocksize) {
|
|
/*
|
|
* Read into buffer
|
|
*/
|
|
if (mtd_read(master, off, sizeof(shdr), &len, (char *)&shdr) ||
|
|
len != sizeof(shdr))
|
|
continue;
|
|
|
|
if (shdr.s_magic == SQUASHFS_MAGIC) {
|
|
uint32_t fs_size = (uint32_t)shdr.bytes_used;
|
|
|
|
pr_info(PFX "filesystem type: squashfs, size=%dkB\n",
|
|
fs_size >> 10);
|
|
|
|
/*
|
|
* Update rootfs based on the superblock info, and
|
|
* stretch to end of MTD. rootfs_split will split it
|
|
*/
|
|
adm8668_parts[PART_ROOTFS].offset = off;
|
|
adm8668_parts[PART_ROOTFS].size = master->size -
|
|
adm8668_parts[PART_ROOTFS].offset;
|
|
|
|
/*
|
|
* kernel ends where rootfs starts
|
|
* but we'll keep it full-length for upgrades
|
|
*/
|
|
linux_len = adm8668_parts[PART_LINUX + 1].offset -
|
|
adm8668_parts[PART_LINUX].offset;
|
|
|
|
adm8668_parts[PART_LINUX].size = master->size -
|
|
adm8668_parts[PART_LINUX].offset;
|
|
goto found;
|
|
}
|
|
}
|
|
|
|
pr_err(PFX "could't find root filesystem\n");
|
|
return NR_PARTS;
|
|
|
|
found:
|
|
if (mtd_read(master, adm8668_parts[PART_LINUX].offset, sizeof(uhdr), &len, (char *)&uhdr) ||
|
|
len != sizeof(uhdr)) {
|
|
pr_err(PFX "failed to read u-boot header\n");
|
|
return NR_PARTS;
|
|
}
|
|
|
|
if (uhdr.ih_magic != IH_MAGIC) {
|
|
pr_info(PFX "invalid u-boot magic detected?!?!\n");
|
|
return NR_PARTS;
|
|
}
|
|
|
|
if (be32_to_cpu(uhdr.ih_size) != (linux_len - sizeof(uhdr))) {
|
|
u32 data;
|
|
size_t data_len = 0;
|
|
unsigned char *block;
|
|
unsigned int offset;
|
|
|
|
offset = adm8668_parts[PART_LINUX].offset +
|
|
sizeof(struct uboot_header);
|
|
|
|
pr_info(PFX "Updating U-boot image:\n");
|
|
pr_info(PFX " old: [size: %8d crc32: 0x%08x]\n",
|
|
be32_to_cpu(uhdr.ih_size), be32_to_cpu(uhdr.ih_dcrc));
|
|
|
|
if (mtd_read(master, offset, sizeof(data), &data_len, (char *)&data)) {
|
|
pr_err(PFX "failed to read data\n");
|
|
goto out;
|
|
}
|
|
|
|
/* Update the data length & crc32 */
|
|
uhdr.ih_size = cpu_to_be32(linux_len - sizeof(uhdr));
|
|
uhdr.ih_dcrc = crc32_le(~0, (char *)&data, linux_len - sizeof(uhdr)) ^ (~0);
|
|
uhdr.ih_dcrc = cpu_to_be32(uhdr.ih_dcrc);
|
|
|
|
pr_info(PFX " new: [size: %8d crc32: 0x%08x]\n",
|
|
be32_to_cpu(uhdr.ih_size), be32_to_cpu(uhdr.ih_dcrc));
|
|
|
|
/* update header's crc... */
|
|
uhdr.ih_hcrc = 0;
|
|
uhdr.ih_hcrc = crc32_le(~0, (unsigned char *)&uhdr,
|
|
sizeof(uhdr)) ^ (~0);
|
|
uhdr.ih_hcrc = cpu_to_be32(uhdr.ih_hcrc);
|
|
|
|
/* read first eraseblock from the image */
|
|
block = vmalloc(master->erasesize);
|
|
if (!block)
|
|
return -ENOMEM;
|
|
|
|
if (mtd_read(master, adm8668_parts[PART_LINUX].offset, master->erasesize, &len, block)
|
|
|| len != master->erasesize) {
|
|
pr_err(PFX "error copying first eraseblock\n");
|
|
return 0;
|
|
}
|
|
|
|
/* Write updated header to the flash */
|
|
memcpy(block, &uhdr, sizeof(uhdr));
|
|
if (master->unlock)
|
|
master->unlock(master, off, master->erasesize);
|
|
|
|
erase_info.mtd = master;
|
|
erase_info.addr = (uint64_t)adm8668_parts[PART_LINUX].offset;
|
|
erase_info.len = master->erasesize;
|
|
ret = mtd_erase(master, &erase_info);
|
|
if (!ret) {
|
|
if (mtd_write(master, adm8668_parts[PART_LINUX].offset, master->erasesize,
|
|
&len, block))
|
|
pr_err(PFX "write failed");
|
|
} else
|
|
pr_err(PFX "erase failed");
|
|
|
|
mtd_sync(master);
|
|
out:
|
|
if (block)
|
|
vfree(block);
|
|
pr_info(PFX "done\n");
|
|
}
|
|
|
|
*pparts = adm8668_parts;
|
|
|
|
return NR_PARTS;
|
|
}
|
|
|
|
static struct mtd_part_parser adm8668_parser = {
|
|
.owner = THIS_MODULE,
|
|
.parse_fn = adm8668_parse_partitions,
|
|
.name = "adm8668part",
|
|
};
|
|
|
|
static int __init adm8668_parser_init(void)
|
|
{
|
|
register_mtd_parser(&adm8668_parser);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void __exit adm8668_parser_exit(void)
|
|
{
|
|
deregister_mtd_parser(&adm8668_parser);
|
|
}
|
|
|
|
module_init(adm8668_parser_init);
|
|
module_exit(adm8668_parser_exit);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_AUTHOR("Scott Nicholas <neutronscott@scottn.us>");
|
|
MODULE_AUTHOR("Florian Fainelli <florian@openwrt.org>");
|
|
MODULE_DESCRIPTION("MTD partition parser for ADM8668");
|