From fb517c30085b57eb2c886a6dbb014f528c881760 Mon Sep 17 00:00:00 2001 From: rajkosto Date: Wed, 10 Nov 2010 15:21:42 +0100 Subject: [PATCH 01/10] nand driver cleanup and new yaffs version --- drivers/mtd/devices/htcleo_nand.c | 348 +- drivers/mtd/devices/msm_nand.c | 3 - fs/yaffs2/Makefile | 4 +- fs/yaffs2/devextras.h | 101 - fs/yaffs2/moduleconfig.h | 5 +- fs/yaffs2/yaffs_allocator.c | 340 +- fs/yaffs2/yaffs_allocator.h | 12 +- fs/yaffs2/yaffs_attribs.c | 124 + fs/yaffs2/{yaffs_qsort.h => yaffs_attribs.h} | 24 +- fs/yaffs2/yaffs_bitmap.c | 73 +- fs/yaffs2/yaffs_bitmap.h | 20 +- fs/yaffs2/yaffs_checkptrw.c | 450 +- fs/yaffs2/yaffs_checkptrw.h | 13 +- fs/yaffs2/yaffs_ecc.c | 85 +- fs/yaffs2/yaffs_ecc.h | 26 +- fs/yaffs2/yaffs_getblockinfo.h | 9 +- fs/yaffs2/yaffs_guts.c | 4947 ++++++++---------- fs/yaffs2/yaffs_guts.h | 1011 ++-- fs/yaffs2/yaffs_linux.h | 28 +- fs/yaffs2/yaffs_linux_allocator.c | 200 - fs/yaffs2/yaffs_list.h | 127 - fs/yaffs2/yaffs_mtdif.c | 18 +- fs/yaffs2/yaffs_mtdif.h | 8 +- fs/yaffs2/yaffs_mtdif1.c | 188 +- fs/yaffs2/yaffs_mtdif1.h | 15 +- fs/yaffs2/yaffs_mtdif2.c | 189 +- fs/yaffs2/yaffs_mtdif2.h | 16 +- fs/yaffs2/yaffs_nameval.c | 128 +- fs/yaffs2/yaffs_nameval.h | 9 +- fs/yaffs2/yaffs_nand.c | 120 +- fs/yaffs2/yaffs_nand.h | 30 +- fs/yaffs2/yaffs_nandemul2k.h | 39 - fs/yaffs2/yaffs_packedtags1.c | 49 +- fs/yaffs2/yaffs_packedtags1.h | 22 +- fs/yaffs2/yaffs_packedtags2.c | 209 +- fs/yaffs2/yaffs_packedtags2.h | 32 +- fs/yaffs2/yaffs_qsort.c | 163 - fs/yaffs2/yaffs_tagscompat.c | 447 +- fs/yaffs2/yaffs_tagscompat.h | 31 +- fs/yaffs2/yaffs_tagsvalidity.c | 13 +- fs/yaffs2/yaffs_tagsvalidity.h | 5 +- fs/yaffs2/yaffs_trace.h | 6 +- fs/yaffs2/yaffs_verify.c | 594 +-- fs/yaffs2/yaffs_verify.h | 40 +- fs/yaffs2/{yaffs_vfs_glue.c => yaffs_vfs.c} | 2070 ++++---- fs/yaffs2/yaffs_yaffs1.c | 387 +- fs/yaffs2/yaffs_yaffs1.h | 2 +- fs/yaffs2/yaffs_yaffs2.c | 1498 +++--- fs/yaffs2/yaffs_yaffs2.h | 35 +- fs/yaffs2/yaffsinterface.h | 21 - fs/yaffs2/yportenv.h | 26 +- 51 files changed, 6622 insertions(+), 7738 deletions(-) delete mode 100644 fs/yaffs2/devextras.h create mode 100644 fs/yaffs2/yaffs_attribs.c rename fs/yaffs2/{yaffs_qsort.h => yaffs_attribs.h} (50%) delete mode 100644 fs/yaffs2/yaffs_linux_allocator.c delete mode 100644 fs/yaffs2/yaffs_list.h delete mode 100644 fs/yaffs2/yaffs_nandemul2k.h delete mode 100644 fs/yaffs2/yaffs_qsort.c rename fs/yaffs2/{yaffs_vfs_glue.c => yaffs_vfs.c} (56%) delete mode 100644 fs/yaffs2/yaffsinterface.h diff --git a/drivers/mtd/devices/htcleo_nand.c b/drivers/mtd/devices/htcleo_nand.c index 2140bcbc..2150bcc2 100755 --- a/drivers/mtd/devices/htcleo_nand.c +++ b/drivers/mtd/devices/htcleo_nand.c @@ -13,6 +13,16 @@ * */ +// WARNING: This driver is designed for HTC LEO (HD2) only. +// Changed numbers to match Leo flash layout +// Yaffs2 reading and writing with MTD_OOB_AUTO works +// -Cotulla + +// Added MTD_OOB_PLACE access to spare, removed most magic constants +// YAFFS2 should not pass improper oob len anymore (fix in yaffs_mtdif2.c) +// Added missing capabilities for userland mtd interaction (multi-page, data/oob only program) +// -Rajko + #include #include #include @@ -25,92 +35,34 @@ #include #include -#include -#include +#include + #include -//#define ENABLE_FLASH_RW_DUMP -//#define ENABLE_ENTRY_TRACE +#if defined(CONFIG_ARCH_MSM7X30) +#define MSM_NAND_BASE 0xA0200000 +#else +#define MSM_NAND_BASE 0xA0A00000 +#endif -#define VERBOSE 0 - -// WARNING: This driver is designed for HTC LEO (HD2) only. -// Changed numbers to match Leo flash layout -// Yaffs2 reading and writing with MTD_OOB_AUTO works -// -Cotulla - -// Added MTD_OOB_PLACE access to spare, removed most magic constants -// YAFFS2 should not pass improper oob len anymore (fix in yaffs_mtdif2.c) -// Added missing capabilities for userland mtd interaction (multi-page, data/oob only program) -// -Rajko - -#define MSM_NAND_BASE 0xA0A00000 -#define MSM_NAND_REG(off) (MSM_NAND_BASE + (off)) - -#define MSM_NAND_FLASH_CMD MSM_NAND_REG(0x0000) -#define MSM_NAND_ADDR0 MSM_NAND_REG(0x0004) -#define MSM_NAND_ADDR1 MSM_NAND_REG(0x0008) -#define MSM_NAND_FLASH_CHIP_SELECT MSM_NAND_REG(0x000C) -#define MSM_NAND_EXEC_CMD MSM_NAND_REG(0x0010) -#define MSM_NAND_FLASH_STATUS MSM_NAND_REG(0x0014) -#define MSM_NAND_BUFFER_STATUS MSM_NAND_REG(0x0018) -#define MSM_NAND_DEV0_CFG0 MSM_NAND_REG(0x0020) -#define MSM_NAND_DEV0_CFG1 MSM_NAND_REG(0x0024) -#define MSM_NAND_DEV1_CFG0 MSM_NAND_REG(0x0030) -#define MSM_NAND_DEV1_CFG1 MSM_NAND_REG(0x0034) -#define MSM_NAND_READ_ID MSM_NAND_REG(0x0040) -#define MSM_NAND_READ_STATUS MSM_NAND_REG(0x0044) -#define MSM_NAND_CONFIG_DATA MSM_NAND_REG(0x0050) -#define MSM_NAND_CONFIG MSM_NAND_REG(0x0054) -#define MSM_NAND_CONFIG_MODE MSM_NAND_REG(0x0058) -#define MSM_NAND_CONFIG_STATUS MSM_NAND_REG(0x0060) -#define MSM_NAND_MACRO1_REG MSM_NAND_REG(0x0064) -#define MSM_NAND_XFR_STEP1 MSM_NAND_REG(0x0070) -#define MSM_NAND_XFR_STEP2 MSM_NAND_REG(0x0074) -#define MSM_NAND_XFR_STEP3 MSM_NAND_REG(0x0078) -#define MSM_NAND_XFR_STEP4 MSM_NAND_REG(0x007C) -#define MSM_NAND_XFR_STEP5 MSM_NAND_REG(0x0080) -#define MSM_NAND_XFR_STEP6 MSM_NAND_REG(0x0084) -#define MSM_NAND_XFR_STEP7 MSM_NAND_REG(0x0088) -#define MSM_NAND_DEV_CMD0 MSM_NAND_REG(0x00A0) -#define MSM_NAND_DEV_CMD1 MSM_NAND_REG(0x00A4) -#define MSM_NAND_DEV_CMD2 MSM_NAND_REG(0x00A8) -#define MSM_NAND_DEV_CMD_VLD MSM_NAND_REG(0x00AC) -#define MSM_NAND_EBI2_MISR_SIG_REG MSM_NAND_REG(0x00B0) -#define MSM_NAND_EBI2_ECC_BUF_CFG MSM_NAND_REG(0x00F0) -#define MSM_NAND_FLASH_BUFFER MSM_NAND_REG(0x0100) - -/* device commands */ - -#define MSM_NAND_CMD_SOFT_RESET 0x01 -#define MSM_NAND_CMD_PAGE_READ 0x32 -#define MSM_NAND_CMD_PAGE_READ_ECC 0x33 -#define MSM_NAND_CMD_PAGE_READ_ALL 0x34 -#define MSM_NAND_CMD_SEQ_PAGE_READ 0x15 -#define MSM_NAND_CMD_PRG_PAGE 0x36 -#define MSM_NAND_CMD_PRG_PAGE_ECC 0x37 -#define MSM_NAND_CMD_PRG_PAGE_ALL 0x39 -#define MSM_NAND_CMD_BLOCK_ERASE 0x3A -#define MSM_NAND_CMD_FETCH_ID 0x0B -#define MSM_NAND_CMD_STATUS 0x0C -#define MSM_NAND_CMD_RESET 0x0D - - -////////////////////////////////////////////////////////////////////////// +#include "msm_nand.h" #define MSM_NAND_DMA_BUFFER_SIZE SZ_4K #define MSM_NAND_DMA_BUFFER_SLOTS \ (MSM_NAND_DMA_BUFFER_SIZE / (sizeof(((atomic_t *)0)->counter) * 8)) -#define MSM_NAND_CFG0_RAW 0xA80420C0 -#define MSM_NAND_CFG1_RAW 0x5045D +#define MSM_NAND_CFG0_RAW 0xA80420C0 +#define MSM_NAND_CFG1_RAW 0x5045D -#define SUPPORT_WRONG_ECC_CONFIG 1 -#define IGNORE_ARM9_CONFIG 0 +#define SUPPORT_WRONG_ECC_CONFIG 0 +#define IGNORE_ARM9_CONFIG 0 +#define VERBOSE 0 + +//#define ENABLE_FLASH_RW_DUMP +//#define ENABLE_ENTRY_TRACE static struct nand_hw_info *nand_info; -struct nand_hw_info -{ +struct nand_hw_info { uint32_t flash_id; uint8_t maker_id; uint8_t maker_name[10]; @@ -147,7 +99,7 @@ struct msm_nand_chip { #define msm_virt_to_dma(chip, vaddr) \ ((void)(*(vaddr)), (chip)->dma_addr + \ - ((uint8_t *)(vaddr) - (chip)->dma_buffer)) + ((uint8_t *)(vaddr) - (chip)->dma_buffer)) /** * msm_nand_oob_64 - oob info for 2KB page @@ -188,8 +140,8 @@ struct flash_identification { static struct flash_identification supported_flash[] = { - /* Flash ID ID Mask Density(MB) Wid Pgsz Blksz oobsz Manuf */ - {0x00000000, 0xFFFFFFFF, 0, 0, 0, 0, 0, }, /*ONFI*/ + /* Flash ID ID Mask Density(MB) Wid Pgsz Blksz oobsz Manuf */ + {0x00000000, 0xFFFFFFFF, 0, 0, 0, 0, 0, }, /*ONFI*/ {0x1500aaec, 0xFF00FFFF, (256<<20), 0, 2048, (2048<<6), 64, }, /*Samsung 2Gbit*/ {0x5500baec, 0xFF00FFFF, (256<<20), 1, 2048, (2048<<6), 64, }, /*Samsung 2Gbit*/ {0x6600bcec, 0xFF00FFFF, (512<<20), 1, 4096, (4096<<6), 128,}, /*Samsung 4Gbit 4K Page*/ @@ -210,7 +162,7 @@ static struct flash_identification supported_flash[] = {0x0000baad, 0x0000FFFF, (256<<20), 1, 2048, (2048<<6), 64, }, /*Hynix 2Gbit*/ {0x0000bcad, 0x0000FFFF, (512<<20), 1, 2048, (2048<<6), 64, }, /*Hynix 4Gbit*/ {0x0000b3ad, 0x0000FFFF, (1024<<20),1, 2048, (2048<<6), 64, }, /*Hynix 8Gbit*/ - /* Note: Width flag is 0 for 8 bit Flash and 1 for 16 bit flash */ + /* Note: Width flag is 0 for 8 bit Flash and 1 for 16 bit flash */ /* Note: The First row will be filled at runtime during ONFI probe */ }; @@ -246,7 +198,7 @@ static void *msm_nand_get_dma_buffer(struct msm_nand_chip *chip, size_t size) } static void msm_nand_release_dma_buffer(struct msm_nand_chip *chip, - void *buffer, size_t size) + void *buffer, size_t size) { int index; unsigned int used_mask; @@ -269,8 +221,8 @@ uint32_t flash_read_id(struct msm_nand_chip *chip) uint32_t rv; wait_event(chip->wait_queue, - (dma_buffer = msm_nand_get_dma_buffer( - chip, sizeof(*dma_buffer)))); + (dma_buffer = msm_nand_get_dma_buffer( + chip, sizeof(*dma_buffer)))); dma_buffer->data[0] = 0 | 4; dma_buffer->data[1] = MSM_NAND_CMD_FETCH_ID; @@ -333,8 +285,8 @@ int flash_read_config(struct msm_nand_chip *chip) } *dma_buffer; wait_event(chip->wait_queue, - (dma_buffer = msm_nand_get_dma_buffer( - chip, sizeof(*dma_buffer)))); + (dma_buffer = msm_nand_get_dma_buffer( + chip, sizeof(*dma_buffer)))); dma_buffer->cfg0 = 0; dma_buffer->cfg1 = 0; @@ -380,15 +332,16 @@ unsigned flash_rd_reg(struct msm_nand_chip *chip, unsigned addr) unsigned rv; wait_event(chip->wait_queue, - (dma_buffer = msm_nand_get_dma_buffer( - chip, sizeof(*dma_buffer)))); + (dma_buffer = msm_nand_get_dma_buffer( + chip, sizeof(*dma_buffer)))); dma_buffer->cmd.cmd = CMD_LC; dma_buffer->cmd.src = addr; dma_buffer->cmd.dst = msm_virt_to_dma(chip, &dma_buffer->data); dma_buffer->cmd.len = 4; - dma_buffer->cmdptr = (msm_virt_to_dma(chip, &dma_buffer->cmd) >> 3) | CMD_PTR_LP; + dma_buffer->cmdptr = + (msm_virt_to_dma(chip, &dma_buffer->cmd) >> 3) | CMD_PTR_LP; dma_buffer->data = 0xeeeeeeee; dsb(); @@ -412,8 +365,8 @@ void flash_wr_reg(struct msm_nand_chip *chip, unsigned addr, unsigned val) } *dma_buffer; wait_event(chip->wait_queue, - (dma_buffer = msm_nand_get_dma_buffer( - chip, sizeof(*dma_buffer)))); + (dma_buffer = msm_nand_get_dma_buffer( + chip, sizeof(*dma_buffer)))); dma_buffer->cmd.cmd = CMD_LC; dma_buffer->cmd.src = msm_virt_to_dma(chip, &dma_buffer->data); @@ -435,7 +388,7 @@ void flash_wr_reg(struct msm_nand_chip *chip, unsigned addr, unsigned val) static dma_addr_t msm_nand_dma_map(struct device *dev, void *addr, size_t size, - enum dma_data_direction dir) + enum dma_data_direction dir) { struct page *page; unsigned long offset = (unsigned long)addr & ~PAGE_MASK; @@ -850,14 +803,18 @@ static int msm_nand_read_oob(struct mtd_info *mtd, loff_t from, struct mtd_oob_o //remap dma if there's still data to be read if (data_count > 0) { + int offset = ops->len-data_count; #if VERBOSE - printk("msm_nand_read_oob dma_map_page offset=%d length=%d\n", (uint32_t)(ops->len-data_count), data_count); + printk("msm_nand_read_oob dma_map_page offset=%d length=%d\n", offset, data_count); #endif - data_dma_addr = msm_nand_dma_map(chip->dev, ops->datbuf+(ops->len-data_count), data_count, DMA_FROM_DEVICE); + data_dma_addr = msm_nand_dma_map(chip->dev, ops->datbuf+offset, data_count, DMA_FROM_DEVICE); data_dma_addr_curr = data_dma_addr; -#if VERBOSE - printk("msm_nand_read_oob dma_map_page returned %08x\n", (uint32_t)data_dma_addr); -#endif + + if (dma_mapping_error(chip->dev, data_dma_addr)) { + pr_err("msm_nand_read_oob: failed to re-get dma addr " + "for %p+%d initial_size=%d remaining_size=%d\n", ops->datbuf, offset, ops->len, data_count); + return -EIO; + } } else { @@ -1543,7 +1500,6 @@ msm_nand_erase(struct mtd_info *mtd, struct erase_info *instr) } *dma_buffer; unsigned page = 0; - if (mtd->writesize == 2048) page = instr->addr >> 11; @@ -1551,7 +1507,7 @@ msm_nand_erase(struct mtd_info *mtd, struct erase_info *instr) page = instr->addr >> 12; #ifdef ENABLE_ENTRY_TRACE - printk("+msm_nand_erase(%d)\n", page); + printk("msm_nand_erase(%d)\n", page); #endif if (instr->addr & (mtd->erasesize - 1)) { @@ -1559,6 +1515,7 @@ msm_nand_erase(struct mtd_info *mtd, struct erase_info *instr) __func__, instr->addr); return -EINVAL; } + if (instr->addr < (NUM_PROTECTED_BLOCKS*mtd->erasesize)) { pr_err("%s: cannot erase block in protected area, addr=0x%llx\n", @@ -1572,8 +1529,8 @@ msm_nand_erase(struct mtd_info *mtd, struct erase_info *instr) } wait_event(chip->wait_queue, - (dma_buffer = msm_nand_get_dma_buffer( - chip, sizeof(*dma_buffer)))); + (dma_buffer = msm_nand_get_dma_buffer( + chip, sizeof(*dma_buffer)))); dma_buffer->data[0] = MSM_NAND_CMD_BLOCK_ERASE; dma_buffer->data[1] = page; @@ -1607,7 +1564,7 @@ msm_nand_erase(struct mtd_info *mtd, struct erase_info *instr) dma_buffer->cmd[3].len = 4; /* clear the status register in case the OP_ERR is set - * due to the write, to work around a h/w bug */ + * due to the write, to work around a h/w bug */ dma_buffer->cmd[4].cmd = CMD_OCU | CMD_LC; dma_buffer->cmd[4].src = msm_virt_to_dma(chip, &dma_buffer->data[8]); dma_buffer->cmd[4].dst = MSM_NAND_FLASH_STATUS; @@ -1624,18 +1581,19 @@ msm_nand_erase(struct mtd_info *mtd, struct erase_info *instr) dsb(); /* we fail if there was an operation error, a mpu error, or the - * erase success bit was not set. - */ + * erase success bit was not set. + */ if (dma_buffer->data[5] & 0x110 || !(dma_buffer->data[5] & 0x80)) { if (dma_buffer->data[5] & 0x10) pr_warning("msm_nand: critical erase error, 0x%llx\n", - instr->addr); + instr->addr); err = -EIO; } else err = 0; msm_nand_release_dma_buffer(chip, dma_buffer, sizeof(*dma_buffer)); + if (err) { pr_err("%s: erase failed, 0x%llx\n", __func__, instr->addr); instr->fail_addr = instr->addr; @@ -1645,6 +1603,7 @@ msm_nand_erase(struct mtd_info *mtd, struct erase_info *instr) instr->fail_addr = 0xffffffff; mtd_erase_callback(instr); } + return err; } @@ -1676,9 +1635,6 @@ msm_nand_block_isbad(struct mtd_info *mtd, loff_t ofs) unsigned page = 0; unsigned cwperpage; -#ifdef ENABLE_ENTRY_TRACE - printk("+nand_block_isbad\n"); -#endif if (mtd->writesize == 2048) page = ofs >> 11; @@ -1690,11 +1646,12 @@ msm_nand_block_isbad(struct mtd_info *mtd, loff_t ofs) /* Check for invalid offset */ if (ofs > mtd->size) return -EINVAL; - if (ofs & (mtd->erasesize - 1)) - { - pr_err("%s: unsupported block address, 0x%x\n", __func__, (uint32_t)ofs); + if (ofs & (mtd->erasesize - 1)) { + pr_err("%s: unsupported block address, 0x%x\n", + __func__, (uint32_t)ofs); return -EINVAL; } + if (ofs < (NUM_PROTECTED_BLOCKS*mtd->erasesize)) { //protected blocks are always good @@ -1703,24 +1660,25 @@ msm_nand_block_isbad(struct mtd_info *mtd, loff_t ofs) wait_event(chip->wait_queue, (dma_buffer = msm_nand_get_dma_buffer(chip , - sizeof(*dma_buffer) + 4))); + sizeof(*dma_buffer) + 4))); buf = (uint8_t *)dma_buffer + sizeof(*dma_buffer); /* Read 4 bytes starting from the bad block marker location - * in the last code word of the page - */ + * in the last code word of the page + */ cmd = dma_buffer->cmd; dma_buffer->data.cmd = MSM_NAND_CMD_PAGE_READ; - dma_buffer->data.cfg0 = MSM_NAND_CFG0_RAW & ~(7U << 6); - // ecc disabled + dma_buffer->data.cfg0 = MSM_NAND_CFG0_RAW & ~(7U << 6); dma_buffer->data.cfg1 = MSM_NAND_CFG1_RAW | (chip->CFG1 & CFG1_WIDE_FLASH); if (chip->CFG1 & CFG1_WIDE_FLASH) - dma_buffer->data.addr0 = (page << 16) | ((528*(cwperpage-1)) >> 1); + dma_buffer->data.addr0 = (page << 16) | + ((528*(cwperpage-1)) >> 1); else - dma_buffer->data.addr0 = (page << 16) | (528*(cwperpage-1)); + dma_buffer->data.addr0 = (page << 16) | + (528*(cwperpage-1)); dma_buffer->data.addr1 = (page >> 16) & 0xff; dma_buffer->data.chipsel = 0 | 4; @@ -1766,57 +1724,37 @@ msm_nand_block_isbad(struct mtd_info *mtd, loff_t ofs) cmd[-1].cmd |= CMD_OCU | CMD_LC; dma_buffer->cmdptr = (msm_virt_to_dma(chip, - dma_buffer->cmd) >> 3) | CMD_PTR_LP; + dma_buffer->cmd) >> 3) | CMD_PTR_LP; dsb(); - msm_dmov_exec_cmd(chip->dma_channel, DMOV_CMD_PTR_LIST | DMOV_CMD_ADDR(msm_virt_to_dma(chip, &dma_buffer->cmdptr))); + msm_dmov_exec_cmd(chip->dma_channel, DMOV_CMD_PTR_LIST | + DMOV_CMD_ADDR(msm_virt_to_dma(chip, &dma_buffer->cmdptr))); dsb(); ret = 0; if (dma_buffer->data.result.flash_status & 0x110) - { -#if VERBOSE - if (dma_buffer->data.result.flash_status & 0x100) - { - pr_err("msm_block_isbad off=%d protection violation\n",(uint32_t)ofs); - } - if (dma_buffer->data.result.flash_status & 0x10) - { - pr_err("msm_block_isbad off=%d wrfail\n",(uint32_t)ofs); - } -#endif ret = -EIO; + + if (!ret) { + /* Check for bad block marker byte */ + if (chip->CFG1 & CFG1_WIDE_FLASH) { + if (buf[0] != 0xFF || buf[1] != 0xFF) + ret = 1; + } else { + if (buf[0] != 0xFF) + ret = 1; + } } - if (!ret) - { - /* Check for bad block marker byte */ - if (chip->CFG1 & CFG1_WIDE_FLASH) - { - if (buf[0] != 0xFF || buf[1] != 0xFF) - { - ret = 1; - printk("###BAD BLOCK %d %08X###\n", (uint32_t)(ofs) / mtd->erasesize, (uint32_t)ofs); - } - } - else - { - if (buf[0] != 0xFF) - { - ret = 1; - printk("###BAD BLOCK %d %08X###\n", (uint32_t)(ofs) / mtd->erasesize, (uint32_t)ofs); - } - } - } + if (ret==1) + printk("###BAD BLOCK %d %08X###\n", (uint32_t)(ofs) / mtd->erasesize, (uint32_t)ofs); + else if (ret != 0) + printk("###ERROR CHECKING BLOCK %d %08X###\n", (uint32_t)(ofs) / mtd->erasesize, (uint32_t)ofs); msm_nand_release_dma_buffer(chip, dma_buffer, sizeof(*dma_buffer) + 4); -#ifdef ENABLE_ENTRY_TRACE - printk("-nand_block_isbad %d\n", ret); -#endif return ret; } - static int msm_nand_block_markbad(struct mtd_info *mtd, loff_t ofs) { @@ -1824,8 +1762,7 @@ msm_nand_block_markbad(struct mtd_info *mtd, loff_t ofs) int ret; ret = msm_nand_block_isbad(mtd, ofs); - if (ret) - { + if (ret) { /* If it was bad already, return success and do nothing */ if (ret > 0) return 0; @@ -1836,28 +1773,28 @@ msm_nand_block_markbad(struct mtd_info *mtd, loff_t ofs) } /** -* msm_nand_suspend - [MTD Interface] Suspend the msm_nand flash -* @param mtd MTD device structure -*/ + * msm_nand_suspend - [MTD Interface] Suspend the msm_nand flash + * @param mtd MTD device structure + */ static int msm_nand_suspend(struct mtd_info *mtd) { return 0; } /** -* msm_nand_resume - [MTD Interface] Resume the msm_nand flash -* @param mtd MTD device structure -*/ + * msm_nand_resume - [MTD Interface] Resume the msm_nand flash + * @param mtd MTD device structure + */ static void msm_nand_resume(struct mtd_info *mtd) { } /** -* Export 3 attributes for HTC SSD HW INFO tool -* >info :basic HW spec of this NAND chip -* >vendor :vendor information -* >pagesize:page size, either 2048 or 4096 -*/ + * Export 3 attributes for HTC SSD HW INFO tool + * >info :basic HW spec of this NAND chip + * >vendor :vendor information + * >pagesize:page size, either 2048 or 4096 + */ static int param_get_vendor_name(char *buffer, struct kernel_param *kp) { return sprintf(buffer, "%s", nand_info->maker_name); @@ -1869,17 +1806,17 @@ static int param_get_nand_info(char *buffer, struct kernel_param *kp) int result = 0; result += sprintf(buffer, "<< NAND INFO >>\n"); result += sprintf(buffer + result, "flash id\t =%X\n", - nand_info->flash_id); + nand_info->flash_id); result += sprintf(buffer + result, "vendor\t\t =%s\n", - nand_info->maker_name); + nand_info->maker_name); result += sprintf(buffer + result, "width\t\t =%d bits\n", - nand_info->width); + nand_info->width); result += sprintf(buffer + result, "size\t\t =%d MB\n", - nand_info->size>>20); + nand_info->size>>20); result += sprintf(buffer + result, "block count\t =%d\n", - nand_info->block_count); + nand_info->block_count); result += sprintf(buffer + result, "page count\t =%d", - nand_info->page_count); + nand_info->page_count); return result; } module_param_call(info, NULL, param_get_nand_info, NULL, S_IRUGO); @@ -1913,17 +1850,16 @@ int msm_nand_scan(struct mtd_info *mtd, int maxchips) flash_id = flash_read_id(chip); for (index = 1; index < ARRAY_SIZE(supported_flash); index++) { if ((flash_id & supported_flash[index].mask) == - (supported_flash[index].flash_id & - (supported_flash[index].mask))) { - dev_found = 1; - break; + (supported_flash[index].flash_id & + (supported_flash[index].mask))) { + dev_found = 1; + break; } } - if (dev_found) - { - wide_bus = supported_flash[index].widebus; - mtd->size = supported_flash[index].density * i; + if (dev_found) { + wide_bus = supported_flash[index].widebus; + mtd->size = supported_flash[index].density * i; mtd->writesize = supported_flash[index].pagesize * i; mtd->oobsize = supported_flash[index].oobsize * i; mtd->erasesize = supported_flash[index].blksize * i; @@ -1942,7 +1878,6 @@ int msm_nand_scan(struct mtd_info *mtd, int maxchips) return -ENODEV; } - if (mtd->writesize != 2048) { pr_err("ERROR: unsupported flash parameters!\n"); @@ -1961,17 +1896,16 @@ int msm_nand_scan(struct mtd_info *mtd, int maxchips) chip->CFG0 = (((mtd->writesize >> 9)-1) << 6) /* 4/8 cw/per page for 2/4k */ | (512 << 9) /* 512 user data bytes */ | (10 << 19) /* 10 parity bytes */ - | (4 << 23) /* spare size */ - | (5 << 27) /* 5 address cycles */ - | (1 << 30) /* Read status before data */ - | (1 << 31) /* Send read cmd */ - | 0; + | (4 << 23) /* spare size */ + | (5 << 27) /* 5 address cycles */ + | (1 << 30) /* Read status before data */ + | (1 << 31); /* Send read cmd */ chip->CFG1 = chip->CFG1 #if IGNORE_ARM9_CONFIG /* use ARM11 own setting on CFG1 */ - | (7 << 2) /* 8 recovery cycles */ - | (0 << 5) /* Allow CS deassertion */ - | (2 << 17) /* 6 cycle tWB/tRB */ + | (7 << 2) /* 8 recovery cycles */ + | (0 << 5) /* Allow CS deassertion */ + | (2 << 17) /* 6 cycle tWB/tRB */ #endif | ((mtd->writesize - (528 * ((mtd->writesize >> 9) - 1)) + 1) << 6) /* Bad block marker location */ | (wide_bus << 1); /* Wide flash bit */ @@ -2004,8 +1938,7 @@ int msm_nand_scan(struct mtd_info *mtd, int maxchips) } else { - pr_err("Unsupported Nand, oobsize: 0x%x \n", - mtd->oobsize); + pr_err("Unsupported Nand, oobsize: 0x%x \n", mtd->oobsize); return -ENODEV; } @@ -2084,9 +2017,9 @@ int msm_nand_scan(struct mtd_info *mtd, int maxchips) EXPORT_SYMBOL_GPL(msm_nand_scan); /** -* msm_nand_release - [msm_nand Interface] Free resources held by the msm_nand device -* @param mtd MTD device structure -*/ + * msm_nand_release - [msm_nand Interface] Free resources held by the msm_nand device + * @param mtd MTD device structure + */ void msm_nand_release(struct mtd_info *mtd) { /* struct msm_nand_chip *this = mtd->priv; */ @@ -2105,7 +2038,7 @@ static const char *part_probes[] = { "cmdlinepart", NULL, }; #endif struct msm_nand_info { - struct mtd_info mtd; + struct mtd_info mtd; struct mtd_partition *parts; struct msm_nand_chip msm_nand; }; @@ -2137,7 +2070,7 @@ static int __devinit msm_nand_probe(struct platform_device *pdev) /* this currently fails if dev is passed in */ info->msm_nand.dma_buffer = dma_alloc_coherent(/*dev*/ NULL, MSM_NAND_DMA_BUFFER_SIZE, - &info->msm_nand.dma_addr, GFP_KERNEL); + &info->msm_nand.dma_addr, GFP_KERNEL); if (info->msm_nand.dma_buffer == NULL) { err = -ENOMEM; goto out_free_info; @@ -2159,10 +2092,11 @@ static int __devinit msm_nand_probe(struct platform_device *pdev) #ifdef CONFIG_MTD_PARTITIONS /* Re-calculate the partition offset and size with correct page size */ - for (i = 0; i < pdata->nr_parts; i++) - { - pdata->parts[i].offset = pdata->parts[i].offset * info->mtd.erasesize; - pdata->parts[i].size = pdata->parts[i].size * info->mtd.erasesize; + for (i = 0; i < pdata->nr_parts; i++) { + pdata->parts[i].offset = pdata->parts[i].offset + * info->mtd.erasesize; + pdata->parts[i].size = pdata->parts[i].size + * info->mtd.erasesize; } err = parse_mtd_partitions(&info->mtd, part_probes, &info->parts, 0); @@ -2179,7 +2113,8 @@ static int __devinit msm_nand_probe(struct platform_device *pdev) return 0; out_free_dma_buffer: - dma_free_coherent(/*dev*/ NULL, SZ_4K, info->msm_nand.dma_buffer, info->msm_nand.dma_addr); + dma_free_coherent(/*dev*/ NULL, SZ_4K, info->msm_nand.dma_buffer, + info->msm_nand.dma_addr); out_free_info: kfree(info); @@ -2202,8 +2137,8 @@ static int __devexit msm_nand_remove(struct platform_device *pdev) msm_nand_release(&info->mtd); dma_free_coherent(/*dev*/ NULL, SZ_4K, - info->msm_nand.dma_buffer, - info->msm_nand.dma_addr); + info->msm_nand.dma_buffer, + info->msm_nand.dma_addr); kfree(info); } @@ -2213,10 +2148,10 @@ static int __devexit msm_nand_remove(struct platform_device *pdev) #define DRIVER_NAME "msm_nand" static struct platform_driver msm_nand_driver = { - .probe = msm_nand_probe, - .remove = __devexit_p(msm_nand_remove), + .probe = msm_nand_probe, + .remove = __devexit_p(msm_nand_remove), .driver = { - .name = DRIVER_NAME, + .name = DRIVER_NAME, } }; @@ -2238,3 +2173,4 @@ module_exit(msm_nand_exit); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("htcleo nand driver code"); + diff --git a/drivers/mtd/devices/msm_nand.c b/drivers/mtd/devices/msm_nand.c index ed619420..2640a02b 100644 --- a/drivers/mtd/devices/msm_nand.c +++ b/drivers/mtd/devices/msm_nand.c @@ -678,15 +678,12 @@ static int msm_nand_read_oob(struct mtd_info *mtd, loff_t from, * was a protection violation (0x100), we lose */ pageerr = rawerr = 0; -// This check fails on reading from Leos NAND, we have to check why -#ifndef CONFIG_MACH_HTCLEO for (n = start_sector; n < cwperpage; n++) { if (dma_buffer->data.result[n].flash_status & 0x110) { rawerr = -EIO; break; } } -#endif if (rawerr) { if (ops->datbuf) { uint8_t *datbuf = ops->datbuf + diff --git a/fs/yaffs2/Makefile b/fs/yaffs2/Makefile index fbdbd4a0..e63a28aa 100644 --- a/fs/yaffs2/Makefile +++ b/fs/yaffs2/Makefile @@ -4,11 +4,11 @@ obj-$(CONFIG_YAFFS_FS) += yaffs.o -yaffs-y := yaffs_ecc.o yaffs_vfs_glue.o yaffs_guts.o yaffs_checkptrw.o +yaffs-y := yaffs_ecc.o yaffs_vfs.o yaffs_guts.o yaffs_checkptrw.o yaffs-y += yaffs_packedtags1.o yaffs_packedtags2.o yaffs_nand.o yaffs-y += yaffs_tagscompat.o yaffs_tagsvalidity.o yaffs-y += yaffs_mtdif.o yaffs_mtdif1.o yaffs_mtdif2.o -yaffs-y += yaffs_nameval.o +yaffs-y += yaffs_nameval.o yaffs_attribs.o yaffs-y += yaffs_allocator.o yaffs-y += yaffs_yaffs1.o yaffs-y += yaffs_yaffs2.o diff --git a/fs/yaffs2/devextras.h b/fs/yaffs2/devextras.h deleted file mode 100644 index ce30c820..00000000 --- a/fs/yaffs2/devextras.h +++ /dev/null @@ -1,101 +0,0 @@ -/* - * YAFFS: Yet another Flash File System . A NAND-flash specific file system. - * - * Copyright (C) 2002-2010 Aleph One Ltd. - * for Toby Churchill Ltd and Brightstar Engineering - * - * Created by Charles Manning - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License version 2.1 as - * published by the Free Software Foundation. - * - * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. - */ - -/* - * This file is just holds extra declarations of macros that would normally - * be providesd in the Linux kernel. These macros have been written from - * scratch but are functionally equivalent to the Linux ones. - * - */ - -#ifndef __EXTRAS_H__ -#define __EXTRAS_H__ - - -#include "yportenv.h" - -#if !(defined __KERNEL__) - -/* Definition of types */ -typedef unsigned char __u8; -typedef unsigned short __u16; -typedef unsigned __u32; - -#endif - - -#if !(defined __KERNEL__) - - -#ifndef WIN32 -#include -#endif - - -#ifdef CONFIG_YAFFS_PROVIDE_DEFS -/* File types */ - - -#define DT_UNKNOWN 0 -#define DT_FIFO 1 -#define DT_CHR 2 -#define DT_DIR 4 -#define DT_BLK 6 -#define DT_REG 8 -#define DT_LNK 10 -#define DT_SOCK 12 -#define DT_WHT 14 - - -#ifndef WIN32 -#include -#endif - -/* - * Attribute flags. These should be or-ed together to figure out what - * has been changed! - */ -#define ATTR_MODE 1 -#define ATTR_UID 2 -#define ATTR_GID 4 -#define ATTR_SIZE 8 -#define ATTR_ATIME 16 -#define ATTR_MTIME 32 -#define ATTR_CTIME 64 - -struct iattr { - unsigned int ia_valid; - unsigned ia_mode; - unsigned ia_uid; - unsigned ia_gid; - unsigned ia_size; - unsigned ia_atime; - unsigned ia_mtime; - unsigned ia_ctime; - unsigned int ia_attr_flags; -}; - -#endif - -#else - -#include -#include -#include - -#endif - - -#endif diff --git a/fs/yaffs2/moduleconfig.h b/fs/yaffs2/moduleconfig.h index 43f11447..20a08821 100644 --- a/fs/yaffs2/moduleconfig.h +++ b/fs/yaffs2/moduleconfig.h @@ -62,13 +62,12 @@ /* Meaning: Select to disable background processing */ /* #define CONFIG_DISABLE_BACKGROUND */ - /* Default: Selected */ /* Meaning: Enable XATTR support */ #define CONFIG_YAFFS_XATTR /* -Older-style on-NAND data format has a "pageStatus" byte to record +Older-style on-NAND data format has a "page_status" byte to record chunk/page state. This byte is zeroed when the page is discarded. Choose this option if you have existing on-NAND data in this format that you need to continue to support. New data written also uses the @@ -78,7 +77,7 @@ adjusted to use the older-style format. See notes on tags formats and MTD versions in yaffs_mtdif1.c. */ /* Default: Not selected */ -/* Meaning: Use older-style on-NAND data format with pageStatus byte */ +/* Meaning: Use older-style on-NAND data format with page_status byte */ /* #define CONFIG_YAFFS_9BYTE_TAGS */ #endif /* YAFFS_OUT_OF_TREE */ diff --git a/fs/yaffs2/yaffs_allocator.c b/fs/yaffs2/yaffs_allocator.c index ab44bc7d..03ede863 100644 --- a/fs/yaffs2/yaffs_allocator.c +++ b/fs/yaffs2/yaffs_allocator.c @@ -1,5 +1,5 @@ /* - * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. * * Copyright (C) 2002-2010 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering @@ -7,13 +7,10 @@ * Created by Charles Manning * * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License version 2.1 as + * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. - * - * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. */ - #include "yaffs_allocator.h" #include "yaffs_guts.h" #include "yaffs_trace.h" @@ -21,45 +18,44 @@ #ifdef CONFIG_YAFFS_YMALLOC_ALLOCATOR -void yaffs_DeinitialiseRawTnodesAndObjects(yaffs_Device *dev) +void yaffs_deinit_raw_tnodes_and_objs(struct yaffs_dev *dev) { dev = dev; } -void yaffs_InitialiseRawTnodesAndObjects(yaffs_Device *dev) +void yaffs_init_raw_tnodes_and_objs(struct yaffs_dev *dev) { dev = dev; } -yaffs_Tnode *yaffs_AllocateRawTnode(yaffs_Device *dev) +struct yaffs_tnode *yaffs_alloc_raw_tnode(struct yaffs_dev *dev) { - return (yaffs_Tnode *)YMALLOC(dev->tnodeSize); + return (struct yaffs_tnode *)YMALLOC(dev->tnode_size); } -void yaffs_FreeRawTnode(yaffs_Device *dev, yaffs_Tnode *tn) +void yaffs_free_raw_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn) { dev = dev; YFREE(tn); } -void yaffs_InitialiseRawObjects(yaffs_Device *dev) +void yaffs_init_raw_objs(struct yaffs_dev *dev) { dev = dev; } -void yaffs_DeinitialiseRawObjects(yaffs_Device *dev) +void yaffs_deinit_raw_objs(struct yaffs_dev *dev) { dev = dev; } -yaffs_Object *yaffs_AllocateRawObject(yaffs_Device *dev) +struct yaffs_obj *yaffs_alloc_raw_obj(struct yaffs_dev *dev) { dev = dev; - return (yaffs_Object *) YMALLOC(sizeof(yaffs_Object)); + return (struct yaffs_obj *)YMALLOC(sizeof(struct yaffs_obj)); } - -void yaffs_FreeRawObject(yaffs_Device *dev, yaffs_Object *obj) +void yaffs_free_raw_obj(struct yaffs_dev *dev, struct yaffs_obj *obj) { dev = dev; @@ -68,135 +64,128 @@ void yaffs_FreeRawObject(yaffs_Device *dev, yaffs_Object *obj) #else -struct yaffs_TnodeList_struct { - struct yaffs_TnodeList_struct *next; - yaffs_Tnode *tnodes; +struct yaffs_tnode_list { + struct yaffs_tnode_list *next; + struct yaffs_tnode *tnodes; }; -typedef struct yaffs_TnodeList_struct yaffs_TnodeList; - -struct yaffs_ObjectList_struct { - yaffs_Object *objects; - struct yaffs_ObjectList_struct *next; +struct yaffs_obj_list { + struct yaffs_obj_list *next; + struct yaffs_obj *objects; }; -typedef struct yaffs_ObjectList_struct yaffs_ObjectList; +struct yaffs_allocator { + int n_tnodes_created; + struct yaffs_tnode *free_tnodes; + int n_free_tnodes; + struct yaffs_tnode_list *alloc_tnode_list; + int n_obj_created; + struct yaffs_obj *free_objs; + int n_free_objects; -struct yaffs_AllocatorStruct { - int nTnodesCreated; - yaffs_Tnode *freeTnodes; - int nFreeTnodes; - yaffs_TnodeList *allocatedTnodeList; - - int nObjectsCreated; - yaffs_Object *freeObjects; - int nFreeObjects; - - yaffs_ObjectList *allocatedObjectList; + struct yaffs_obj_list *allocated_obj_list; }; -typedef struct yaffs_AllocatorStruct yaffs_Allocator; - - -static void yaffs_DeinitialiseRawTnodes(yaffs_Device *dev) +static void yaffs_deinit_raw_tnodes(struct yaffs_dev *dev) { - yaffs_Allocator *allocator = (yaffs_Allocator *)dev->allocator; + struct yaffs_allocator *allocator = + (struct yaffs_allocator *)dev->allocator; - yaffs_TnodeList *tmp; + struct yaffs_tnode_list *tmp; - if(!allocator){ + if (!allocator) { YBUG(); return; } - while (allocator->allocatedTnodeList) { - tmp = allocator->allocatedTnodeList->next; + while (allocator->alloc_tnode_list) { + tmp = allocator->alloc_tnode_list->next; - YFREE(allocator->allocatedTnodeList->tnodes); - YFREE(allocator->allocatedTnodeList); - allocator->allocatedTnodeList = tmp; + YFREE(allocator->alloc_tnode_list->tnodes); + YFREE(allocator->alloc_tnode_list); + allocator->alloc_tnode_list = tmp; } - allocator->freeTnodes = NULL; - allocator->nFreeTnodes = 0; - allocator->nTnodesCreated = 0; + allocator->free_tnodes = NULL; + allocator->n_free_tnodes = 0; + allocator->n_tnodes_created = 0; } -static void yaffs_InitialiseRawTnodes(yaffs_Device *dev) +static void yaffs_init_raw_tnodes(struct yaffs_dev *dev) { - yaffs_Allocator *allocator = dev->allocator; + struct yaffs_allocator *allocator = dev->allocator; - if(allocator){ - allocator->allocatedTnodeList = NULL; - allocator->freeTnodes = NULL; - allocator->nFreeTnodes = 0; - allocator->nTnodesCreated = 0; + if (allocator) { + allocator->alloc_tnode_list = NULL; + allocator->free_tnodes = NULL; + allocator->n_free_tnodes = 0; + allocator->n_tnodes_created = 0; } else YBUG(); } -static int yaffs_CreateTnodes(yaffs_Device *dev, int nTnodes) +static int yaffs_create_tnodes(struct yaffs_dev *dev, int n_tnodes) { - yaffs_Allocator *allocator = (yaffs_Allocator *)dev->allocator; + struct yaffs_allocator *allocator = + (struct yaffs_allocator *)dev->allocator; int i; - yaffs_Tnode *newTnodes; - __u8 *mem; - yaffs_Tnode *curr; - yaffs_Tnode *next; - yaffs_TnodeList *tnl; + struct yaffs_tnode *new_tnodes; + u8 *mem; + struct yaffs_tnode *curr; + struct yaffs_tnode *next; + struct yaffs_tnode_list *tnl; - if(!allocator){ + if (!allocator) { YBUG(); return YAFFS_FAIL; } - if (nTnodes < 1) + if (n_tnodes < 1) return YAFFS_OK; - /* make these things */ - newTnodes = YMALLOC(nTnodes * dev->tnodeSize); - mem = (__u8 *)newTnodes; + new_tnodes = YMALLOC(n_tnodes * dev->tnode_size); + mem = (u8 *) new_tnodes; - if (!newTnodes) { + if (!new_tnodes) { T(YAFFS_TRACE_ERROR, - (TSTR("yaffs: Could not allocate Tnodes" TENDSTR))); + (TSTR("yaffs: Could not allocate Tnodes" TENDSTR))); return YAFFS_FAIL; } /* New hookup for wide tnodes */ - for (i = 0; i < nTnodes - 1; i++) { - curr = (yaffs_Tnode *) &mem[i * dev->tnodeSize]; - next = (yaffs_Tnode *) &mem[(i+1) * dev->tnodeSize]; + for (i = 0; i < n_tnodes - 1; i++) { + curr = (struct yaffs_tnode *)&mem[i * dev->tnode_size]; + next = (struct yaffs_tnode *)&mem[(i + 1) * dev->tnode_size]; curr->internal[0] = next; } - curr = (yaffs_Tnode *) &mem[(nTnodes - 1) * dev->tnodeSize]; - curr->internal[0] = allocator->freeTnodes; - allocator->freeTnodes = (yaffs_Tnode *)mem; + curr = (struct yaffs_tnode *)&mem[(n_tnodes - 1) * dev->tnode_size]; + curr->internal[0] = allocator->free_tnodes; + allocator->free_tnodes = (struct yaffs_tnode *)mem; - allocator->nFreeTnodes += nTnodes; - allocator->nTnodesCreated += nTnodes; + allocator->n_free_tnodes += n_tnodes; + allocator->n_tnodes_created += n_tnodes; /* Now add this bunch of tnodes to a list for freeing up. * NB If we can't add this to the management list it isn't fatal * but it just means we can't free this bunch of tnodes later. */ - tnl = YMALLOC(sizeof(yaffs_TnodeList)); + tnl = YMALLOC(sizeof(struct yaffs_tnode_list)); if (!tnl) { T(YAFFS_TRACE_ERROR, (TSTR ("yaffs: Could not add tnodes to management list" TENDSTR))); - return YAFFS_FAIL; + return YAFFS_FAIL; } else { - tnl->tnodes = newTnodes; - tnl->next = allocator->allocatedTnodeList; - allocator->allocatedTnodeList = tnl; + tnl->tnodes = new_tnodes; + tnl->next = allocator->alloc_tnode_list; + allocator->alloc_tnode_list = tnl; } T(YAFFS_TRACE_ALLOCATE, (TSTR("yaffs: Tnodes added" TENDSTR))); @@ -204,112 +193,109 @@ static int yaffs_CreateTnodes(yaffs_Device *dev, int nTnodes) return YAFFS_OK; } - -yaffs_Tnode *yaffs_AllocateRawTnode(yaffs_Device *dev) +struct yaffs_tnode *yaffs_alloc_raw_tnode(struct yaffs_dev *dev) { - yaffs_Allocator *allocator = (yaffs_Allocator *)dev->allocator; - yaffs_Tnode *tn = NULL; + struct yaffs_allocator *allocator = + (struct yaffs_allocator *)dev->allocator; + struct yaffs_tnode *tn = NULL; - if(!allocator){ + if (!allocator) { YBUG(); return NULL; } /* If there are none left make more */ - if (!allocator->freeTnodes) - yaffs_CreateTnodes(dev, YAFFS_ALLOCATION_NTNODES); + if (!allocator->free_tnodes) + yaffs_create_tnodes(dev, YAFFS_ALLOCATION_NTNODES); - if (allocator->freeTnodes) { - tn = allocator->freeTnodes; - allocator->freeTnodes = allocator->freeTnodes->internal[0]; - allocator->nFreeTnodes--; + if (allocator->free_tnodes) { + tn = allocator->free_tnodes; + allocator->free_tnodes = allocator->free_tnodes->internal[0]; + allocator->n_free_tnodes--; } return tn; } /* FreeTnode frees up a tnode and puts it back on the free list */ -void yaffs_FreeRawTnode(yaffs_Device *dev, yaffs_Tnode *tn) +void yaffs_free_raw_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn) { - yaffs_Allocator *allocator = dev->allocator; + struct yaffs_allocator *allocator = dev->allocator; - if(!allocator){ + if (!allocator) { YBUG(); return; } if (tn) { - tn->internal[0] = allocator->freeTnodes; - allocator->freeTnodes = tn; - allocator->nFreeTnodes++; + tn->internal[0] = allocator->free_tnodes; + allocator->free_tnodes = tn; + allocator->n_free_tnodes++; } - dev->nCheckpointBlocksRequired = 0; /* force recalculation*/ + dev->checkpoint_blocks_required = 0; /* force recalculation */ } - - -static void yaffs_InitialiseRawObjects(yaffs_Device *dev) +static void yaffs_init_raw_objs(struct yaffs_dev *dev) { - yaffs_Allocator *allocator = dev->allocator; + struct yaffs_allocator *allocator = dev->allocator; - if(allocator) { - allocator->allocatedObjectList = NULL; - allocator->freeObjects = NULL; - allocator->nFreeObjects = 0; + if (allocator) { + allocator->allocated_obj_list = NULL; + allocator->free_objs = NULL; + allocator->n_free_objects = 0; } else YBUG(); } -static void yaffs_DeinitialiseRawObjects(yaffs_Device *dev) +static void yaffs_deinit_raw_objs(struct yaffs_dev *dev) { - yaffs_Allocator *allocator = dev->allocator; - yaffs_ObjectList *tmp; + struct yaffs_allocator *allocator = dev->allocator; + struct yaffs_obj_list *tmp; - if(!allocator){ + if (!allocator) { YBUG(); return; } - while (allocator->allocatedObjectList) { - tmp = allocator->allocatedObjectList->next; - YFREE(allocator->allocatedObjectList->objects); - YFREE(allocator->allocatedObjectList); + while (allocator->allocated_obj_list) { + tmp = allocator->allocated_obj_list->next; + YFREE(allocator->allocated_obj_list->objects); + YFREE(allocator->allocated_obj_list); - allocator->allocatedObjectList = tmp; + allocator->allocated_obj_list = tmp; } - allocator->freeObjects = NULL; - allocator->nFreeObjects = 0; - allocator->nObjectsCreated = 0; + allocator->free_objs = NULL; + allocator->n_free_objects = 0; + allocator->n_obj_created = 0; } - -static int yaffs_CreateFreeObjects(yaffs_Device *dev, int nObjects) +static int yaffs_create_free_objs(struct yaffs_dev *dev, int n_obj) { - yaffs_Allocator *allocator = dev->allocator; + struct yaffs_allocator *allocator = dev->allocator; int i; - yaffs_Object *newObjects; - yaffs_ObjectList *list; + struct yaffs_obj *new_objs; + struct yaffs_obj_list *list; - if(!allocator){ + if (!allocator) { YBUG(); return YAFFS_FAIL; } - if (nObjects < 1) + if (n_obj < 1) return YAFFS_OK; /* make these things */ - newObjects = YMALLOC(nObjects * sizeof(yaffs_Object)); - list = YMALLOC(sizeof(yaffs_ObjectList)); + new_objs = YMALLOC(n_obj * sizeof(struct yaffs_obj)); + list = YMALLOC(sizeof(struct yaffs_obj_list)); - if (!newObjects || !list) { - if (newObjects){ - YFREE(newObjects); - newObjects = NULL; + if (!new_objs || !list) { + if (new_objs) { + YFREE(new_objs); + new_objs = NULL; } - if (list){ + if (list) { YFREE(list); list = NULL; } @@ -319,91 +305,89 @@ static int yaffs_CreateFreeObjects(yaffs_Device *dev, int nObjects) } /* Hook them into the free list */ - for (i = 0; i < nObjects - 1; i++) { - newObjects[i].siblings.next = - (struct ylist_head *)(&newObjects[i + 1]); + for (i = 0; i < n_obj - 1; i++) { + new_objs[i].siblings.next = + (struct list_head *)(&new_objs[i + 1]); } - newObjects[nObjects - 1].siblings.next = (void *)allocator->freeObjects; - allocator->freeObjects = newObjects; - allocator->nFreeObjects += nObjects; - allocator->nObjectsCreated += nObjects; + new_objs[n_obj - 1].siblings.next = (void *)allocator->free_objs; + allocator->free_objs = new_objs; + allocator->n_free_objects += n_obj; + allocator->n_obj_created += n_obj; /* Now add this bunch of Objects to a list for freeing up. */ - list->objects = newObjects; - list->next = allocator->allocatedObjectList; - allocator->allocatedObjectList = list; + list->objects = new_objs; + list->next = allocator->allocated_obj_list; + allocator->allocated_obj_list = list; return YAFFS_OK; } -yaffs_Object *yaffs_AllocateRawObject(yaffs_Device *dev) +struct yaffs_obj *yaffs_alloc_raw_obj(struct yaffs_dev *dev) { - yaffs_Object *obj = NULL; - yaffs_Allocator *allocator = dev->allocator; + struct yaffs_obj *obj = NULL; + struct yaffs_allocator *allocator = dev->allocator; - if(!allocator) { + if (!allocator) { YBUG(); return obj; } /* If there are none left make more */ - if (!allocator->freeObjects) - yaffs_CreateFreeObjects(dev, YAFFS_ALLOCATION_NOBJECTS); + if (!allocator->free_objs) + yaffs_create_free_objs(dev, YAFFS_ALLOCATION_NOBJECTS); - if (allocator->freeObjects) { - obj = allocator->freeObjects; - allocator->freeObjects = - (yaffs_Object *) (allocator->freeObjects->siblings.next); - allocator->nFreeObjects--; + if (allocator->free_objs) { + obj = allocator->free_objs; + allocator->free_objs = + (struct yaffs_obj *)(allocator->free_objs->siblings.next); + allocator->n_free_objects--; } return obj; } - -void yaffs_FreeRawObject(yaffs_Device *dev, yaffs_Object *obj) +void yaffs_free_raw_obj(struct yaffs_dev *dev, struct yaffs_obj *obj) { - yaffs_Allocator *allocator = dev->allocator; + struct yaffs_allocator *allocator = dev->allocator; - if(!allocator) + if (!allocator) YBUG(); else { /* Link into the free list. */ - obj->siblings.next = (struct ylist_head *)(allocator->freeObjects); - allocator->freeObjects = obj; - allocator->nFreeObjects++; + obj->siblings.next = (struct list_head *)(allocator->free_objs); + allocator->free_objs = obj; + allocator->n_free_objects++; } } -void yaffs_DeinitialiseRawTnodesAndObjects(yaffs_Device *dev) +void yaffs_deinit_raw_tnodes_and_objs(struct yaffs_dev *dev) { - if(dev->allocator){ - yaffs_DeinitialiseRawTnodes(dev); - yaffs_DeinitialiseRawObjects(dev); + if (dev->allocator) { + yaffs_deinit_raw_tnodes(dev); + yaffs_deinit_raw_objs(dev); YFREE(dev->allocator); - dev->allocator=NULL; + dev->allocator = NULL; } else YBUG(); } -void yaffs_InitialiseRawTnodesAndObjects(yaffs_Device *dev) +void yaffs_init_raw_tnodes_and_objs(struct yaffs_dev *dev) { - yaffs_Allocator *allocator; + struct yaffs_allocator *allocator; - if(!dev->allocator){ - allocator = YMALLOC(sizeof(yaffs_Allocator)); - if(allocator){ + if (!dev->allocator) { + allocator = YMALLOC(sizeof(struct yaffs_allocator)); + if (allocator) { dev->allocator = allocator; - yaffs_InitialiseRawTnodes(dev); - yaffs_InitialiseRawObjects(dev); + yaffs_init_raw_tnodes(dev); + yaffs_init_raw_objs(dev); } } else YBUG(); } - #endif diff --git a/fs/yaffs2/yaffs_allocator.h b/fs/yaffs2/yaffs_allocator.h index b0a5d11b..4d5f2aec 100644 --- a/fs/yaffs2/yaffs_allocator.h +++ b/fs/yaffs2/yaffs_allocator.h @@ -18,13 +18,13 @@ #include "yaffs_guts.h" -void yaffs_InitialiseRawTnodesAndObjects(yaffs_Device *dev); -void yaffs_DeinitialiseRawTnodesAndObjects(yaffs_Device *dev); +void yaffs_init_raw_tnodes_and_objs(struct yaffs_dev *dev); +void yaffs_deinit_raw_tnodes_and_objs(struct yaffs_dev *dev); -yaffs_Tnode *yaffs_AllocateRawTnode(yaffs_Device *dev); -void yaffs_FreeRawTnode(yaffs_Device *dev, yaffs_Tnode *tn); +struct yaffs_tnode *yaffs_alloc_raw_tnode(struct yaffs_dev *dev); +void yaffs_free_raw_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn); -yaffs_Object *yaffs_AllocateRawObject(yaffs_Device *dev); -void yaffs_FreeRawObject(yaffs_Device *dev, yaffs_Object *obj); +struct yaffs_obj *yaffs_alloc_raw_obj(struct yaffs_dev *dev); +void yaffs_free_raw_obj(struct yaffs_dev *dev, struct yaffs_obj *obj); #endif diff --git a/fs/yaffs2/yaffs_attribs.c b/fs/yaffs2/yaffs_attribs.c new file mode 100644 index 00000000..aaf46850 --- /dev/null +++ b/fs/yaffs2/yaffs_attribs.c @@ -0,0 +1,124 @@ +/* + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. + * + * Copyright (C) 2002-2010 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning + * + * 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 "yaffs_guts.h" +#include "yaffs_attribs.h" + +void yaffs_load_attribs(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh) +{ + obj->yst_uid = oh->yst_uid; + obj->yst_gid = oh->yst_gid; + obj->yst_atime = oh->yst_atime; + obj->yst_mtime = oh->yst_mtime; + obj->yst_ctime = oh->yst_ctime; + obj->yst_rdev = oh->yst_rdev; +} + +void yaffs_load_attribs_oh(struct yaffs_obj_hdr *oh, struct yaffs_obj *obj) +{ + oh->yst_uid = obj->yst_uid; + oh->yst_gid = obj->yst_gid; + oh->yst_atime = obj->yst_atime; + oh->yst_mtime = obj->yst_mtime; + oh->yst_ctime = obj->yst_ctime; + oh->yst_rdev = obj->yst_rdev; + +} + +void yaffs_load_current_time(struct yaffs_obj *obj, int do_a, int do_c) +{ + obj->yst_mtime = Y_CURRENT_TIME; + if (do_a) + obj->yst_atime = obj->yst_atime; + if (do_c) + obj->yst_ctime = obj->yst_atime; +} + +void yaffs_attribs_init(struct yaffs_obj *obj, u32 gid, u32 uid, u32 rdev) +{ + yaffs_load_current_time(obj, 1, 1); + obj->yst_rdev = rdev; + obj->yst_uid = uid; + obj->yst_gid = gid; +} + +loff_t yaffs_get_file_size(struct yaffs_obj *obj) +{ + YCHAR *alias = NULL; + obj = yaffs_get_equivalent_obj(obj); + + switch (obj->variant_type) { + case YAFFS_OBJECT_TYPE_FILE: + return obj->variant.file_variant.file_size; + case YAFFS_OBJECT_TYPE_SYMLINK: + alias = obj->variant.symlink_variant.alias; + if (!alias) + return 0; + return yaffs_strnlen(alias, YAFFS_MAX_ALIAS_LENGTH); + default: + return 0; + } +} + +int yaffs_set_attribs(struct yaffs_obj *obj, struct iattr *attr) +{ + unsigned int valid = attr->ia_valid; + + if (valid & ATTR_MODE) + obj->yst_mode = attr->ia_mode; + if (valid & ATTR_UID) + obj->yst_uid = attr->ia_uid; + if (valid & ATTR_GID) + obj->yst_gid = attr->ia_gid; + + if (valid & ATTR_ATIME) + obj->yst_atime = Y_TIME_CONVERT(attr->ia_atime); + if (valid & ATTR_CTIME) + obj->yst_ctime = Y_TIME_CONVERT(attr->ia_ctime); + if (valid & ATTR_MTIME) + obj->yst_mtime = Y_TIME_CONVERT(attr->ia_mtime); + + if (valid & ATTR_SIZE) + yaffs_resize_file(obj, attr->ia_size); + + yaffs_update_oh(obj, NULL, 1, 0, 0, NULL); + + return YAFFS_OK; + +} + +int yaffs_get_attribs(struct yaffs_obj *obj, struct iattr *attr) +{ + unsigned int valid = 0; + + attr->ia_mode = obj->yst_mode; + valid |= ATTR_MODE; + attr->ia_uid = obj->yst_uid; + valid |= ATTR_UID; + attr->ia_gid = obj->yst_gid; + valid |= ATTR_GID; + + Y_TIME_CONVERT(attr->ia_atime) = obj->yst_atime; + valid |= ATTR_ATIME; + Y_TIME_CONVERT(attr->ia_ctime) = obj->yst_ctime; + valid |= ATTR_CTIME; + Y_TIME_CONVERT(attr->ia_mtime) = obj->yst_mtime; + valid |= ATTR_MTIME; + + attr->ia_size = yaffs_get_file_size(obj); + valid |= ATTR_SIZE; + + attr->ia_valid = valid; + + return YAFFS_OK; +} diff --git a/fs/yaffs2/yaffs_qsort.h b/fs/yaffs2/yaffs_attribs.h similarity index 50% rename from fs/yaffs2/yaffs_qsort.h rename to fs/yaffs2/yaffs_attribs.h index 4a4981b3..33d541d6 100644 --- a/fs/yaffs2/yaffs_qsort.h +++ b/fs/yaffs2/yaffs_attribs.h @@ -13,22 +13,16 @@ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. */ +#ifndef __YAFFS_ATTRIBS_H__ +#define __YAFFS_ATTRIBS_H__ -#ifndef __YAFFS_QSORT_H__ -#define __YAFFS_QSORT_H__ +#include "yaffs_guts.h" -#ifdef __KERNEL__ -#include - -extern void yaffs_qsort(void *const base, size_t total_elems, size_t size, - int (*cmp)(const void *, const void *)){ - sort(base, total_elems, size, cmp, NULL); -} - -#else - -extern void yaffs_qsort(void *const base, size_t total_elems, size_t size, - int (*cmp)(const void *, const void *)); +void yaffs_load_attribs(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh); +void yaffs_load_attribs_oh(struct yaffs_obj_hdr *oh, struct yaffs_obj *obj); +void yaffs_attribs_init(struct yaffs_obj *obj, u32 gid, u32 uid, u32 rdev); +void yaffs_load_current_time(struct yaffs_obj *obj, int do_a, int do_c); +int yaffs_set_attribs(struct yaffs_obj *obj, struct iattr *attr); +int yaffs_get_attribs(struct yaffs_obj *obj, struct iattr *attr); #endif -#endif diff --git a/fs/yaffs2/yaffs_bitmap.c b/fs/yaffs2/yaffs_bitmap.c index c7e9e8c4..5d1cfb29 100644 --- a/fs/yaffs2/yaffs_bitmap.c +++ b/fs/yaffs2/yaffs_bitmap.c @@ -17,89 +17,88 @@ * Chunk bitmap manipulations */ -static Y_INLINE __u8 *yaffs_BlockBits(yaffs_Device *dev, int blk) +static Y_INLINE u8 *yaffs_block_bits(struct yaffs_dev *dev, int blk) { - if (blk < dev->internalStartBlock || blk > dev->internalEndBlock) { + if (blk < dev->internal_start_block || blk > dev->internal_end_block) { T(YAFFS_TRACE_ERROR, - (TSTR("**>> yaffs: BlockBits block %d is not valid" TENDSTR), - blk)); + (TSTR("**>> yaffs: BlockBits block %d is not valid" TENDSTR), + blk)); YBUG(); } - return dev->chunkBits + - (dev->chunkBitmapStride * (blk - dev->internalStartBlock)); + return dev->chunk_bits + + (dev->chunk_bit_stride * (blk - dev->internal_start_block)); } -void yaffs_VerifyChunkBitId(yaffs_Device *dev, int blk, int chunk) +void yaffs_verify_chunk_bit_id(struct yaffs_dev *dev, int blk, int chunk) { - if (blk < dev->internalStartBlock || blk > dev->internalEndBlock || - chunk < 0 || chunk >= dev->param.nChunksPerBlock) { + if (blk < dev->internal_start_block || blk > dev->internal_end_block || + chunk < 0 || chunk >= dev->param.chunks_per_block) { T(YAFFS_TRACE_ERROR, - (TSTR("**>> yaffs: Chunk Id (%d:%d) invalid"TENDSTR), - blk, chunk)); + (TSTR("**>> yaffs: Chunk Id (%d:%d) invalid" TENDSTR), + blk, chunk)); YBUG(); } } -void yaffs_ClearChunkBits(yaffs_Device *dev, int blk) +void yaffs_clear_chunk_bits(struct yaffs_dev *dev, int blk) { - __u8 *blkBits = yaffs_BlockBits(dev, blk); + u8 *blk_bits = yaffs_block_bits(dev, blk); - memset(blkBits, 0, dev->chunkBitmapStride); + memset(blk_bits, 0, dev->chunk_bit_stride); } -void yaffs_ClearChunkBit(yaffs_Device *dev, int blk, int chunk) +void yaffs_clear_chunk_bit(struct yaffs_dev *dev, int blk, int chunk) { - __u8 *blkBits = yaffs_BlockBits(dev, blk); + u8 *blk_bits = yaffs_block_bits(dev, blk); - yaffs_VerifyChunkBitId(dev, blk, chunk); + yaffs_verify_chunk_bit_id(dev, blk, chunk); - blkBits[chunk / 8] &= ~(1 << (chunk & 7)); + blk_bits[chunk / 8] &= ~(1 << (chunk & 7)); } -void yaffs_SetChunkBit(yaffs_Device *dev, int blk, int chunk) +void yaffs_set_chunk_bit(struct yaffs_dev *dev, int blk, int chunk) { - __u8 *blkBits = yaffs_BlockBits(dev, blk); + u8 *blk_bits = yaffs_block_bits(dev, blk); - yaffs_VerifyChunkBitId(dev, blk, chunk); + yaffs_verify_chunk_bit_id(dev, blk, chunk); - blkBits[chunk / 8] |= (1 << (chunk & 7)); + blk_bits[chunk / 8] |= (1 << (chunk & 7)); } -int yaffs_CheckChunkBit(yaffs_Device *dev, int blk, int chunk) +int yaffs_check_chunk_bit(struct yaffs_dev *dev, int blk, int chunk) { - __u8 *blkBits = yaffs_BlockBits(dev, blk); - yaffs_VerifyChunkBitId(dev, blk, chunk); + u8 *blk_bits = yaffs_block_bits(dev, blk); + yaffs_verify_chunk_bit_id(dev, blk, chunk); - return (blkBits[chunk / 8] & (1 << (chunk & 7))) ? 1 : 0; + return (blk_bits[chunk / 8] & (1 << (chunk & 7))) ? 1 : 0; } -int yaffs_StillSomeChunkBits(yaffs_Device *dev, int blk) +int yaffs_still_some_chunks(struct yaffs_dev *dev, int blk) { - __u8 *blkBits = yaffs_BlockBits(dev, blk); + u8 *blk_bits = yaffs_block_bits(dev, blk); int i; - for (i = 0; i < dev->chunkBitmapStride; i++) { - if (*blkBits) + for (i = 0; i < dev->chunk_bit_stride; i++) { + if (*blk_bits) return 1; - blkBits++; + blk_bits++; } return 0; } -int yaffs_CountChunkBits(yaffs_Device *dev, int blk) +int yaffs_count_chunk_bits(struct yaffs_dev *dev, int blk) { - __u8 *blkBits = yaffs_BlockBits(dev, blk); + u8 *blk_bits = yaffs_block_bits(dev, blk); int i; int n = 0; - for (i = 0; i < dev->chunkBitmapStride; i++) { - __u8 x = *blkBits; + for (i = 0; i < dev->chunk_bit_stride; i++) { + u8 x = *blk_bits; while (x) { if (x & 1) n++; x >>= 1; } - blkBits++; + blk_bits++; } return n; } - diff --git a/fs/yaffs2/yaffs_bitmap.h b/fs/yaffs2/yaffs_bitmap.h index a0ad1308..cf9ea58d 100644 --- a/fs/yaffs2/yaffs_bitmap.h +++ b/fs/yaffs2/yaffs_bitmap.h @@ -1,5 +1,5 @@ /* - * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. * * Copyright (C) 2002-2010 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering @@ -7,8 +7,10 @@ * Created by Charles Manning * * 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 + * it under the terms of the GNU Lesser General Public License version 2.1 as * published by the Free Software Foundation. + * + * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. */ /* @@ -20,12 +22,12 @@ #include "yaffs_guts.h" -void yaffs_VerifyChunkBitId(yaffs_Device *dev, int blk, int chunk); -void yaffs_ClearChunkBits(yaffs_Device *dev, int blk); -void yaffs_ClearChunkBit(yaffs_Device *dev, int blk, int chunk); -void yaffs_SetChunkBit(yaffs_Device *dev, int blk, int chunk); -int yaffs_CheckChunkBit(yaffs_Device *dev, int blk, int chunk); -int yaffs_StillSomeChunkBits(yaffs_Device *dev, int blk); -int yaffs_CountChunkBits(yaffs_Device *dev, int blk); +void yaffs_verify_chunk_bit_id(struct yaffs_dev *dev, int blk, int chunk); +void yaffs_clear_chunk_bits(struct yaffs_dev *dev, int blk); +void yaffs_clear_chunk_bit(struct yaffs_dev *dev, int blk, int chunk); +void yaffs_set_chunk_bit(struct yaffs_dev *dev, int blk, int chunk); +int yaffs_check_chunk_bit(struct yaffs_dev *dev, int blk, int chunk); +int yaffs_still_some_chunks(struct yaffs_dev *dev, int blk); +int yaffs_count_chunk_bits(struct yaffs_dev *dev, int blk); #endif diff --git a/fs/yaffs2/yaffs_checkptrw.c b/fs/yaffs2/yaffs_checkptrw.c index 16c9f849..2cb144c2 100644 --- a/fs/yaffs2/yaffs_checkptrw.c +++ b/fs/yaffs2/yaffs_checkptrw.c @@ -14,388 +14,406 @@ #include "yaffs_checkptrw.h" #include "yaffs_getblockinfo.h" -static int yaffs2_CheckpointSpaceOk(yaffs_Device *dev) +static int yaffs2_checkpt_space_ok(struct yaffs_dev *dev) { - int blocksAvailable = dev->nErasedBlocks - dev->param.nReservedBlocks; + int blocks_avail = dev->n_erased_blocks - dev->param.n_reserved_blocks; T(YAFFS_TRACE_CHECKPOINT, - (TSTR("checkpt blocks available = %d" TENDSTR), - blocksAvailable)); + (TSTR("checkpt blocks available = %d" TENDSTR), blocks_avail)); - return (blocksAvailable <= 0) ? 0 : 1; + return (blocks_avail <= 0) ? 0 : 1; } - -static int yaffs2_CheckpointErase(yaffs_Device *dev) +static int yaffs_checkpt_erase(struct yaffs_dev *dev) { int i; - if (!dev->param.eraseBlockInNAND) + if (!dev->param.erase_fn) return 0; - T(YAFFS_TRACE_CHECKPOINT, (TSTR("checking blocks %d to %d"TENDSTR), - dev->internalStartBlock, dev->internalEndBlock)); + T(YAFFS_TRACE_CHECKPOINT, (TSTR("checking blocks %d to %d" TENDSTR), + dev->internal_start_block, + dev->internal_end_block)); - for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) { - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, i); - if (bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("erasing checkpt block %d"TENDSTR), i)); + for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) { + struct yaffs_block_info *bi = yaffs_get_block_info(dev, i); + if (bi->block_state == YAFFS_BLOCK_STATE_CHECKPOINT) { + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("erasing checkpt block %d" TENDSTR), i)); - dev->nBlockErasures++; + dev->n_erasures++; - if (dev->param.eraseBlockInNAND(dev, i - dev->blockOffset /* realign */)) { - bi->blockState = YAFFS_BLOCK_STATE_EMPTY; - dev->nErasedBlocks++; - dev->nFreeChunks += dev->param.nChunksPerBlock; + if (dev->param. + erase_fn(dev, + i - dev->block_offset /* realign */ )) { + bi->block_state = YAFFS_BLOCK_STATE_EMPTY; + dev->n_erased_blocks++; + dev->n_free_chunks += + dev->param.chunks_per_block; } else { - dev->param.markNANDBlockBad(dev, i); - bi->blockState = YAFFS_BLOCK_STATE_DEAD; + dev->param.bad_block_fn(dev, i); + bi->block_state = YAFFS_BLOCK_STATE_DEAD; } } } - dev->blocksInCheckpoint = 0; + dev->blocks_in_checkpt = 0; return 1; } - -static void yaffs2_CheckpointFindNextErasedBlock(yaffs_Device *dev) +static void yaffs2_checkpt_find_erased_block(struct yaffs_dev *dev) { - int i; - int blocksAvailable = dev->nErasedBlocks - dev->param.nReservedBlocks; + int i; + int blocks_avail = dev->n_erased_blocks - dev->param.n_reserved_blocks; T(YAFFS_TRACE_CHECKPOINT, - (TSTR("allocating checkpt block: erased %d reserved %d avail %d next %d "TENDSTR), - dev->nErasedBlocks, dev->param.nReservedBlocks, blocksAvailable, dev->checkpointNextBlock)); + (TSTR + ("allocating checkpt block: erased %d reserved %d avail %d next %d " + TENDSTR), dev->n_erased_blocks, dev->param.n_reserved_blocks, + blocks_avail, dev->checkpt_next_block)); - if (dev->checkpointNextBlock >= 0 && - dev->checkpointNextBlock <= dev->internalEndBlock && - blocksAvailable > 0) { + if (dev->checkpt_next_block >= 0 && + dev->checkpt_next_block <= dev->internal_end_block && + blocks_avail > 0) { - for (i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++) { - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, i); - if (bi->blockState == YAFFS_BLOCK_STATE_EMPTY) { - dev->checkpointNextBlock = i + 1; - dev->checkpointCurrentBlock = i; - T(YAFFS_TRACE_CHECKPOINT, (TSTR("allocating checkpt block %d"TENDSTR), i)); + for (i = dev->checkpt_next_block; i <= dev->internal_end_block; + i++) { + struct yaffs_block_info *bi = + yaffs_get_block_info(dev, i); + if (bi->block_state == YAFFS_BLOCK_STATE_EMPTY) { + dev->checkpt_next_block = i + 1; + dev->checkpt_cur_block = i; + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("allocating checkpt block %d" TENDSTR), + i)); return; } } } - T(YAFFS_TRACE_CHECKPOINT, (TSTR("out of checkpt blocks"TENDSTR))); + T(YAFFS_TRACE_CHECKPOINT, (TSTR("out of checkpt blocks" TENDSTR))); - dev->checkpointNextBlock = -1; - dev->checkpointCurrentBlock = -1; + dev->checkpt_next_block = -1; + dev->checkpt_cur_block = -1; } -static void yaffs2_CheckpointFindNextCheckpointBlock(yaffs_Device *dev) +static void yaffs2_checkpt_find_block(struct yaffs_dev *dev) { - int i; - yaffs_ExtendedTags tags; + int i; + struct yaffs_ext_tags tags; - T(YAFFS_TRACE_CHECKPOINT, (TSTR("find next checkpt block: start: blocks %d next %d" TENDSTR), - dev->blocksInCheckpoint, dev->checkpointNextBlock)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("find next checkpt block: start: blocks %d next %d" TENDSTR), + dev->blocks_in_checkpt, dev->checkpt_next_block)); - if (dev->blocksInCheckpoint < dev->checkpointMaxBlocks) - for (i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++) { - int chunk = i * dev->param.nChunksPerBlock; - int realignedChunk = chunk - dev->chunkOffset; + if (dev->blocks_in_checkpt < dev->checkpt_max_blocks) + for (i = dev->checkpt_next_block; i <= dev->internal_end_block; + i++) { + int chunk = i * dev->param.chunks_per_block; + int realigned_chunk = chunk - dev->chunk_offset; - dev->param.readChunkWithTagsFromNAND(dev, realignedChunk, - NULL, &tags); - T(YAFFS_TRACE_CHECKPOINT, (TSTR("find next checkpt block: search: block %d oid %d seq %d eccr %d" TENDSTR), - i, tags.objectId, tags.sequenceNumber, tags.eccResult)); + dev->param.read_chunk_tags_fn(dev, realigned_chunk, + NULL, &tags); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR + ("find next checkpt block: search: block %d oid %d seq %d eccr %d" + TENDSTR), i, tags.obj_id, tags.seq_number, + tags.ecc_result)); - if (tags.sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA) { + if (tags.seq_number == YAFFS_SEQUENCE_CHECKPOINT_DATA) { /* Right kind of block */ - dev->checkpointNextBlock = tags.objectId; - dev->checkpointCurrentBlock = i; - dev->checkpointBlockList[dev->blocksInCheckpoint] = i; - dev->blocksInCheckpoint++; - T(YAFFS_TRACE_CHECKPOINT, (TSTR("found checkpt block %d"TENDSTR), i)); + dev->checkpt_next_block = tags.obj_id; + dev->checkpt_cur_block = i; + dev->checkpt_block_list[dev-> + blocks_in_checkpt] = i; + dev->blocks_in_checkpt++; + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("found checkpt block %d" TENDSTR), i)); return; } } - T(YAFFS_TRACE_CHECKPOINT, (TSTR("found no more checkpt blocks"TENDSTR))); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("found no more checkpt blocks" TENDSTR))); - dev->checkpointNextBlock = -1; - dev->checkpointCurrentBlock = -1; + dev->checkpt_next_block = -1; + dev->checkpt_cur_block = -1; } - -int yaffs2_CheckpointOpen(yaffs_Device *dev, int forWriting) +int yaffs2_checkpt_open(struct yaffs_dev *dev, int writing) { - - dev->checkpointOpenForWrite = forWriting; + dev->checkpt_open_write = writing; /* Got the functions we need? */ - if (!dev->param.writeChunkWithTagsToNAND || - !dev->param.readChunkWithTagsFromNAND || - !dev->param.eraseBlockInNAND || - !dev->param.markNANDBlockBad) + if (!dev->param.write_chunk_tags_fn || + !dev->param.read_chunk_tags_fn || + !dev->param.erase_fn || !dev->param.bad_block_fn) return 0; - if (forWriting && !yaffs2_CheckpointSpaceOk(dev)) + if (writing && !yaffs2_checkpt_space_ok(dev)) return 0; - if (!dev->checkpointBuffer) - dev->checkpointBuffer = YMALLOC_DMA(dev->param.totalBytesPerChunk); - if (!dev->checkpointBuffer) + if (!dev->checkpt_buffer) + dev->checkpt_buffer = + YMALLOC_DMA(dev->param.total_bytes_per_chunk); + if (!dev->checkpt_buffer) return 0; - - dev->checkpointPageSequence = 0; - dev->checkpointByteCount = 0; - dev->checkpointSum = 0; - dev->checkpointXor = 0; - dev->checkpointCurrentBlock = -1; - dev->checkpointCurrentChunk = -1; - dev->checkpointNextBlock = dev->internalStartBlock; + dev->checkpt_page_seq = 0; + dev->checkpt_byte_count = 0; + dev->checkpt_sum = 0; + dev->checkpt_xor = 0; + dev->checkpt_cur_block = -1; + dev->checkpt_cur_chunk = -1; + dev->checkpt_next_block = dev->internal_start_block; /* Erase all the blocks in the checkpoint area */ - if (forWriting) { - memset(dev->checkpointBuffer, 0, dev->nDataBytesPerChunk); - dev->checkpointByteOffset = 0; - return yaffs2_CheckpointErase(dev); + if (writing) { + memset(dev->checkpt_buffer, 0, dev->data_bytes_per_chunk); + dev->checkpt_byte_offs = 0; + return yaffs_checkpt_erase(dev); } else { int i; /* Set to a value that will kick off a read */ - dev->checkpointByteOffset = dev->nDataBytesPerChunk; + dev->checkpt_byte_offs = dev->data_bytes_per_chunk; /* A checkpoint block list of 1 checkpoint block per 16 block is (hopefully) * going to be way more than we need */ - dev->blocksInCheckpoint = 0; - dev->checkpointMaxBlocks = (dev->internalEndBlock - dev->internalStartBlock)/16 + 2; - dev->checkpointBlockList = YMALLOC(sizeof(int) * dev->checkpointMaxBlocks); - if(!dev->checkpointBlockList) + dev->blocks_in_checkpt = 0; + dev->checkpt_max_blocks = + (dev->internal_end_block - dev->internal_start_block) / 16 + + 2; + dev->checkpt_block_list = + YMALLOC(sizeof(int) * dev->checkpt_max_blocks); + if (!dev->checkpt_block_list) return 0; - for (i = 0; i < dev->checkpointMaxBlocks; i++) - dev->checkpointBlockList[i] = -1; + for (i = 0; i < dev->checkpt_max_blocks; i++) + dev->checkpt_block_list[i] = -1; } return 1; } -int yaffs2_GetCheckpointSum(yaffs_Device *dev, __u32 *sum) +int yaffs2_get_checkpt_sum(struct yaffs_dev *dev, u32 * sum) { - __u32 compositeSum; - compositeSum = (dev->checkpointSum << 8) | (dev->checkpointXor & 0xFF); - *sum = compositeSum; + u32 composite_sum; + composite_sum = (dev->checkpt_sum << 8) | (dev->checkpt_xor & 0xFF); + *sum = composite_sum; return 1; } -static int yaffs2_CheckpointFlushBuffer(yaffs_Device *dev) +static int yaffs2_checkpt_flush_buffer(struct yaffs_dev *dev) { int chunk; - int realignedChunk; + int realigned_chunk; - yaffs_ExtendedTags tags; + struct yaffs_ext_tags tags; - if (dev->checkpointCurrentBlock < 0) { - yaffs2_CheckpointFindNextErasedBlock(dev); - dev->checkpointCurrentChunk = 0; + if (dev->checkpt_cur_block < 0) { + yaffs2_checkpt_find_erased_block(dev); + dev->checkpt_cur_chunk = 0; } - if (dev->checkpointCurrentBlock < 0) + if (dev->checkpt_cur_block < 0) return 0; - tags.chunkDeleted = 0; - tags.objectId = dev->checkpointNextBlock; /* Hint to next place to look */ - tags.chunkId = dev->checkpointPageSequence + 1; - tags.sequenceNumber = YAFFS_SEQUENCE_CHECKPOINT_DATA; - tags.byteCount = dev->nDataBytesPerChunk; - if (dev->checkpointCurrentChunk == 0) { + tags.is_deleted = 0; + tags.obj_id = dev->checkpt_next_block; /* Hint to next place to look */ + tags.chunk_id = dev->checkpt_page_seq + 1; + tags.seq_number = YAFFS_SEQUENCE_CHECKPOINT_DATA; + tags.n_bytes = dev->data_bytes_per_chunk; + if (dev->checkpt_cur_chunk == 0) { /* First chunk we write for the block? Set block state to checkpoint */ - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, dev->checkpointCurrentBlock); - bi->blockState = YAFFS_BLOCK_STATE_CHECKPOINT; - dev->blocksInCheckpoint++; + struct yaffs_block_info *bi = + yaffs_get_block_info(dev, dev->checkpt_cur_block); + bi->block_state = YAFFS_BLOCK_STATE_CHECKPOINT; + dev->blocks_in_checkpt++; } - chunk = dev->checkpointCurrentBlock * dev->param.nChunksPerBlock + dev->checkpointCurrentChunk; + chunk = + dev->checkpt_cur_block * dev->param.chunks_per_block + + dev->checkpt_cur_chunk; + T(YAFFS_TRACE_CHECKPOINT, + (TSTR + ("checkpoint wite buffer nand %d(%d:%d) objid %d chId %d" TENDSTR), + chunk, dev->checkpt_cur_block, dev->checkpt_cur_chunk, tags.obj_id, + tags.chunk_id)); - T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint wite buffer nand %d(%d:%d) objid %d chId %d" TENDSTR), - chunk, dev->checkpointCurrentBlock, dev->checkpointCurrentChunk, tags.objectId, tags.chunkId)); + realigned_chunk = chunk - dev->chunk_offset; - realignedChunk = chunk - dev->chunkOffset; + dev->n_page_writes++; - dev->nPageWrites++; - - dev->param.writeChunkWithTagsToNAND(dev, realignedChunk, - dev->checkpointBuffer, &tags); - dev->checkpointByteOffset = 0; - dev->checkpointPageSequence++; - dev->checkpointCurrentChunk++; - if (dev->checkpointCurrentChunk >= dev->param.nChunksPerBlock) { - dev->checkpointCurrentChunk = 0; - dev->checkpointCurrentBlock = -1; + dev->param.write_chunk_tags_fn(dev, realigned_chunk, + dev->checkpt_buffer, &tags); + dev->checkpt_byte_offs = 0; + dev->checkpt_page_seq++; + dev->checkpt_cur_chunk++; + if (dev->checkpt_cur_chunk >= dev->param.chunks_per_block) { + dev->checkpt_cur_chunk = 0; + dev->checkpt_cur_block = -1; } - memset(dev->checkpointBuffer, 0, dev->nDataBytesPerChunk); + memset(dev->checkpt_buffer, 0, dev->data_bytes_per_chunk); return 1; } - -int yaffs2_CheckpointWrite(yaffs_Device *dev, const void *data, int nBytes) +int yaffs2_checkpt_wr(struct yaffs_dev *dev, const void *data, int n_bytes) { int i = 0; int ok = 1; + u8 *data_bytes = (u8 *) data; - __u8 * dataBytes = (__u8 *)data; - - - - if (!dev->checkpointBuffer) + if (!dev->checkpt_buffer) return 0; - if (!dev->checkpointOpenForWrite) + if (!dev->checkpt_open_write) return -1; - while (i < nBytes && ok) { - dev->checkpointBuffer[dev->checkpointByteOffset] = *dataBytes; - dev->checkpointSum += *dataBytes; - dev->checkpointXor ^= *dataBytes; + while (i < n_bytes && ok) { + dev->checkpt_buffer[dev->checkpt_byte_offs] = *data_bytes; + dev->checkpt_sum += *data_bytes; + dev->checkpt_xor ^= *data_bytes; - dev->checkpointByteOffset++; + dev->checkpt_byte_offs++; i++; - dataBytes++; - dev->checkpointByteCount++; + data_bytes++; + dev->checkpt_byte_count++; - - if (dev->checkpointByteOffset < 0 || - dev->checkpointByteOffset >= dev->nDataBytesPerChunk) - ok = yaffs2_CheckpointFlushBuffer(dev); + if (dev->checkpt_byte_offs < 0 || + dev->checkpt_byte_offs >= dev->data_bytes_per_chunk) + ok = yaffs2_checkpt_flush_buffer(dev); } return i; } -int yaffs2_CheckpointRead(yaffs_Device *dev, void *data, int nBytes) +int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes) { int i = 0; int ok = 1; - yaffs_ExtendedTags tags; - + struct yaffs_ext_tags tags; int chunk; - int realignedChunk; + int realigned_chunk; - __u8 *dataBytes = (__u8 *)data; + u8 *data_bytes = (u8 *) data; - if (!dev->checkpointBuffer) + if (!dev->checkpt_buffer) return 0; - if (dev->checkpointOpenForWrite) + if (dev->checkpt_open_write) return -1; - while (i < nBytes && ok) { + while (i < n_bytes && ok) { + if (dev->checkpt_byte_offs < 0 || + dev->checkpt_byte_offs >= dev->data_bytes_per_chunk) { - if (dev->checkpointByteOffset < 0 || - dev->checkpointByteOffset >= dev->nDataBytesPerChunk) { - - if (dev->checkpointCurrentBlock < 0) { - yaffs2_CheckpointFindNextCheckpointBlock(dev); - dev->checkpointCurrentChunk = 0; + if (dev->checkpt_cur_block < 0) { + yaffs2_checkpt_find_block(dev); + dev->checkpt_cur_chunk = 0; } - if (dev->checkpointCurrentBlock < 0) + if (dev->checkpt_cur_block < 0) ok = 0; else { - chunk = dev->checkpointCurrentBlock * - dev->param.nChunksPerBlock + - dev->checkpointCurrentChunk; + chunk = dev->checkpt_cur_block * + dev->param.chunks_per_block + + dev->checkpt_cur_chunk; - realignedChunk = chunk - dev->chunkOffset; - - dev->nPageReads++; + realigned_chunk = chunk - dev->chunk_offset; + + dev->n_page_reads++; /* read in the next chunk */ - /* printf("read checkpoint page %d\n",dev->checkpointPage); */ - dev->param.readChunkWithTagsFromNAND(dev, - realignedChunk, - dev->checkpointBuffer, - &tags); + dev->param.read_chunk_tags_fn(dev, + realigned_chunk, + dev-> + checkpt_buffer, + &tags); - if (tags.chunkId != (dev->checkpointPageSequence + 1) || - tags.eccResult > YAFFS_ECC_RESULT_FIXED || - tags.sequenceNumber != YAFFS_SEQUENCE_CHECKPOINT_DATA) + if (tags.chunk_id != (dev->checkpt_page_seq + 1) + || tags.ecc_result > YAFFS_ECC_RESULT_FIXED + || tags.seq_number != + YAFFS_SEQUENCE_CHECKPOINT_DATA) ok = 0; - dev->checkpointByteOffset = 0; - dev->checkpointPageSequence++; - dev->checkpointCurrentChunk++; + dev->checkpt_byte_offs = 0; + dev->checkpt_page_seq++; + dev->checkpt_cur_chunk++; - if (dev->checkpointCurrentChunk >= dev->param.nChunksPerBlock) - dev->checkpointCurrentBlock = -1; + if (dev->checkpt_cur_chunk >= + dev->param.chunks_per_block) + dev->checkpt_cur_block = -1; } } if (ok) { - *dataBytes = dev->checkpointBuffer[dev->checkpointByteOffset]; - dev->checkpointSum += *dataBytes; - dev->checkpointXor ^= *dataBytes; - dev->checkpointByteOffset++; + *data_bytes = + dev->checkpt_buffer[dev->checkpt_byte_offs]; + dev->checkpt_sum += *data_bytes; + dev->checkpt_xor ^= *data_bytes; + dev->checkpt_byte_offs++; i++; - dataBytes++; - dev->checkpointByteCount++; + data_bytes++; + dev->checkpt_byte_count++; } } - return i; + return i; } -int yaffs2_CheckpointClose(yaffs_Device *dev) +int yaffs_checkpt_close(struct yaffs_dev *dev) { - if (dev->checkpointOpenForWrite) { - if (dev->checkpointByteOffset != 0) - yaffs2_CheckpointFlushBuffer(dev); - } else if(dev->checkpointBlockList){ + if (dev->checkpt_open_write) { + if (dev->checkpt_byte_offs != 0) + yaffs2_checkpt_flush_buffer(dev); + } else if (dev->checkpt_block_list) { int i; - for (i = 0; i < dev->blocksInCheckpoint && dev->checkpointBlockList[i] >= 0; i++) { - int blk = dev->checkpointBlockList[i]; - yaffs_BlockInfo *bi = NULL; - if( dev->internalStartBlock <= blk && blk <= dev->internalEndBlock) - bi = yaffs_GetBlockInfo(dev, blk); - if (bi && bi->blockState == YAFFS_BLOCK_STATE_EMPTY) - bi->blockState = YAFFS_BLOCK_STATE_CHECKPOINT; + for (i = 0; + i < dev->blocks_in_checkpt + && dev->checkpt_block_list[i] >= 0; i++) { + int blk = dev->checkpt_block_list[i]; + struct yaffs_block_info *bi = NULL; + if (dev->internal_start_block <= blk + && blk <= dev->internal_end_block) + bi = yaffs_get_block_info(dev, blk); + if (bi && bi->block_state == YAFFS_BLOCK_STATE_EMPTY) + bi->block_state = YAFFS_BLOCK_STATE_CHECKPOINT; else { /* Todo this looks odd... */ } } - YFREE(dev->checkpointBlockList); - dev->checkpointBlockList = NULL; + YFREE(dev->checkpt_block_list); + dev->checkpt_block_list = NULL; } - dev->nFreeChunks -= dev->blocksInCheckpoint * dev->param.nChunksPerBlock; - dev->nErasedBlocks -= dev->blocksInCheckpoint; - + dev->n_free_chunks -= + dev->blocks_in_checkpt * dev->param.chunks_per_block; + dev->n_erased_blocks -= dev->blocks_in_checkpt; T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint byte count %d" TENDSTR), - dev->checkpointByteCount)); + dev->checkpt_byte_count)); - if (dev->checkpointBuffer) { + if (dev->checkpt_buffer) { /* free the buffer */ - YFREE(dev->checkpointBuffer); - dev->checkpointBuffer = NULL; + YFREE(dev->checkpt_buffer); + dev->checkpt_buffer = NULL; return 1; } else return 0; } -int yaffs2_CheckpointInvalidateStream(yaffs_Device *dev) +int yaffs2_checkpt_invalidate_stream(struct yaffs_dev *dev) { /* Erase the checkpoint data */ - T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint invalidate of %d blocks"TENDSTR), - dev->blocksInCheckpoint)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("checkpoint invalidate of %d blocks" TENDSTR), + dev->blocks_in_checkpt)); - return yaffs2_CheckpointErase(dev); + return yaffs_checkpt_erase(dev); } - - - diff --git a/fs/yaffs2/yaffs_checkptrw.h b/fs/yaffs2/yaffs_checkptrw.h index ea4f0276..361c6067 100644 --- a/fs/yaffs2/yaffs_checkptrw.h +++ b/fs/yaffs2/yaffs_checkptrw.h @@ -18,17 +18,16 @@ #include "yaffs_guts.h" -int yaffs2_CheckpointOpen(yaffs_Device *dev, int forWriting); +int yaffs2_checkpt_open(struct yaffs_dev *dev, int writing); -int yaffs2_CheckpointWrite(yaffs_Device *dev, const void *data, int nBytes); +int yaffs2_checkpt_wr(struct yaffs_dev *dev, const void *data, int n_bytes); -int yaffs2_CheckpointRead(yaffs_Device *dev, void *data, int nBytes); +int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes); -int yaffs2_GetCheckpointSum(yaffs_Device *dev, __u32 *sum); +int yaffs2_get_checkpt_sum(struct yaffs_dev *dev, u32 * sum); -int yaffs2_CheckpointClose(yaffs_Device *dev); - -int yaffs2_CheckpointInvalidateStream(yaffs_Device *dev); +int yaffs_checkpt_close(struct yaffs_dev *dev); +int yaffs2_checkpt_invalidate_stream(struct yaffs_dev *dev); #endif diff --git a/fs/yaffs2/yaffs_ecc.c b/fs/yaffs2/yaffs_ecc.c index da6145aa..0ea0305e 100644 --- a/fs/yaffs2/yaffs_ecc.c +++ b/fs/yaffs2/yaffs_ecc.c @@ -69,7 +69,7 @@ static const unsigned char column_parity_table[] = { /* Count the bits in an unsigned char or a U32 */ -static int yaffs_CountBits(unsigned char x) +static int yaffs_count_bits(unsigned char x) { int r = 0; while (x) { @@ -80,7 +80,7 @@ static int yaffs_CountBits(unsigned char x) return r; } -static int yaffs_CountBits32(unsigned x) +static int yaffs_count_bits32(unsigned x) { int r = 0; while (x) { @@ -92,7 +92,7 @@ static int yaffs_CountBits32(unsigned x) } /* Calculate the ECC for a 256-byte block of data */ -void yaffs_ECCCalculate(const unsigned char *data, unsigned char *ecc) +void yaffs_ecc_cacl(const unsigned char *data, unsigned char *ecc) { unsigned int i; @@ -106,7 +106,7 @@ void yaffs_ECCCalculate(const unsigned char *data, unsigned char *ecc) b = column_parity_table[*data++]; col_parity ^= b; - if (b & 0x01) { /* odd number of bits in the byte */ + if (b & 0x01) { /* odd number of bits in the byte */ line_parity ^= i; line_parity_prime ^= ~i; } @@ -160,11 +160,10 @@ void yaffs_ECCCalculate(const unsigned char *data, unsigned char *ecc) #endif } - /* Correct the ECC on a 256 byte block of data */ -int yaffs_ECCCorrect(unsigned char *data, unsigned char *read_ecc, - const unsigned char *test_ecc) +int yaffs_ecc_correct(unsigned char *data, unsigned char *read_ecc, + const unsigned char *test_ecc) { unsigned char d0, d1, d2; /* deltas */ @@ -173,7 +172,7 @@ int yaffs_ECCCorrect(unsigned char *data, unsigned char *read_ecc, d2 = read_ecc[2] ^ test_ecc[2]; if ((d0 | d1 | d2) == 0) - return 0; /* no error */ + return 0; /* no error */ if (((d0 ^ (d0 >> 1)) & 0x55) == 0x55 && ((d1 ^ (d1 >> 1)) & 0x55) == 0x55 && @@ -220,19 +219,18 @@ int yaffs_ECCCorrect(unsigned char *data, unsigned char *read_ecc, data[byte] ^= (1 << bit); - return 1; /* Corrected the error */ + return 1; /* Corrected the error */ } - if ((yaffs_CountBits(d0) + - yaffs_CountBits(d1) + - yaffs_CountBits(d2)) == 1) { + if ((yaffs_count_bits(d0) + + yaffs_count_bits(d1) + yaffs_count_bits(d2)) == 1) { /* Reccoverable error in ecc */ read_ecc[0] = test_ecc[0]; read_ecc[1] = test_ecc[1]; read_ecc[2] = test_ecc[2]; - return 1; /* Corrected the error */ + return 1; /* Corrected the error */ } /* Unrecoverable error */ @@ -241,12 +239,11 @@ int yaffs_ECCCorrect(unsigned char *data, unsigned char *read_ecc, } - /* * ECCxxxOther does ECC calcs on arbitrary n bytes of data */ -void yaffs_ECCCalculateOther(const unsigned char *data, unsigned nBytes, - yaffs_ECCOther *eccOther) +void yaffs_ecc_calc_other(const unsigned char *data, unsigned n_bytes, + struct yaffs_ecc_other *ecc_other) { unsigned int i; @@ -255,11 +252,11 @@ void yaffs_ECCCalculateOther(const unsigned char *data, unsigned nBytes, unsigned line_parity_prime = 0; unsigned char b; - for (i = 0; i < nBytes; i++) { + for (i = 0; i < n_bytes; i++) { b = column_parity_table[*data++]; col_parity ^= b; - if (b & 0x01) { + if (b & 0x01) { /* odd number of bits in the byte */ line_parity ^= i; line_parity_prime ^= ~i; @@ -267,54 +264,56 @@ void yaffs_ECCCalculateOther(const unsigned char *data, unsigned nBytes, } - eccOther->colParity = (col_parity >> 2) & 0x3f; - eccOther->lineParity = line_parity; - eccOther->lineParityPrime = line_parity_prime; + ecc_other->col_parity = (col_parity >> 2) & 0x3f; + ecc_other->line_parity = line_parity; + ecc_other->line_parity_prime = line_parity_prime; } -int yaffs_ECCCorrectOther(unsigned char *data, unsigned nBytes, - yaffs_ECCOther *read_ecc, - const yaffs_ECCOther *test_ecc) +int yaffs_ecc_correct_other(unsigned char *data, unsigned n_bytes, + struct yaffs_ecc_other *read_ecc, + const struct yaffs_ecc_other *test_ecc) { - unsigned char cDelta; /* column parity delta */ - unsigned lDelta; /* line parity delta */ - unsigned lDeltaPrime; /* line parity delta */ + unsigned char delta_col; /* column parity delta */ + unsigned delta_line; /* line parity delta */ + unsigned delta_line_prime; /* line parity delta */ unsigned bit; - cDelta = read_ecc->colParity ^ test_ecc->colParity; - lDelta = read_ecc->lineParity ^ test_ecc->lineParity; - lDeltaPrime = read_ecc->lineParityPrime ^ test_ecc->lineParityPrime; + delta_col = read_ecc->col_parity ^ test_ecc->col_parity; + delta_line = read_ecc->line_parity ^ test_ecc->line_parity; + delta_line_prime = + read_ecc->line_parity_prime ^ test_ecc->line_parity_prime; - if ((cDelta | lDelta | lDeltaPrime) == 0) - return 0; /* no error */ + if ((delta_col | delta_line | delta_line_prime) == 0) + return 0; /* no error */ - if (lDelta == ~lDeltaPrime && - (((cDelta ^ (cDelta >> 1)) & 0x15) == 0x15)) { + if (delta_line == ~delta_line_prime && + (((delta_col ^ (delta_col >> 1)) & 0x15) == 0x15)) { /* Single bit (recoverable) error in data */ bit = 0; - if (cDelta & 0x20) + if (delta_col & 0x20) bit |= 0x04; - if (cDelta & 0x08) + if (delta_col & 0x08) bit |= 0x02; - if (cDelta & 0x02) + if (delta_col & 0x02) bit |= 0x01; - if (lDelta >= nBytes) + if (delta_line >= n_bytes) return -1; - data[lDelta] ^= (1 << bit); + data[delta_line] ^= (1 << bit); - return 1; /* corrected */ + return 1; /* corrected */ } - if ((yaffs_CountBits32(lDelta) + yaffs_CountBits32(lDeltaPrime) + - yaffs_CountBits(cDelta)) == 1) { + if ((yaffs_count_bits32(delta_line) + + yaffs_count_bits32(delta_line_prime) + + yaffs_count_bits(delta_col)) == 1) { /* Reccoverable error in ecc */ *read_ecc = *test_ecc; - return 1; /* corrected */ + return 1; /* corrected */ } /* Unrecoverable error */ diff --git a/fs/yaffs2/yaffs_ecc.h b/fs/yaffs2/yaffs_ecc.h index a1ee69ac..b0c461d6 100644 --- a/fs/yaffs2/yaffs_ecc.h +++ b/fs/yaffs2/yaffs_ecc.h @@ -26,19 +26,19 @@ #ifndef __YAFFS_ECC_H__ #define __YAFFS_ECC_H__ -typedef struct { - unsigned char colParity; - unsigned lineParity; - unsigned lineParityPrime; -} yaffs_ECCOther; +struct yaffs_ecc_other { + unsigned char col_parity; + unsigned line_parity; + unsigned line_parity_prime; +}; -void yaffs_ECCCalculate(const unsigned char *data, unsigned char *ecc); -int yaffs_ECCCorrect(unsigned char *data, unsigned char *read_ecc, - const unsigned char *test_ecc); +void yaffs_ecc_cacl(const unsigned char *data, unsigned char *ecc); +int yaffs_ecc_correct(unsigned char *data, unsigned char *read_ecc, + const unsigned char *test_ecc); -void yaffs_ECCCalculateOther(const unsigned char *data, unsigned nBytes, - yaffs_ECCOther *ecc); -int yaffs_ECCCorrectOther(unsigned char *data, unsigned nBytes, - yaffs_ECCOther *read_ecc, - const yaffs_ECCOther *test_ecc); +void yaffs_ecc_calc_other(const unsigned char *data, unsigned n_bytes, + struct yaffs_ecc_other *ecc); +int yaffs_ecc_correct_other(unsigned char *data, unsigned n_bytes, + struct yaffs_ecc_other *read_ecc, + const struct yaffs_ecc_other *test_ecc); #endif diff --git a/fs/yaffs2/yaffs_getblockinfo.h b/fs/yaffs2/yaffs_getblockinfo.h index 71fe1dee..108c3612 100644 --- a/fs/yaffs2/yaffs_getblockinfo.h +++ b/fs/yaffs2/yaffs_getblockinfo.h @@ -20,16 +20,17 @@ #include "yaffs_trace.h" /* Function to manipulate block info */ -static Y_INLINE yaffs_BlockInfo *yaffs_GetBlockInfo(yaffs_Device * dev, int blk) +static Y_INLINE struct yaffs_block_info *yaffs_get_block_info(struct yaffs_dev + *dev, int blk) { - if (blk < dev->internalStartBlock || blk > dev->internalEndBlock) { + if (blk < dev->internal_start_block || blk > dev->internal_end_block) { T(YAFFS_TRACE_ERROR, (TSTR - ("**>> yaffs: getBlockInfo block %d is not valid" TENDSTR), + ("**>> yaffs: get_block_info block %d is not valid" TENDSTR), blk)); YBUG(); } - return &dev->blockInfo[blk - dev->internalStartBlock]; + return &dev->block_info[blk - dev->internal_start_block]; } #endif diff --git a/fs/yaffs2/yaffs_guts.c b/fs/yaffs2/yaffs_guts.c index 7e97a5f0..a9fc46c0 100644 --- a/fs/yaffs2/yaffs_guts.c +++ b/fs/yaffs2/yaffs_guts.c @@ -10,10 +10,10 @@ * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. */ + #include "yportenv.h" #include "yaffs_trace.h" -#include "yaffsinterface.h" #include "yaffs_guts.h" #include "yaffs_tagsvalidity.h" #include "yaffs_getblockinfo.h" @@ -33,100 +33,97 @@ #include "yaffs_nameval.h" #include "yaffs_allocator.h" +#include "yaffs_attribs.h" + /* Note YAFFS_GC_GOOD_ENOUGH must be <= YAFFS_GC_PASSIVE_THRESHOLD */ #define YAFFS_GC_GOOD_ENOUGH 2 #define YAFFS_GC_PASSIVE_THRESHOLD 4 #include "yaffs_ecc.h" - - /* Robustification (if it ever comes about...) */ -static void yaffs_RetireBlock(yaffs_Device *dev, int blockInNAND); -static void yaffs_HandleWriteChunkError(yaffs_Device *dev, int chunkInNAND, - int erasedOk); -static void yaffs_HandleWriteChunkOk(yaffs_Device *dev, int chunkInNAND, - const __u8 *data, - const yaffs_ExtendedTags *tags); -static void yaffs_HandleUpdateChunk(yaffs_Device *dev, int chunkInNAND, - const yaffs_ExtendedTags *tags); +static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block); +static void yaffs_handle_chunk_wr_error(struct yaffs_dev *dev, int nand_chunk, + int erased_ok); +static void yaffs_handle_chunk_wr_ok(struct yaffs_dev *dev, int nand_chunk, + const u8 * data, + const struct yaffs_ext_tags *tags); +static void yaffs_handle_chunk_update(struct yaffs_dev *dev, int nand_chunk, + const struct yaffs_ext_tags *tags); /* Other local prototypes */ -static void yaffs_UpdateParent(yaffs_Object *obj); -static int yaffs_UnlinkObject(yaffs_Object *obj); -static int yaffs_ObjectHasCachedWriteData(yaffs_Object *obj); +static void yaffs_update_parent(struct yaffs_obj *obj); +static int yaffs_unlink_obj(struct yaffs_obj *obj); +static int yaffs_obj_cache_dirty(struct yaffs_obj *obj); -static int yaffs_WriteNewChunkWithTagsToNAND(yaffs_Device *dev, - const __u8 *buffer, - yaffs_ExtendedTags *tags, - int useReserve); +static int yaffs_write_new_chunk(struct yaffs_dev *dev, + const u8 * buffer, + struct yaffs_ext_tags *tags, int use_reserver); +static struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number, + enum yaffs_obj_type type); -static yaffs_Object *yaffs_CreateNewObject(yaffs_Device *dev, int number, - yaffs_ObjectType type); +static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer, + struct yaffs_xattr_mod *xmod); +static void yaffs_remove_obj_from_dir(struct yaffs_obj *obj); +static int yaffs_generic_obj_del(struct yaffs_obj *in); -static int yaffs_ApplyXMod(yaffs_Object *obj, char *buffer, yaffs_XAttrMod *xmod); +static int yaffs_check_chunk_erased(struct yaffs_dev *dev, int nand_chunk); -static void yaffs_RemoveObjectFromDirectory(yaffs_Object *obj); -static int yaffs_CheckStructures(void); -static int yaffs_DoGenericObjectDeletion(yaffs_Object *in); +static int yaffs_unlink_worker(struct yaffs_obj *obj); -static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev, - int chunkInNAND); +static int yaffs_tags_match(const struct yaffs_ext_tags *tags, int obj_id, + int chunk_obj); -static int yaffs_UnlinkWorker(yaffs_Object *obj); +static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver, + struct yaffs_block_info **block_ptr); -static int yaffs_TagsMatch(const yaffs_ExtendedTags *tags, int objectId, - int chunkInObject); +static void yaffs_check_obj_details_loaded(struct yaffs_obj *in); -static int yaffs_AllocateChunk(yaffs_Device *dev, int useReserve, - yaffs_BlockInfo **blockUsedPtr); +static void yaffs_invalidate_whole_cache(struct yaffs_obj *in); +static void yaffs_invalidate_chunk_cache(struct yaffs_obj *object, + int chunk_id); -static void yaffs_CheckObjectDetailsLoaded(yaffs_Object *in); +static int yaffs_find_chunk_in_file(struct yaffs_obj *in, int inode_chunk, + struct yaffs_ext_tags *tags); -static void yaffs_InvalidateWholeChunkCache(yaffs_Object *in); -static void yaffs_InvalidateChunkCache(yaffs_Object *object, int chunkId); - -static int yaffs_FindChunkInFile(yaffs_Object *in, int chunkInInode, - yaffs_ExtendedTags *tags); - -static int yaffs_VerifyChunkWritten(yaffs_Device *dev, - int chunkInNAND, - const __u8 *data, - yaffs_ExtendedTags *tags); - - -static void yaffs_LoadNameFromObjectHeader(yaffs_Device *dev,YCHAR *name, const YCHAR *ohName, int bufferSize); -static void yaffs_LoadObjectHeaderFromName(yaffs_Device *dev,YCHAR *ohName, const YCHAR *name); +static int yaffs_verify_chunk_written(struct yaffs_dev *dev, + int nand_chunk, + const u8 * data, + struct yaffs_ext_tags *tags); +static void yaffs_load_name_from_oh(struct yaffs_dev *dev, YCHAR * name, + const YCHAR * oh_name, int buff_size); +static void yaffs_load_oh_from_name(struct yaffs_dev *dev, YCHAR * oh_name, + const YCHAR * name); /* Function to calculate chunk and offset */ -static void yaffs_AddrToChunk(yaffs_Device *dev, loff_t addr, int *chunkOut, - __u32 *offsetOut) +static void yaffs_addr_to_chunk(struct yaffs_dev *dev, loff_t addr, + int *chunk_out, u32 * offset_out) { int chunk; - __u32 offset; + u32 offset; - chunk = (__u32)(addr >> dev->chunkShift); + chunk = (u32) (addr >> dev->chunk_shift); - if (dev->chunkDiv == 1) { + if (dev->chunk_div == 1) { /* easy power of 2 case */ - offset = (__u32)(addr & dev->chunkMask); + offset = (u32) (addr & dev->chunk_mask); } else { /* Non power-of-2 case */ - loff_t chunkBase; + loff_t chunk_base; - chunk /= dev->chunkDiv; + chunk /= dev->chunk_div; - chunkBase = ((loff_t)chunk) * dev->nDataBytesPerChunk; - offset = (__u32)(addr - chunkBase); + chunk_base = ((loff_t) chunk) * dev->data_bytes_per_chunk; + offset = (u32) (addr - chunk_base); } - *chunkOut = chunk; - *offsetOut = offset; + *chunk_out = chunk; + *offset_out = offset; } /* Function to return the number of shifts for a power of 2 greater than or @@ -135,95 +132,94 @@ static void yaffs_AddrToChunk(yaffs_Device *dev, loff_t addr, int *chunkOut, * be hellishly efficient. */ -static __u32 ShiftsGE(__u32 x) +static u32 calc_shifts_ceiling(u32 x) { - int extraBits; - int nShifts; + int extra_bits; + int shifts; - nShifts = extraBits = 0; + shifts = extra_bits = 0; while (x > 1) { if (x & 1) - extraBits++; + extra_bits++; x >>= 1; - nShifts++; + shifts++; } - if (extraBits) - nShifts++; + if (extra_bits) + shifts++; - return nShifts; + return shifts; } /* Function to return the number of shifts to get a 1 in bit 0 */ -static __u32 Shifts(__u32 x) +static u32 calc_shifts(u32 x) { - __u32 nShifts; + u32 shifts; - nShifts = 0; + shifts = 0; if (!x) return 0; - while (!(x&1)) { + while (!(x & 1)) { x >>= 1; - nShifts++; + shifts++; } - return nShifts; + return shifts; } - - /* * Temporary buffer manipulations. */ -static int yaffs_InitialiseTempBuffers(yaffs_Device *dev) +static int yaffs_init_tmp_buffers(struct yaffs_dev *dev) { int i; - __u8 *buf = (__u8 *)1; + u8 *buf = (u8 *) 1; - memset(dev->tempBuffer, 0, sizeof(dev->tempBuffer)); + memset(dev->temp_buffer, 0, sizeof(dev->temp_buffer)); for (i = 0; buf && i < YAFFS_N_TEMP_BUFFERS; i++) { - dev->tempBuffer[i].line = 0; /* not in use */ - dev->tempBuffer[i].buffer = buf = - YMALLOC_DMA(dev->param.totalBytesPerChunk); + dev->temp_buffer[i].line = 0; /* not in use */ + dev->temp_buffer[i].buffer = buf = + YMALLOC_DMA(dev->param.total_bytes_per_chunk); } return buf ? YAFFS_OK : YAFFS_FAIL; } -__u8 *yaffs_GetTempBuffer(yaffs_Device *dev, int lineNo) +u8 *yaffs_get_temp_buffer(struct yaffs_dev * dev, int line_no) { int i, j; - dev->tempInUse++; - if (dev->tempInUse > dev->maxTemp) - dev->maxTemp = dev->tempInUse; + dev->temp_in_use++; + if (dev->temp_in_use > dev->max_temp) + dev->max_temp = dev->temp_in_use; for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) { - if (dev->tempBuffer[i].line == 0) { - dev->tempBuffer[i].line = lineNo; - if ((i + 1) > dev->maxTemp) { - dev->maxTemp = i + 1; + if (dev->temp_buffer[i].line == 0) { + dev->temp_buffer[i].line = line_no; + if ((i + 1) > dev->max_temp) { + dev->max_temp = i + 1; for (j = 0; j <= i; j++) - dev->tempBuffer[j].maxLine = - dev->tempBuffer[j].line; + dev->temp_buffer[j].max_line = + dev->temp_buffer[j].line; } - return dev->tempBuffer[i].buffer; + return dev->temp_buffer[i].buffer; } } T(YAFFS_TRACE_BUFFERS, (TSTR("Out of temp buffers at line %d, other held by lines:"), - lineNo)); + line_no)); for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) - T(YAFFS_TRACE_BUFFERS, (TSTR(" %d "), dev->tempBuffer[i].line)); + T(YAFFS_TRACE_BUFFERS, + (TSTR(" %d "), dev->temp_buffer[i].line)); T(YAFFS_TRACE_BUFFERS, (TSTR(" " TENDSTR))); @@ -232,21 +228,20 @@ __u8 *yaffs_GetTempBuffer(yaffs_Device *dev, int lineNo) * This is not good. */ - dev->unmanagedTempAllocations++; - return YMALLOC(dev->nDataBytesPerChunk); + dev->unmanaged_buffer_allocs++; + return YMALLOC(dev->data_bytes_per_chunk); } -void yaffs_ReleaseTempBuffer(yaffs_Device *dev, __u8 *buffer, - int lineNo) +void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 * buffer, int line_no) { int i; - dev->tempInUse--; + dev->temp_in_use--; for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) { - if (dev->tempBuffer[i].buffer == buffer) { - dev->tempBuffer[i].line = 0; + if (dev->temp_buffer[i].buffer == buffer) { + dev->temp_buffer[i].line = 0; return; } } @@ -255,9 +250,9 @@ void yaffs_ReleaseTempBuffer(yaffs_Device *dev, __u8 *buffer, /* assume it is an unmanaged one. */ T(YAFFS_TRACE_BUFFERS, (TSTR("Releasing unmanaged temp buffer in line %d" TENDSTR), - lineNo)); + line_no)); YFREE(buffer); - dev->unmanagedTempDeallocations++; + dev->unmanaged_buffer_deallocs++; } } @@ -265,25 +260,25 @@ void yaffs_ReleaseTempBuffer(yaffs_Device *dev, __u8 *buffer, /* * Determine if we have a managed buffer. */ -int yaffs_IsManagedTempBuffer(yaffs_Device *dev, const __u8 *buffer) +int yaffs_is_managed_tmp_buffer(struct yaffs_dev *dev, const u8 * buffer) { int i; for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) { - if (dev->tempBuffer[i].buffer == buffer) + if (dev->temp_buffer[i].buffer == buffer) return 1; } - for (i = 0; i < dev->param.nShortOpCaches; i++) { - if (dev->srCache[i].data == buffer) + for (i = 0; i < dev->param.n_caches; i++) { + if (dev->cache[i].data == buffer) return 1; } - if (buffer == dev->checkpointBuffer) + if (buffer == dev->checkpt_buffer) return 1; T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: unmaged buffer detected.\n" TENDSTR))); + (TSTR("yaffs: unmaged buffer detected.\n" TENDSTR))); return 0; } @@ -291,14 +286,11 @@ int yaffs_IsManagedTempBuffer(yaffs_Device *dev, const __u8 *buffer) * Verification code */ - - - /* * Simple hash function. Needs to have a reasonable spread */ -static Y_INLINE int yaffs_HashFunction(int n) +static Y_INLINE int yaffs_hash_fn(int n) { n = abs(n); return n % YAFFS_NOBJECT_BUCKETS; @@ -309,25 +301,24 @@ static Y_INLINE int yaffs_HashFunction(int n) * Note that root might have a presence in NAND if permissions are set. */ -yaffs_Object *yaffs_Root(yaffs_Device *dev) +struct yaffs_obj *yaffs_root(struct yaffs_dev *dev) { - return dev->rootDir; + return dev->root_dir; } -yaffs_Object *yaffs_LostNFound(yaffs_Device *dev) +struct yaffs_obj *yaffs_lost_n_found(struct yaffs_dev *dev) { - return dev->lostNFoundDir; + return dev->lost_n_found; } - /* * Erased NAND checking functions */ -int yaffs_CheckFF(__u8 *buffer, int nBytes) +int yaffs_check_ff(u8 * buffer, int n_bytes) { /* Horrible, slow implementation */ - while (nBytes--) { + while (n_bytes--) { if (*buffer != 0xFF) return 0; buffer++; @@ -335,70 +326,67 @@ int yaffs_CheckFF(__u8 *buffer, int nBytes) return 1; } -static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev, - int chunkInNAND) +static int yaffs_check_chunk_erased(struct yaffs_dev *dev, int nand_chunk) { int retval = YAFFS_OK; - __u8 *data = yaffs_GetTempBuffer(dev, __LINE__); - yaffs_ExtendedTags tags; + u8 *data = yaffs_get_temp_buffer(dev, __LINE__); + struct yaffs_ext_tags tags; int result; - result = yaffs_ReadChunkWithTagsFromNAND(dev, chunkInNAND, data, &tags); + result = yaffs_rd_chunk_tags_nand(dev, nand_chunk, data, &tags); - if (tags.eccResult > YAFFS_ECC_RESULT_NO_ERROR) + if (tags.ecc_result > YAFFS_ECC_RESULT_NO_ERROR) retval = YAFFS_FAIL; - if (!yaffs_CheckFF(data, dev->nDataBytesPerChunk) || tags.chunkUsed) { + if (!yaffs_check_ff(data, dev->data_bytes_per_chunk) || tags.chunk_used) { T(YAFFS_TRACE_NANDACCESS, - (TSTR("Chunk %d not erased" TENDSTR), chunkInNAND)); + (TSTR("Chunk %d not erased" TENDSTR), nand_chunk)); retval = YAFFS_FAIL; } - yaffs_ReleaseTempBuffer(dev, data, __LINE__); + yaffs_release_temp_buffer(dev, data, __LINE__); return retval; } - -static int yaffs_VerifyChunkWritten(yaffs_Device *dev, - int chunkInNAND, - const __u8 *data, - yaffs_ExtendedTags *tags) +static int yaffs_verify_chunk_written(struct yaffs_dev *dev, + int nand_chunk, + const u8 * data, + struct yaffs_ext_tags *tags) { int retval = YAFFS_OK; - yaffs_ExtendedTags tempTags; - __u8 *buffer = yaffs_GetTempBuffer(dev,__LINE__); + struct yaffs_ext_tags temp_tags; + u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__); int result; - - result = yaffs_ReadChunkWithTagsFromNAND(dev,chunkInNAND,buffer,&tempTags); - if(memcmp(buffer,data,dev->nDataBytesPerChunk) || - tempTags.objectId != tags->objectId || - tempTags.chunkId != tags->chunkId || - tempTags.byteCount != tags->byteCount) + + result = yaffs_rd_chunk_tags_nand(dev, nand_chunk, buffer, &temp_tags); + if (memcmp(buffer, data, dev->data_bytes_per_chunk) || + temp_tags.obj_id != tags->obj_id || + temp_tags.chunk_id != tags->chunk_id || + temp_tags.n_bytes != tags->n_bytes) retval = YAFFS_FAIL; - yaffs_ReleaseTempBuffer(dev, buffer, __LINE__); + yaffs_release_temp_buffer(dev, buffer, __LINE__); return retval; } -static int yaffs_WriteNewChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev, - const __u8 *data, - yaffs_ExtendedTags *tags, - int useReserve) +static int yaffs_write_new_chunk(struct yaffs_dev *dev, + const u8 * data, + struct yaffs_ext_tags *tags, int use_reserver) { int attempts = 0; - int writeOk = 0; + int write_ok = 0; int chunk; - yaffs2_InvalidateCheckpoint(dev); + yaffs2_checkpt_invalidate(dev); do { - yaffs_BlockInfo *bi = 0; - int erasedOk = 0; + struct yaffs_block_info *bi = 0; + int erased_ok = 0; - chunk = yaffs_AllocateChunk(dev, useReserve, &bi); + chunk = yaffs_alloc_chunk(dev, use_reserver, &bi); if (chunk < 0) { /* no space */ break; @@ -410,7 +398,7 @@ static int yaffs_WriteNewChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev, * * Check the first page we try to write in a block. * If the check passes then we don't need to check any - * more. If the check fails, we check again... + * more. If the check fails, we check again... * If the block has been erased, we don't need to check. * * However, if the block has been prioritised for gc, @@ -431,103 +419,107 @@ static int yaffs_WriteNewChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev, /* let's give it a try */ attempts++; - if(dev->param.alwaysCheckErased) - bi->skipErasedCheck = 0; + if (dev->param.always_check_erased) + bi->skip_erased_check = 0; - if (!bi->skipErasedCheck) { - erasedOk = yaffs_CheckChunkErased(dev, chunk); - if (erasedOk != YAFFS_OK) { + if (!bi->skip_erased_check) { + erased_ok = yaffs_check_chunk_erased(dev, chunk); + if (erased_ok != YAFFS_OK) { T(YAFFS_TRACE_ERROR, - (TSTR("**>> yaffs chunk %d was not erased" - TENDSTR), chunk)); + (TSTR("**>> yaffs chunk %d was not erased" + TENDSTR), chunk)); /* If not erased, delete this one, * skip rest of block and * try another chunk */ - yaffs_DeleteChunk(dev,chunk,1,__LINE__); - yaffs_SkipRestOfBlock(dev); + yaffs_chunk_del(dev, chunk, 1, __LINE__); + yaffs_skip_rest_of_block(dev); continue; } } - writeOk = yaffs_WriteChunkWithTagsToNAND(dev, chunk, - data, tags); + write_ok = yaffs_wr_chunk_tags_nand(dev, chunk, data, tags); - if(!bi->skipErasedCheck) - writeOk = yaffs_VerifyChunkWritten(dev, chunk, data, tags); + if (!bi->skip_erased_check) + write_ok = + yaffs_verify_chunk_written(dev, chunk, data, tags); - if (writeOk != YAFFS_OK) { + if (write_ok != YAFFS_OK) { /* Clean up aborted write, skip to next block and * try another chunk */ - yaffs_HandleWriteChunkError(dev, chunk, erasedOk); + yaffs_handle_chunk_wr_error(dev, chunk, erased_ok); continue; } - bi->skipErasedCheck = 1; + bi->skip_erased_check = 1; /* Copy the data into the robustification buffer */ - yaffs_HandleWriteChunkOk(dev, chunk, data, tags); + yaffs_handle_chunk_wr_ok(dev, chunk, data, tags); - } while (writeOk != YAFFS_OK && - (yaffs_wr_attempts <= 0 || attempts <= yaffs_wr_attempts)); + } while (write_ok != YAFFS_OK && + (yaffs_wr_attempts <= 0 || attempts <= yaffs_wr_attempts)); - if (!writeOk) + if (!write_ok) chunk = -1; if (attempts > 1) { T(YAFFS_TRACE_ERROR, - (TSTR("**>> yaffs write required %d attempts" TENDSTR), - attempts)); + (TSTR("**>> yaffs write required %d attempts" TENDSTR), + attempts)); - dev->nRetriedWrites += (attempts - 1); + dev->n_retired_writes += (attempts - 1); } return chunk; } - - /* * Block retiring for handling a broken block. */ -static void yaffs_RetireBlock(yaffs_Device *dev, int blockInNAND) +static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block) { - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND); + struct yaffs_block_info *bi = yaffs_get_block_info(dev, flash_block); - yaffs2_InvalidateCheckpoint(dev); - - yaffs2_ClearOldestDirtySequence(dev,bi); + yaffs2_checkpt_invalidate(dev); - if (yaffs_MarkBlockBad(dev, blockInNAND) != YAFFS_OK) { - if (yaffs_EraseBlockInNAND(dev, blockInNAND) != YAFFS_OK) { - T(YAFFS_TRACE_ALWAYS, (TSTR( - "yaffs: Failed to mark bad and erase block %d" - TENDSTR), blockInNAND)); + yaffs2_clear_oldest_dirty_seq(dev, bi); + + if (yaffs_mark_bad(dev, flash_block) != YAFFS_OK) { + if (yaffs_erase_block(dev, flash_block) != YAFFS_OK) { + T(YAFFS_TRACE_ALWAYS, + (TSTR + ("yaffs: Failed to mark bad and erase block %d" + TENDSTR), flash_block)); } else { - yaffs_ExtendedTags tags; - int chunkId = blockInNAND * dev->param.nChunksPerBlock; + struct yaffs_ext_tags tags; + int chunk_id = + flash_block * dev->param.chunks_per_block; - __u8 *buffer = yaffs_GetTempBuffer(dev, __LINE__); + u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__); - memset(buffer, 0xff, dev->nDataBytesPerChunk); - yaffs_InitialiseTags(&tags); - tags.sequenceNumber = YAFFS_SEQUENCE_BAD_BLOCK; - if (dev->param.writeChunkWithTagsToNAND(dev, chunkId - - dev->chunkOffset, buffer, &tags) != YAFFS_OK) - T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Failed to " - TCONT("write bad block marker to block %d") - TENDSTR), blockInNAND)); + memset(buffer, 0xff, dev->data_bytes_per_chunk); + yaffs_init_tags(&tags); + tags.seq_number = YAFFS_SEQUENCE_BAD_BLOCK; + if (dev->param.write_chunk_tags_fn(dev, chunk_id - + dev->chunk_offset, + buffer, + &tags) != YAFFS_OK) + T(YAFFS_TRACE_ALWAYS, + (TSTR + ("yaffs: Failed to " + TCONT("write bad block marker to block %d") + TENDSTR), flash_block)); - yaffs_ReleaseTempBuffer(dev, buffer, __LINE__); + yaffs_release_temp_buffer(dev, buffer, __LINE__); } } - bi->blockState = YAFFS_BLOCK_STATE_DEAD; - bi->gcPrioritise = 0; - bi->needsRetiring = 0; + bi->block_state = YAFFS_BLOCK_STATE_DEAD; + bi->gc_prioritise = 0; + bi->needs_retiring = 0; - dev->nRetiredBlocks++; + dev->n_retired_blocks++; } /* @@ -535,76 +527,74 @@ static void yaffs_RetireBlock(yaffs_Device *dev, int blockInNAND) * */ -static void yaffs_HandleWriteChunkOk(yaffs_Device *dev, int chunkInNAND, - const __u8 *data, - const yaffs_ExtendedTags *tags) +static void yaffs_handle_chunk_wr_ok(struct yaffs_dev *dev, int nand_chunk, + const u8 * data, + const struct yaffs_ext_tags *tags) { - dev=dev; - chunkInNAND=chunkInNAND; - data=data; - tags=tags; + dev = dev; + nand_chunk = nand_chunk; + data = data; + tags = tags; } -static void yaffs_HandleUpdateChunk(yaffs_Device *dev, int chunkInNAND, - const yaffs_ExtendedTags *tags) +static void yaffs_handle_chunk_update(struct yaffs_dev *dev, int nand_chunk, + const struct yaffs_ext_tags *tags) { - dev=dev; - chunkInNAND=chunkInNAND; - tags=tags; + dev = dev; + nand_chunk = nand_chunk; + tags = tags; } -void yaffs_HandleChunkError(yaffs_Device *dev, yaffs_BlockInfo *bi) +void yaffs_handle_chunk_error(struct yaffs_dev *dev, + struct yaffs_block_info *bi) { - if (!bi->gcPrioritise) { - bi->gcPrioritise = 1; - dev->hasPendingPrioritisedGCs = 1; - bi->chunkErrorStrikes++; + if (!bi->gc_prioritise) { + bi->gc_prioritise = 1; + dev->has_pending_prioritised_gc = 1; + bi->chunk_error_strikes++; - if (bi->chunkErrorStrikes > 3) { - bi->needsRetiring = 1; /* Too many stikes, so retire this */ - T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Block struck out" TENDSTR))); + if (bi->chunk_error_strikes > 3) { + bi->needs_retiring = 1; /* Too many stikes, so retire this */ + T(YAFFS_TRACE_ALWAYS, + (TSTR("yaffs: Block struck out" TENDSTR))); } } } -static void yaffs_HandleWriteChunkError(yaffs_Device *dev, int chunkInNAND, - int erasedOk) +static void yaffs_handle_chunk_wr_error(struct yaffs_dev *dev, int nand_chunk, + int erased_ok) { - int blockInNAND = chunkInNAND / dev->param.nChunksPerBlock; - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND); + int flash_block = nand_chunk / dev->param.chunks_per_block; + struct yaffs_block_info *bi = yaffs_get_block_info(dev, flash_block); - yaffs_HandleChunkError(dev, bi); + yaffs_handle_chunk_error(dev, bi); - if (erasedOk) { + if (erased_ok) { /* Was an actual write failure, so mark the block for retirement */ - bi->needsRetiring = 1; + bi->needs_retiring = 1; T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, - (TSTR("**>> Block %d needs retiring" TENDSTR), blockInNAND)); + (TSTR("**>> Block %d needs retiring" TENDSTR), flash_block)); } /* Delete the chunk */ - yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__); - yaffs_SkipRestOfBlock(dev); + yaffs_chunk_del(dev, nand_chunk, 1, __LINE__); + yaffs_skip_rest_of_block(dev); } - /*---------------- Name handling functions ------------*/ -static __u16 yaffs_CalcNameSum(const YCHAR *name) +static u16 yaffs_calc_name_sum(const YCHAR * name) { - __u16 sum = 0; - __u16 i = 1; + u16 sum = 0; + u16 i = 1; - const YUCHAR *bname = (const YUCHAR *) name; + const YUCHAR *bname = (const YUCHAR *)name; if (bname) { - while ((*bname) && (i < (YAFFS_MAX_NAME_LENGTH/2))) { + while ((*bname) && (i < (YAFFS_MAX_NAME_LENGTH / 2))) { -#ifdef CONFIG_YAFFS_CASE_INSENSITIVE - sum += yaffs_toupper(*bname) * i; -#else - sum += (*bname) * i; -#endif + /* 0x1f mask is case insensitive */ + sum += ((*bname) & 0x1f) * i; i++; bname++; } @@ -612,27 +602,33 @@ static __u16 yaffs_CalcNameSum(const YCHAR *name) return sum; } -void yaffs_SetObjectName(yaffs_Object *obj, const YCHAR *name) +void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR * name) { #ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM - memset(obj->shortName, 0, sizeof(YCHAR) * (YAFFS_SHORT_NAME_LENGTH+1)); - if (name && yaffs_strnlen(name,YAFFS_SHORT_NAME_LENGTH+1) <= YAFFS_SHORT_NAME_LENGTH) - yaffs_strcpy(obj->shortName, name); + memset(obj->short_name, 0, + sizeof(YCHAR) * (YAFFS_SHORT_NAME_LENGTH + 1)); + if (name + && yaffs_strnlen(name, + YAFFS_SHORT_NAME_LENGTH + 1) <= + YAFFS_SHORT_NAME_LENGTH) + yaffs_strcpy(obj->short_name, name); else - obj->shortName[0] = _Y('\0'); + obj->short_name[0] = _Y('\0'); #endif - obj->sum = yaffs_CalcNameSum(name); + obj->sum = yaffs_calc_name_sum(name); } -void yaffs_SetObjectNameFromOH(yaffs_Object *obj, const yaffs_ObjectHeader *oh) +void yaffs_set_obj_name_from_oh(struct yaffs_obj *obj, + const struct yaffs_obj_hdr *oh) { #ifdef CONFIG_YAFFS_AUTO_UNICODE - YCHAR tmpName[YAFFS_MAX_NAME_LENGTH+1]; - memset(tmpName,0,sizeof(tmpName)); - yaffs_LoadNameFromObjectHeader(obj->myDev,tmpName,oh->name,YAFFS_MAX_NAME_LENGTH+1); - yaffs_SetObjectName(obj,tmpName); + YCHAR tmp_name[YAFFS_MAX_NAME_LENGTH + 1]; + memset(tmp_name, 0, sizeof(tmp_name)); + yaffs_load_name_from_oh(obj->my_dev, tmp_name, oh->name, + YAFFS_MAX_NAME_LENGTH + 1); + yaffs_set_obj_name(obj, tmp_name); #else - yaffs_SetObjectName(obj,oh->name); + yaffs_set_obj_name(obj, oh->name); #endif } @@ -643,91 +639,90 @@ void yaffs_SetObjectNameFromOH(yaffs_Object *obj, const yaffs_ObjectHeader *oh) * in the tnode. */ - -yaffs_Tnode *yaffs_GetTnode(yaffs_Device *dev) +struct yaffs_tnode *yaffs_get_tnode(struct yaffs_dev *dev) { - yaffs_Tnode *tn = yaffs_AllocateRawTnode(dev); - if (tn){ - memset(tn, 0, dev->tnodeSize); - dev->nTnodes++; + struct yaffs_tnode *tn = yaffs_alloc_raw_tnode(dev); + if (tn) { + memset(tn, 0, dev->tnode_size); + dev->n_tnodes++; } - dev->nCheckpointBlocksRequired = 0; /* force recalculation*/ + dev->checkpoint_blocks_required = 0; /* force recalculation */ return tn; } /* FreeTnode frees up a tnode and puts it back on the free list */ -static void yaffs_FreeTnode(yaffs_Device *dev, yaffs_Tnode *tn) +static void yaffs_free_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn) { - yaffs_FreeRawTnode(dev,tn); - dev->nTnodes--; - dev->nCheckpointBlocksRequired = 0; /* force recalculation*/ + yaffs_free_raw_tnode(dev, tn); + dev->n_tnodes--; + dev->checkpoint_blocks_required = 0; /* force recalculation */ } -static void yaffs_DeinitialiseTnodesAndObjects(yaffs_Device *dev) +static void yaffs_deinit_tnodes_and_objs(struct yaffs_dev *dev) { - yaffs_DeinitialiseRawTnodesAndObjects(dev); - dev->nObjects = 0; - dev->nTnodes = 0; + yaffs_deinit_raw_tnodes_and_objs(dev); + dev->n_obj = 0; + dev->n_tnodes = 0; } - -void yaffs_LoadLevel0Tnode(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos, - unsigned val) +void yaffs_load_tnode_0(struct yaffs_dev *dev, struct yaffs_tnode *tn, + unsigned pos, unsigned val) { - __u32 *map = (__u32 *)tn; - __u32 bitInMap; - __u32 bitInWord; - __u32 wordInMap; - __u32 mask; + u32 *map = (u32 *) tn; + u32 bit_in_map; + u32 bit_in_word; + u32 word_in_map; + u32 mask; pos &= YAFFS_TNODES_LEVEL0_MASK; - val >>= dev->chunkGroupBits; + val >>= dev->chunk_grp_bits; - bitInMap = pos * dev->tnodeWidth; - wordInMap = bitInMap / 32; - bitInWord = bitInMap & (32 - 1); + bit_in_map = pos * dev->tnode_width; + word_in_map = bit_in_map / 32; + bit_in_word = bit_in_map & (32 - 1); - mask = dev->tnodeMask << bitInWord; + mask = dev->tnode_mask << bit_in_word; - map[wordInMap] &= ~mask; - map[wordInMap] |= (mask & (val << bitInWord)); + map[word_in_map] &= ~mask; + map[word_in_map] |= (mask & (val << bit_in_word)); - if (dev->tnodeWidth > (32 - bitInWord)) { - bitInWord = (32 - bitInWord); - wordInMap++;; - mask = dev->tnodeMask >> (/*dev->tnodeWidth -*/ bitInWord); - map[wordInMap] &= ~mask; - map[wordInMap] |= (mask & (val >> bitInWord)); + if (dev->tnode_width > (32 - bit_in_word)) { + bit_in_word = (32 - bit_in_word); + word_in_map++;; + mask = + dev->tnode_mask >> ( /*dev->tnode_width - */ bit_in_word); + map[word_in_map] &= ~mask; + map[word_in_map] |= (mask & (val >> bit_in_word)); } } -__u32 yaffs_GetChunkGroupBase(yaffs_Device *dev, yaffs_Tnode *tn, - unsigned pos) +u32 yaffs_get_group_base(struct yaffs_dev *dev, struct yaffs_tnode *tn, + unsigned pos) { - __u32 *map = (__u32 *)tn; - __u32 bitInMap; - __u32 bitInWord; - __u32 wordInMap; - __u32 val; + u32 *map = (u32 *) tn; + u32 bit_in_map; + u32 bit_in_word; + u32 word_in_map; + u32 val; pos &= YAFFS_TNODES_LEVEL0_MASK; - bitInMap = pos * dev->tnodeWidth; - wordInMap = bitInMap / 32; - bitInWord = bitInMap & (32 - 1); + bit_in_map = pos * dev->tnode_width; + word_in_map = bit_in_map / 32; + bit_in_word = bit_in_map & (32 - 1); - val = map[wordInMap] >> bitInWord; + val = map[word_in_map] >> bit_in_word; - if (dev->tnodeWidth > (32 - bitInWord)) { - bitInWord = (32 - bitInWord); - wordInMap++;; - val |= (map[wordInMap] << bitInWord); + if (dev->tnode_width > (32 - bit_in_word)) { + bit_in_word = (32 - bit_in_word); + word_in_map++;; + val |= (map[word_in_map] << bit_in_word); } - val &= dev->tnodeMask; - val <<= dev->chunkGroupBits; + val &= dev->tnode_mask; + val <<= dev->chunk_grp_bits; return val; } @@ -735,48 +730,48 @@ __u32 yaffs_GetChunkGroupBase(yaffs_Device *dev, yaffs_Tnode *tn, /* ------------------- End of individual tnode manipulation -----------------*/ /* ---------Functions to manipulate the look-up tree (made up of tnodes) ------ - * The look up tree is represented by the top tnode and the number of topLevel + * The look up tree is represented by the top tnode and the number of top_level * in the tree. 0 means only the level 0 tnode is in the tree. */ /* FindLevel0Tnode finds the level 0 tnode, if one exists. */ -yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device *dev, - yaffs_FileStructure *fStruct, - __u32 chunkId) +struct yaffs_tnode *yaffs_find_tnode_0(struct yaffs_dev *dev, + struct yaffs_file_var *file_struct, + u32 chunk_id) { - yaffs_Tnode *tn = fStruct->top; - __u32 i; - int requiredTallness; - int level = fStruct->topLevel; + struct yaffs_tnode *tn = file_struct->top; + u32 i; + int required_depth; + int level = file_struct->top_level; - dev=dev; + dev = dev; /* Check sane level and chunk Id */ if (level < 0 || level > YAFFS_TNODES_MAX_LEVEL) return NULL; - if (chunkId > YAFFS_MAX_CHUNK_ID) + if (chunk_id > YAFFS_MAX_CHUNK_ID) return NULL; - /* First check we're tall enough (ie enough topLevel) */ + /* First check we're tall enough (ie enough top_level) */ - i = chunkId >> YAFFS_TNODES_LEVEL0_BITS; - requiredTallness = 0; + i = chunk_id >> YAFFS_TNODES_LEVEL0_BITS; + required_depth = 0; while (i) { i >>= YAFFS_TNODES_INTERNAL_BITS; - requiredTallness++; + required_depth++; } - if (requiredTallness > fStruct->topLevel) - return NULL; /* Not tall enough, so we can't find it */ + if (required_depth > file_struct->top_level) + return NULL; /* Not tall enough, so we can't find it */ /* Traverse down to level 0 */ while (level > 0 && tn) { - tn = tn->internal[(chunkId >> - (YAFFS_TNODES_LEVEL0_BITS + - (level - 1) * - YAFFS_TNODES_INTERNAL_BITS)) & - YAFFS_TNODES_INTERNAL_MASK]; + tn = tn->internal[(chunk_id >> + (YAFFS_TNODES_LEVEL0_BITS + + (level - 1) * + YAFFS_TNODES_INTERNAL_BITS)) & + YAFFS_TNODES_INTERNAL_MASK]; level--; } @@ -794,49 +789,48 @@ yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device *dev, * be plugged into the ttree. */ -yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device *dev, - yaffs_FileStructure *fStruct, - __u32 chunkId, - yaffs_Tnode *passedTn) +struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev, + struct yaffs_file_var *file_struct, + u32 chunk_id, + struct yaffs_tnode *passed_tn) { - int requiredTallness; + int required_depth; int i; int l; - yaffs_Tnode *tn; - - __u32 x; + struct yaffs_tnode *tn; + u32 x; /* Check sane level and page Id */ - if (fStruct->topLevel < 0 || fStruct->topLevel > YAFFS_TNODES_MAX_LEVEL) + if (file_struct->top_level < 0 + || file_struct->top_level > YAFFS_TNODES_MAX_LEVEL) return NULL; - if (chunkId > YAFFS_MAX_CHUNK_ID) + if (chunk_id > YAFFS_MAX_CHUNK_ID) return NULL; - /* First check we're tall enough (ie enough topLevel) */ + /* First check we're tall enough (ie enough top_level) */ - x = chunkId >> YAFFS_TNODES_LEVEL0_BITS; - requiredTallness = 0; + x = chunk_id >> YAFFS_TNODES_LEVEL0_BITS; + required_depth = 0; while (x) { x >>= YAFFS_TNODES_INTERNAL_BITS; - requiredTallness++; + required_depth++; } - - if (requiredTallness > fStruct->topLevel) { + if (required_depth > file_struct->top_level) { /* Not tall enough, gotta make the tree taller */ - for (i = fStruct->topLevel; i < requiredTallness; i++) { + for (i = file_struct->top_level; i < required_depth; i++) { - tn = yaffs_GetTnode(dev); + tn = yaffs_get_tnode(dev); if (tn) { - tn->internal[0] = fStruct->top; - fStruct->top = tn; - fStruct->topLevel++; + tn->internal[0] = file_struct->top; + file_struct->top = tn; + file_struct->top_level++; } else { T(YAFFS_TRACE_ERROR, - (TSTR("yaffs: no more tnodes" TENDSTR))); + (TSTR("yaffs: no more tnodes" TENDSTR))); return NULL; } } @@ -844,34 +838,35 @@ yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device *dev, /* Traverse down to level 0, adding anything we need */ - l = fStruct->topLevel; - tn = fStruct->top; + l = file_struct->top_level; + tn = file_struct->top; if (l > 0) { while (l > 0 && tn) { - x = (chunkId >> + x = (chunk_id >> (YAFFS_TNODES_LEVEL0_BITS + (l - 1) * YAFFS_TNODES_INTERNAL_BITS)) & YAFFS_TNODES_INTERNAL_MASK; - if ((l > 1) && !tn->internal[x]) { /* Add missing non-level-zero tnode */ - tn->internal[x] = yaffs_GetTnode(dev); - if(!tn->internal[x]) + tn->internal[x] = yaffs_get_tnode(dev); + if (!tn->internal[x]) return NULL; } else if (l == 1) { /* Looking from level 1 at level 0 */ - if (passedTn) { - /* If we already have one, then release it.*/ + if (passed_tn) { + /* If we already have one, then release it. */ if (tn->internal[x]) - yaffs_FreeTnode(dev, tn->internal[x]); - tn->internal[x] = passedTn; + yaffs_free_tnode(dev, + tn-> + internal[x]); + tn->internal[x] = passed_tn; } else if (!tn->internal[x]) { /* Don't have one, none passed in */ - tn->internal[x] = yaffs_GetTnode(dev); - if(!tn->internal[x]) + tn->internal[x] = yaffs_get_tnode(dev); + if (!tn->internal[x]) return NULL; } } @@ -881,151 +876,56 @@ yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device *dev, } } else { /* top is level 0 */ - if (passedTn) { - memcpy(tn, passedTn, (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8); - yaffs_FreeTnode(dev, passedTn); + if (passed_tn) { + memcpy(tn, passed_tn, + (dev->tnode_width * YAFFS_NTNODES_LEVEL0) / 8); + yaffs_free_tnode(dev, passed_tn); } } return tn; } -static int yaffs_FindChunkInGroup(yaffs_Device *dev, int theChunk, - yaffs_ExtendedTags *tags, int objectId, - int chunkInInode) +static int yaffs_find_chunk_in_group(struct yaffs_dev *dev, int the_chunk, + struct yaffs_ext_tags *tags, int obj_id, + int inode_chunk) { int j; - for (j = 0; theChunk && j < dev->chunkGroupSize; j++) { - if (yaffs_CheckChunkBit(dev, theChunk / dev->param.nChunksPerBlock, - theChunk % dev->param.nChunksPerBlock)) { - - if(dev->chunkGroupSize == 1) - return theChunk; + for (j = 0; the_chunk && j < dev->chunk_grp_size; j++) { + if (yaffs_check_chunk_bit + (dev, the_chunk / dev->param.chunks_per_block, + the_chunk % dev->param.chunks_per_block)) { + + if (dev->chunk_grp_size == 1) + return the_chunk; else { - yaffs_ReadChunkWithTagsFromNAND(dev, theChunk, NULL, - tags); - if (yaffs_TagsMatch(tags, objectId, chunkInInode)) { + yaffs_rd_chunk_tags_nand(dev, the_chunk, NULL, + tags); + if (yaffs_tags_match(tags, obj_id, inode_chunk)) { /* found it; */ - return theChunk; + return the_chunk; } } } - theChunk++; + the_chunk++; } return -1; } -#if 0 -/* Experimental code not being used yet. Might speed up file deletion */ -/* DeleteWorker scans backwards through the tnode tree and deletes all the - * chunks and tnodes in the file. - * Returns 1 if the tree was deleted. - * Returns 0 if it stopped early due to hitting the limit and the delete is incomplete. - */ - -static int yaffs_DeleteWorker(yaffs_Object *in, yaffs_Tnode *tn, __u32 level, - int chunkOffset, int *limit) +static void yaffs_soft_del_chunk(struct yaffs_dev *dev, int chunk) { - int i; - int chunkInInode; - int theChunk; - yaffs_ExtendedTags tags; - int foundChunk; - yaffs_Device *dev = in->myDev; - - int allDone = 1; - - if (tn) { - if (level > 0) { - for (i = YAFFS_NTNODES_INTERNAL - 1; allDone && i >= 0; - i--) { - if (tn->internal[i]) { - if (limit && (*limit) < 0) { - allDone = 0; - } else { - allDone = - yaffs_DeleteWorker(in, - tn-> - internal - [i], - level - - 1, - (chunkOffset - << - YAFFS_TNODES_INTERNAL_BITS) - + i, - limit); - } - if (allDone) { - yaffs_FreeTnode(dev, - tn-> - internal[i]); - tn->internal[i] = NULL; - } - } - } - return (allDone) ? 1 : 0; - } else if (level == 0) { - int hitLimit = 0; - - for (i = YAFFS_NTNODES_LEVEL0 - 1; i >= 0 && !hitLimit; - i--) { - theChunk = yaffs_GetChunkGroupBase(dev, tn, i); - if (theChunk) { - - chunkInInode = (chunkOffset << - YAFFS_TNODES_LEVEL0_BITS) + i; - - foundChunk = - yaffs_FindChunkInGroup(dev, - theChunk, - &tags, - in->objectId, - chunkInInode); - - if (foundChunk > 0) { - yaffs_DeleteChunk(dev, - foundChunk, 1, - __LINE__); - in->nDataChunks--; - if (limit) { - *limit = *limit - 1; - if (*limit <= 0) - hitLimit = 1; - } - - } - - yaffs_LoadLevel0Tnode(dev, tn, i, 0); - } - - } - return (i < 0) ? 1 : 0; - - } - - } - - return 1; - -} - -#endif - -static void yaffs_SoftDeleteChunk(yaffs_Device *dev, int chunk) -{ - yaffs_BlockInfo *theBlock; - unsigned blockNo; + struct yaffs_block_info *the_block; + unsigned block_no; T(YAFFS_TRACE_DELETION, (TSTR("soft delete chunk %d" TENDSTR), chunk)); - blockNo = chunk / dev->param.nChunksPerBlock; - theBlock = yaffs_GetBlockInfo(dev, blockNo); - if (theBlock) { - theBlock->softDeletions++; - dev->nFreeChunks++; - yaffs2_UpdateOldestDirtySequence(dev, blockNo, theBlock); + block_no = chunk / dev->param.chunks_per_block; + the_block = yaffs_get_block_info(dev, block_no); + if (the_block) { + the_block->soft_del_pages++; + dev->n_free_chunks++; + yaffs2_update_oldest_dirty_seq(dev, block_no, the_block); } } @@ -1035,51 +935,51 @@ static void yaffs_SoftDeleteChunk(yaffs_Device *dev, int chunk) * Thus, essentially this is the same as DeleteWorker except that the chunks are soft deleted. */ -static int yaffs_SoftDeleteWorker(yaffs_Object *in, yaffs_Tnode *tn, - __u32 level, int chunkOffset) +static int yaffs_soft_del_worker(struct yaffs_obj *in, struct yaffs_tnode *tn, + u32 level, int chunk_offset) { int i; - int theChunk; - int allDone = 1; - yaffs_Device *dev = in->myDev; + int the_chunk; + int all_done = 1; + struct yaffs_dev *dev = in->my_dev; if (tn) { if (level > 0) { - for (i = YAFFS_NTNODES_INTERNAL - 1; allDone && i >= 0; + for (i = YAFFS_NTNODES_INTERNAL - 1; all_done && i >= 0; i--) { if (tn->internal[i]) { - allDone = - yaffs_SoftDeleteWorker(in, - tn-> - internal[i], - level - 1, - (chunkOffset - << - YAFFS_TNODES_INTERNAL_BITS) - + i); - if (allDone) { - yaffs_FreeTnode(dev, - tn-> - internal[i]); + all_done = + yaffs_soft_del_worker(in, + tn->internal + [i], + level - 1, + (chunk_offset + << + YAFFS_TNODES_INTERNAL_BITS) + + i); + if (all_done) { + yaffs_free_tnode(dev, + tn->internal + [i]); tn->internal[i] = NULL; } else { /* Hoosterman... how could this happen? */ } } } - return (allDone) ? 1 : 0; + return (all_done) ? 1 : 0; } else if (level == 0) { for (i = YAFFS_NTNODES_LEVEL0 - 1; i >= 0; i--) { - theChunk = yaffs_GetChunkGroupBase(dev, tn, i); - if (theChunk) { + the_chunk = yaffs_get_group_base(dev, tn, i); + if (the_chunk) { /* Note this does not find the real chunk, only the chunk group. * We make an assumption that a chunk group is not larger than * a block. */ - yaffs_SoftDeleteChunk(dev, theChunk); - yaffs_LoadLevel0Tnode(dev, tn, i, 0); + yaffs_soft_del_chunk(dev, the_chunk); + yaffs_load_tnode_0(dev, tn, i, 0); } } @@ -1093,25 +993,25 @@ static int yaffs_SoftDeleteWorker(yaffs_Object *in, yaffs_Tnode *tn, } -static void yaffs_SoftDeleteFile(yaffs_Object *obj) +static void yaffs_soft_del_file(struct yaffs_obj *obj) { if (obj->deleted && - obj->variantType == YAFFS_OBJECT_TYPE_FILE && !obj->softDeleted) { - if (obj->nDataChunks <= 0) { + obj->variant_type == YAFFS_OBJECT_TYPE_FILE && !obj->soft_del) { + if (obj->n_data_chunks <= 0) { /* Empty file with no duplicate object headers, just delete it immediately */ - yaffs_FreeTnode(obj->myDev, - obj->variant.fileVariant.top); - obj->variant.fileVariant.top = NULL; + yaffs_free_tnode(obj->my_dev, + obj->variant.file_variant.top); + obj->variant.file_variant.top = NULL; T(YAFFS_TRACE_TRACING, (TSTR("yaffs: Deleting empty file %d" TENDSTR), - obj->objectId)); - yaffs_DoGenericObjectDeletion(obj); + obj->obj_id)); + yaffs_generic_obj_del(obj); } else { - yaffs_SoftDeleteWorker(obj, - obj->variant.fileVariant.top, - obj->variant.fileVariant. - topLevel, 0); - obj->softDeleted = 1; + yaffs_soft_del_worker(obj, + obj->variant.file_variant.top, + obj->variant. + file_variant.top_level, 0); + obj->soft_del = 1; } } } @@ -1131,41 +1031,44 @@ static void yaffs_SoftDeleteFile(yaffs_Object *obj) * If there is no data in a subtree then it is pruned. */ -static yaffs_Tnode *yaffs_PruneWorker(yaffs_Device *dev, yaffs_Tnode *tn, - __u32 level, int del0) +static struct yaffs_tnode *yaffs_prune_worker(struct yaffs_dev *dev, + struct yaffs_tnode *tn, u32 level, + int del0) { int i; - int hasData; + int has_data; if (tn) { - hasData = 0; + has_data = 0; - if(level > 0){ + if (level > 0) { for (i = 0; i < YAFFS_NTNODES_INTERNAL; i++) { if (tn->internal[i]) { tn->internal[i] = - yaffs_PruneWorker(dev, tn->internal[i], - level - 1, - (i == 0) ? del0 : 1); + yaffs_prune_worker(dev, + tn->internal[i], + level - 1, + (i == + 0) ? del0 : 1); } if (tn->internal[i]) - hasData++; + has_data++; } } else { - int tnodeSize_u32 = dev->tnodeSize/sizeof(__u32); - __u32 *map = (__u32 *)tn; + int tnode_size_u32 = dev->tnode_size / sizeof(u32); + u32 *map = (u32 *) tn; - for(i = 0; !hasData && i < tnodeSize_u32; i++){ - if(map[i]) - hasData++; - } - } + for (i = 0; !has_data && i < tnode_size_u32; i++) { + if (map[i]) + has_data++; + } + } - if (hasData == 0 && del0) { + if (has_data == 0 && del0) { /* Free and return NULL */ - yaffs_FreeTnode(dev, tn); + yaffs_free_tnode(dev, tn); tn = NULL; } @@ -1175,17 +1078,18 @@ static yaffs_Tnode *yaffs_PruneWorker(yaffs_Device *dev, yaffs_Tnode *tn, } -static int yaffs_PruneFileStructure(yaffs_Device *dev, - yaffs_FileStructure *fStruct) +static int yaffs_prune_tree(struct yaffs_dev *dev, + struct yaffs_file_var *file_struct) { int i; - int hasData; + int has_data; int done = 0; - yaffs_Tnode *tn; + struct yaffs_tnode *tn; - if (fStruct->topLevel > 0) { - fStruct->top = - yaffs_PruneWorker(dev, fStruct->top, fStruct->topLevel, 0); + if (file_struct->top_level > 0) { + file_struct->top = + yaffs_prune_worker(dev, file_struct->top, + file_struct->top_level, 0); /* Now we have a tree with all the non-zero branches NULL but the height * is the same as it was. @@ -1194,19 +1098,19 @@ static int yaffs_PruneFileStructure(yaffs_Device *dev, * (ie all the non-zero are NULL) */ - while (fStruct->topLevel && !done) { - tn = fStruct->top; + while (file_struct->top_level && !done) { + tn = file_struct->top; - hasData = 0; + has_data = 0; for (i = 1; i < YAFFS_NTNODES_INTERNAL; i++) { if (tn->internal[i]) - hasData++; + has_data++; } - if (!hasData) { - fStruct->top = tn->internal[0]; - fStruct->topLevel--; - yaffs_FreeTnode(dev, tn); + if (!has_data) { + file_struct->top = tn->internal[0]; + file_struct->top_level--; + yaffs_free_tnode(dev, tn); } else { done = 1; } @@ -1218,152 +1122,149 @@ static int yaffs_PruneFileStructure(yaffs_Device *dev, /*-------------------- End of File Structure functions.-------------------*/ - /* AllocateEmptyObject gets us a clean Object. Tries to make allocate more if we run out */ -static yaffs_Object *yaffs_AllocateEmptyObject(yaffs_Device *dev) +static struct yaffs_obj *yaffs_alloc_empty_obj(struct yaffs_dev *dev) { - yaffs_Object *obj = yaffs_AllocateRawObject(dev); + struct yaffs_obj *obj = yaffs_alloc_raw_obj(dev); if (obj) { - dev->nObjects++; + dev->n_obj++; /* Now sweeten it up... */ - memset(obj, 0, sizeof(yaffs_Object)); - obj->beingCreated = 1; - - obj->myDev = dev; - obj->hdrChunk = 0; - obj->variantType = YAFFS_OBJECT_TYPE_UNKNOWN; - YINIT_LIST_HEAD(&(obj->hardLinks)); - YINIT_LIST_HEAD(&(obj->hashLink)); - YINIT_LIST_HEAD(&obj->siblings); + memset(obj, 0, sizeof(struct yaffs_obj)); + obj->being_created = 1; + obj->my_dev = dev; + obj->hdr_chunk = 0; + obj->variant_type = YAFFS_OBJECT_TYPE_UNKNOWN; + INIT_LIST_HEAD(&(obj->hard_links)); + INIT_LIST_HEAD(&(obj->hash_link)); + INIT_LIST_HEAD(&obj->siblings); /* Now make the directory sane */ - if (dev->rootDir) { - obj->parent = dev->rootDir; - ylist_add(&(obj->siblings), &dev->rootDir->variant.directoryVariant.children); + if (dev->root_dir) { + obj->parent = dev->root_dir; + list_add(&(obj->siblings), + &dev->root_dir->variant.dir_variant.children); } /* Add it to the lost and found directory. - * NB Can't put root or lostNFound in lostNFound so - * check if lostNFound exists first + * NB Can't put root or lost-n-found in lost-n-found so + * check if lost-n-found exists first */ - if (dev->lostNFoundDir) - yaffs_AddObjectToDirectory(dev->lostNFoundDir, obj); + if (dev->lost_n_found) + yaffs_add_obj_to_dir(dev->lost_n_found, obj); - obj->beingCreated = 0; + obj->being_created = 0; } - dev->nCheckpointBlocksRequired = 0; /* force recalculation*/ + dev->checkpoint_blocks_required = 0; /* force recalculation */ return obj; } -static yaffs_Object *yaffs_CreateFakeDirectory(yaffs_Device *dev, int number, - __u32 mode) +static struct yaffs_obj *yaffs_create_fake_dir(struct yaffs_dev *dev, + int number, u32 mode) { - yaffs_Object *obj = - yaffs_CreateNewObject(dev, number, YAFFS_OBJECT_TYPE_DIRECTORY); + struct yaffs_obj *obj = + yaffs_new_obj(dev, number, YAFFS_OBJECT_TYPE_DIRECTORY); if (obj) { - obj->fake = 1; /* it is fake so it might have no NAND presence... */ - obj->renameAllowed = 0; /* ... and we're not allowed to rename it... */ - obj->unlinkAllowed = 0; /* ... or unlink it */ + obj->fake = 1; /* it is fake so it might have no NAND presence... */ + obj->rename_allowed = 0; /* ... and we're not allowed to rename it... */ + obj->unlink_allowed = 0; /* ... or unlink it */ obj->deleted = 0; obj->unlinked = 0; obj->yst_mode = mode; - obj->myDev = dev; - obj->hdrChunk = 0; /* Not a valid chunk. */ + obj->my_dev = dev; + obj->hdr_chunk = 0; /* Not a valid chunk. */ } return obj; } -static void yaffs_UnhashObject(yaffs_Object *obj) +static void yaffs_unhash_obj(struct yaffs_obj *obj) { int bucket; - yaffs_Device *dev = obj->myDev; + struct yaffs_dev *dev = obj->my_dev; /* If it is still linked into the bucket list, free from the list */ - if (!ylist_empty(&obj->hashLink)) { - ylist_del_init(&obj->hashLink); - bucket = yaffs_HashFunction(obj->objectId); - dev->objectBucket[bucket].count--; + if (!list_empty(&obj->hash_link)) { + list_del_init(&obj->hash_link); + bucket = yaffs_hash_fn(obj->obj_id); + dev->obj_bucket[bucket].count--; } } /* FreeObject frees up a Object and puts it back on the free list */ -static void yaffs_FreeObject(yaffs_Object *obj) +static void yaffs_free_obj(struct yaffs_obj *obj) { - yaffs_Device *dev = obj->myDev; + struct yaffs_dev *dev = obj->my_dev; - T(YAFFS_TRACE_OS, (TSTR("FreeObject %p inode %p"TENDSTR), obj, obj->myInode)); + T(YAFFS_TRACE_OS, + (TSTR("FreeObject %p inode %p" TENDSTR), obj, obj->my_inode)); if (!obj) YBUG(); if (obj->parent) YBUG(); - if (!ylist_empty(&obj->siblings)) + if (!list_empty(&obj->siblings)) YBUG(); - - if (obj->myInode) { + if (obj->my_inode) { /* We're still hooked up to a cached inode. * Don't delete now, but mark for later deletion */ - obj->deferedFree = 1; + obj->defered_free = 1; return; } - yaffs_UnhashObject(obj); + yaffs_unhash_obj(obj); - yaffs_FreeRawObject(dev,obj); - dev->nObjects--; - dev->nCheckpointBlocksRequired = 0; /* force recalculation*/ + yaffs_free_raw_obj(dev, obj); + dev->n_obj--; + dev->checkpoint_blocks_required = 0; /* force recalculation */ } - -void yaffs_HandleDeferedFree(yaffs_Object *obj) +void yaffs_handle_defered_free(struct yaffs_obj *obj) { - if (obj->deferedFree) - yaffs_FreeObject(obj); + if (obj->defered_free) + yaffs_free_obj(obj); } -static void yaffs_InitialiseTnodesAndObjects(yaffs_Device *dev) +static void yaffs_init_tnodes_and_objs(struct yaffs_dev *dev) { int i; - dev->nObjects = 0; - dev->nTnodes = 0; + dev->n_obj = 0; + dev->n_tnodes = 0; - yaffs_InitialiseRawTnodesAndObjects(dev); + yaffs_init_raw_tnodes_and_objs(dev); for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { - YINIT_LIST_HEAD(&dev->objectBucket[i].list); - dev->objectBucket[i].count = 0; + INIT_LIST_HEAD(&dev->obj_bucket[i].list); + dev->obj_bucket[i].count = 0; } } -static int yaffs_FindNiceObjectBucket(yaffs_Device *dev) +static int yaffs_find_nice_bucket(struct yaffs_dev *dev) { int i; int l = 999; int lowest = 999999; - /* Search for the shortest list or one that * isn't too long. */ for (i = 0; i < 10 && lowest > 4; i++) { - dev->bucketFinder++; - dev->bucketFinder %= YAFFS_NOBJECT_BUCKETS; - if (dev->objectBucket[dev->bucketFinder].count < lowest) { - lowest = dev->objectBucket[dev->bucketFinder].count; - l = dev->bucketFinder; + dev->bucket_finder++; + dev->bucket_finder %= YAFFS_NOBJECT_BUCKETS; + if (dev->obj_bucket[dev->bucket_finder].count < lowest) { + lowest = dev->obj_bucket[dev->bucket_finder].count; + l = dev->bucket_finder; } } @@ -1371,29 +1272,29 @@ static int yaffs_FindNiceObjectBucket(yaffs_Device *dev) return l; } -static int yaffs_CreateNewObjectNumber(yaffs_Device *dev) +static int yaffs_new_obj_id(struct yaffs_dev *dev) { - int bucket = yaffs_FindNiceObjectBucket(dev); + int bucket = yaffs_find_nice_bucket(dev); /* Now find an object value that has not already been taken * by scanning the list. */ int found = 0; - struct ylist_head *i; + struct list_head *i; - __u32 n = (__u32) bucket; + u32 n = (u32) bucket; - /* yaffs_CheckObjectHashSanity(); */ + /* yaffs_check_obj_hash_sane(); */ while (!found) { found = 1; n += YAFFS_NOBJECT_BUCKETS; - if (1 || dev->objectBucket[bucket].count > 0) { - ylist_for_each(i, &dev->objectBucket[bucket].list) { + if (1 || dev->obj_bucket[bucket].count > 0) { + list_for_each(i, &dev->obj_bucket[bucket].list) { /* If there is already one in the list */ - if (i && ylist_entry(i, yaffs_Object, - hashLink)->objectId == n) { + if (i && list_entry(i, struct yaffs_obj, + hash_link)->obj_id == n) { found = 0; } } @@ -1403,29 +1304,29 @@ static int yaffs_CreateNewObjectNumber(yaffs_Device *dev) return n; } -static void yaffs_HashObject(yaffs_Object *in) +static void yaffs_hash_obj(struct yaffs_obj *in) { - int bucket = yaffs_HashFunction(in->objectId); - yaffs_Device *dev = in->myDev; + int bucket = yaffs_hash_fn(in->obj_id); + struct yaffs_dev *dev = in->my_dev; - ylist_add(&in->hashLink, &dev->objectBucket[bucket].list); - dev->objectBucket[bucket].count++; + list_add(&in->hash_link, &dev->obj_bucket[bucket].list); + dev->obj_bucket[bucket].count++; } -yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device *dev, __u32 number) +struct yaffs_obj *yaffs_find_by_number(struct yaffs_dev *dev, u32 number) { - int bucket = yaffs_HashFunction(number); - struct ylist_head *i; - yaffs_Object *in; + int bucket = yaffs_hash_fn(number); + struct list_head *i; + struct yaffs_obj *in; - ylist_for_each(i, &dev->objectBucket[bucket].list) { + list_for_each(i, &dev->obj_bucket[bucket].list) { /* Look if it is in the list */ if (i) { - in = ylist_entry(i, yaffs_Object, hashLink); - if (in->objectId == number) { + in = list_entry(i, struct yaffs_obj, hash_link); + if (in->obj_id == number) { /* Don't tell the VFS about this one if it is defered free */ - if (in->deferedFree) + if (in->defered_free) return NULL; return in; @@ -1436,61 +1337,48 @@ yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device *dev, __u32 number) return NULL; } -yaffs_Object *yaffs_CreateNewObject(yaffs_Device *dev, int number, - yaffs_ObjectType type) +struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number, + enum yaffs_obj_type type) { - yaffs_Object *theObject=NULL; - yaffs_Tnode *tn = NULL; + struct yaffs_obj *the_obj = NULL; + struct yaffs_tnode *tn = NULL; if (number < 0) - number = yaffs_CreateNewObjectNumber(dev); + number = yaffs_new_obj_id(dev); if (type == YAFFS_OBJECT_TYPE_FILE) { - tn = yaffs_GetTnode(dev); + tn = yaffs_get_tnode(dev); if (!tn) return NULL; } - theObject = yaffs_AllocateEmptyObject(dev); - if (!theObject){ - if(tn) - yaffs_FreeTnode(dev,tn); + the_obj = yaffs_alloc_empty_obj(dev); + if (!the_obj) { + if (tn) + yaffs_free_tnode(dev, tn); return NULL; } + if (the_obj) { + the_obj->fake = 0; + the_obj->rename_allowed = 1; + the_obj->unlink_allowed = 1; + the_obj->obj_id = number; + yaffs_hash_obj(the_obj); + the_obj->variant_type = type; + yaffs_load_current_time(the_obj, 1, 1); - if (theObject) { - theObject->fake = 0; - theObject->renameAllowed = 1; - theObject->unlinkAllowed = 1; - theObject->objectId = number; - yaffs_HashObject(theObject); - theObject->variantType = type; -#ifdef CONFIG_YAFFS_WINCE - yfsd_WinFileTimeNow(theObject->win_atime); - theObject->win_ctime[0] = theObject->win_mtime[0] = - theObject->win_atime[0]; - theObject->win_ctime[1] = theObject->win_mtime[1] = - theObject->win_atime[1]; - -#else - - theObject->yst_atime = theObject->yst_mtime = - theObject->yst_ctime = Y_CURRENT_TIME; -#endif switch (type) { case YAFFS_OBJECT_TYPE_FILE: - theObject->variant.fileVariant.fileSize = 0; - theObject->variant.fileVariant.scannedFileSize = 0; - theObject->variant.fileVariant.shrinkSize = 0xFFFFFFFF; /* max __u32 */ - theObject->variant.fileVariant.topLevel = 0; - theObject->variant.fileVariant.top = tn; + the_obj->variant.file_variant.file_size = 0; + the_obj->variant.file_variant.scanned_size = 0; + the_obj->variant.file_variant.shrink_size = ~0; /* max */ + the_obj->variant.file_variant.top_level = 0; + the_obj->variant.file_variant.top = tn; break; case YAFFS_OBJECT_TYPE_DIRECTORY: - YINIT_LIST_HEAD(&theObject->variant.directoryVariant. - children); - YINIT_LIST_HEAD(&theObject->variant.directoryVariant. - dirty); + INIT_LIST_HEAD(&the_obj->variant.dir_variant.children); + INIT_LIST_HEAD(&the_obj->variant.dir_variant.dirty); break; case YAFFS_OBJECT_TYPE_SYMLINK: case YAFFS_OBJECT_TYPE_HARDLINK: @@ -1503,125 +1391,109 @@ yaffs_Object *yaffs_CreateNewObject(yaffs_Device *dev, int number, } } - return theObject; + return the_obj; } -yaffs_Object *yaffs_FindOrCreateObjectByNumber(yaffs_Device *dev, - int number, - yaffs_ObjectType type) +struct yaffs_obj *yaffs_find_or_create_by_number(struct yaffs_dev *dev, + int number, + enum yaffs_obj_type type) { - yaffs_Object *theObject = NULL; + struct yaffs_obj *the_obj = NULL; if (number > 0) - theObject = yaffs_FindObjectByNumber(dev, number); + the_obj = yaffs_find_by_number(dev, number); - if (!theObject) - theObject = yaffs_CreateNewObject(dev, number, type); + if (!the_obj) + the_obj = yaffs_new_obj(dev, number, type); - return theObject; + return the_obj; } - -YCHAR *yaffs_CloneString(const YCHAR *str) +YCHAR *yaffs_clone_str(const YCHAR * str) { - YCHAR *newStr = NULL; + YCHAR *new_str = NULL; int len; if (!str) str = _Y(""); - len = yaffs_strnlen(str,YAFFS_MAX_ALIAS_LENGTH); - newStr = YMALLOC((len + 1) * sizeof(YCHAR)); - if (newStr){ - yaffs_strncpy(newStr, str,len); - newStr[len] = 0; + len = yaffs_strnlen(str, YAFFS_MAX_ALIAS_LENGTH); + new_str = YMALLOC((len + 1) * sizeof(YCHAR)); + if (new_str) { + yaffs_strncpy(new_str, str, len); + new_str[len] = 0; } - return newStr; + return new_str; } /* * Mknod (create) a new object. - * equivalentObject only has meaning for a hard link; - * aliasString only has meaning for a symlink. + * equiv_obj only has meaning for a hard link; + * alias_str only has meaning for a symlink. * rdev only has meaning for devices (a subset of special objects) */ -static yaffs_Object *yaffs_MknodObject(yaffs_ObjectType type, - yaffs_Object *parent, - const YCHAR *name, - __u32 mode, - __u32 uid, - __u32 gid, - yaffs_Object *equivalentObject, - const YCHAR *aliasString, __u32 rdev) +static struct yaffs_obj *yaffs_create_obj(enum yaffs_obj_type type, + struct yaffs_obj *parent, + const YCHAR * name, + u32 mode, + u32 uid, + u32 gid, + struct yaffs_obj *equiv_obj, + const YCHAR * alias_str, u32 rdev) { - yaffs_Object *in; + struct yaffs_obj *in; YCHAR *str = NULL; - yaffs_Device *dev = parent->myDev; + struct yaffs_dev *dev = parent->my_dev; - /* Check if the entry exists. If it does then fail the call since we don't want a dup.*/ - if (yaffs_FindObjectByName(parent, name)) + /* Check if the entry exists. If it does then fail the call since we don't want a dup. */ + if (yaffs_find_by_name(parent, name)) return NULL; if (type == YAFFS_OBJECT_TYPE_SYMLINK) { - str = yaffs_CloneString(aliasString); + str = yaffs_clone_str(alias_str); if (!str) return NULL; } - in = yaffs_CreateNewObject(dev, -1, type); + in = yaffs_new_obj(dev, -1, type); - if (!in){ - if(str) + if (!in) { + if (str) YFREE(str); return NULL; } - - - - if (in) { - in->hdrChunk = 0; + in->hdr_chunk = 0; in->valid = 1; - in->variantType = type; + in->variant_type = type; in->yst_mode = mode; -#ifdef CONFIG_YAFFS_WINCE - yfsd_WinFileTimeNow(in->win_atime); - in->win_ctime[0] = in->win_mtime[0] = in->win_atime[0]; - in->win_ctime[1] = in->win_mtime[1] = in->win_atime[1]; + yaffs_attribs_init(in, gid, uid, rdev); -#else - in->yst_atime = in->yst_mtime = in->yst_ctime = Y_CURRENT_TIME; + in->n_data_chunks = 0; - in->yst_rdev = rdev; - in->yst_uid = uid; - in->yst_gid = gid; -#endif - in->nDataChunks = 0; - - yaffs_SetObjectName(in, name); + yaffs_set_obj_name(in, name); in->dirty = 1; - yaffs_AddObjectToDirectory(parent, in); + yaffs_add_obj_to_dir(parent, in); - in->myDev = parent->myDev; + in->my_dev = parent->my_dev; switch (type) { case YAFFS_OBJECT_TYPE_SYMLINK: - in->variant.symLinkVariant.alias = str; + in->variant.symlink_variant.alias = str; break; case YAFFS_OBJECT_TYPE_HARDLINK: - in->variant.hardLinkVariant.equivalentObject = - equivalentObject; - in->variant.hardLinkVariant.equivalentObjectId = - equivalentObject->objectId; - ylist_add(&in->hardLinks, &equivalentObject->hardLinks); + in->variant.hardlink_variant.equiv_obj = equiv_obj; + in->variant.hardlink_variant.equiv_id = + equiv_obj->obj_id; + list_add(&in->hard_links, &equiv_obj->hard_links); break; case YAFFS_OBJECT_TYPE_FILE: case YAFFS_OBJECT_TYPE_DIRECTORY: @@ -1631,184 +1503,189 @@ static yaffs_Object *yaffs_MknodObject(yaffs_ObjectType type, break; } - if (yaffs_UpdateObjectHeader(in, name, 0, 0, 0, NULL) < 0) { + if (yaffs_update_oh(in, name, 0, 0, 0, NULL) < 0) { /* Could not create the object header, fail the creation */ - yaffs_DeleteObject(in); + yaffs_del_obj(in); in = NULL; } - yaffs_UpdateParent(parent); + yaffs_update_parent(parent); } return in; } -yaffs_Object *yaffs_MknodFile(yaffs_Object *parent, const YCHAR *name, - __u32 mode, __u32 uid, __u32 gid) +struct yaffs_obj *yaffs_create_file(struct yaffs_obj *parent, + const YCHAR * name, u32 mode, u32 uid, + u32 gid) { - return yaffs_MknodObject(YAFFS_OBJECT_TYPE_FILE, parent, name, mode, + return yaffs_create_obj(YAFFS_OBJECT_TYPE_FILE, parent, name, mode, uid, gid, NULL, NULL, 0); } -yaffs_Object *yaffs_MknodDirectory(yaffs_Object *parent, const YCHAR *name, - __u32 mode, __u32 uid, __u32 gid) +struct yaffs_obj *yaffs_create_dir(struct yaffs_obj *parent, const YCHAR * name, + u32 mode, u32 uid, u32 gid) { - return yaffs_MknodObject(YAFFS_OBJECT_TYPE_DIRECTORY, parent, name, - mode, uid, gid, NULL, NULL, 0); + return yaffs_create_obj(YAFFS_OBJECT_TYPE_DIRECTORY, parent, name, + mode, uid, gid, NULL, NULL, 0); } -yaffs_Object *yaffs_MknodSpecial(yaffs_Object *parent, const YCHAR *name, - __u32 mode, __u32 uid, __u32 gid, __u32 rdev) +struct yaffs_obj *yaffs_create_special(struct yaffs_obj *parent, + const YCHAR * name, u32 mode, u32 uid, + u32 gid, u32 rdev) { - return yaffs_MknodObject(YAFFS_OBJECT_TYPE_SPECIAL, parent, name, mode, - uid, gid, NULL, NULL, rdev); + return yaffs_create_obj(YAFFS_OBJECT_TYPE_SPECIAL, parent, name, mode, + uid, gid, NULL, NULL, rdev); } -yaffs_Object *yaffs_MknodSymLink(yaffs_Object *parent, const YCHAR *name, - __u32 mode, __u32 uid, __u32 gid, - const YCHAR *alias) +struct yaffs_obj *yaffs_create_symlink(struct yaffs_obj *parent, + const YCHAR * name, u32 mode, u32 uid, + u32 gid, const YCHAR * alias) { - return yaffs_MknodObject(YAFFS_OBJECT_TYPE_SYMLINK, parent, name, mode, + return yaffs_create_obj(YAFFS_OBJECT_TYPE_SYMLINK, parent, name, mode, uid, gid, NULL, alias, 0); } -/* yaffs_Link returns the object id of the equivalent object.*/ -yaffs_Object *yaffs_Link(yaffs_Object *parent, const YCHAR *name, - yaffs_Object *equivalentObject) +/* yaffs_link_obj returns the object id of the equivalent object.*/ +struct yaffs_obj *yaffs_link_obj(struct yaffs_obj *parent, const YCHAR * name, + struct yaffs_obj *equiv_obj) { /* Get the real object in case we were fed a hard link as an equivalent object */ - equivalentObject = yaffs_GetEquivalentObject(equivalentObject); + equiv_obj = yaffs_get_equivalent_obj(equiv_obj); - if (yaffs_MknodObject + if (yaffs_create_obj (YAFFS_OBJECT_TYPE_HARDLINK, parent, name, 0, 0, 0, - equivalentObject, NULL, 0)) { - return equivalentObject; + equiv_obj, NULL, 0)) { + return equiv_obj; } else { return NULL; } } -static int yaffs_ChangeObjectName(yaffs_Object *obj, yaffs_Object *newDir, - const YCHAR *newName, int force, int shadows) +static int yaffs_change_obj_name(struct yaffs_obj *obj, + struct yaffs_obj *new_dir, + const YCHAR * new_name, int force, int shadows) { - int unlinkOp; - int deleteOp; + int unlink_op; + int del_op; - yaffs_Object *existingTarget; + struct yaffs_obj *existing_target; - if (newDir == NULL) - newDir = obj->parent; /* use the old directory */ + if (new_dir == NULL) + new_dir = obj->parent; /* use the old directory */ - if (newDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { + if (new_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { T(YAFFS_TRACE_ALWAYS, (TSTR - ("tragedy: yaffs_ChangeObjectName: newDir is not a directory" + ("tragedy: yaffs_change_obj_name: new_dir is not a directory" TENDSTR))); YBUG(); } /* TODO: Do we need this different handling for YAFFS2 and YAFFS1?? */ - if (obj->myDev->param.isYaffs2) - unlinkOp = (newDir == obj->myDev->unlinkedDir); + if (obj->my_dev->param.is_yaffs2) + unlink_op = (new_dir == obj->my_dev->unlinked_dir); else - unlinkOp = (newDir == obj->myDev->unlinkedDir - && obj->variantType == YAFFS_OBJECT_TYPE_FILE); + unlink_op = (new_dir == obj->my_dev->unlinked_dir + && obj->variant_type == YAFFS_OBJECT_TYPE_FILE); - deleteOp = (newDir == obj->myDev->deletedDir); + del_op = (new_dir == obj->my_dev->del_dir); - existingTarget = yaffs_FindObjectByName(newDir, newName); + existing_target = yaffs_find_by_name(new_dir, new_name); /* If the object is a file going into the unlinked directory, * then it is OK to just stuff it in since duplicate names are allowed. * else only proceed if the new name does not exist and if we're putting * it into a directory. */ - if ((unlinkOp || - deleteOp || + if ((unlink_op || + del_op || force || (shadows > 0) || - !existingTarget) && - newDir->variantType == YAFFS_OBJECT_TYPE_DIRECTORY) { - yaffs_SetObjectName(obj, newName); + !existing_target) && + new_dir->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) { + yaffs_set_obj_name(obj, new_name); obj->dirty = 1; - yaffs_AddObjectToDirectory(newDir, obj); + yaffs_add_obj_to_dir(new_dir, obj); - if (unlinkOp) + if (unlink_op) obj->unlinked = 1; /* If it is a deletion then we mark it as a shrink for gc purposes. */ - if (yaffs_UpdateObjectHeader(obj, newName, 0, deleteOp, shadows, NULL) >= 0) + if (yaffs_update_oh(obj, new_name, 0, del_op, shadows, NULL) >= + 0) return YAFFS_OK; } return YAFFS_FAIL; } -int yaffs_RenameObject(yaffs_Object *oldDir, const YCHAR *oldName, - yaffs_Object *newDir, const YCHAR *newName) +int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR * old_name, + struct yaffs_obj *new_dir, const YCHAR * new_name) { - yaffs_Object *obj = NULL; - yaffs_Object *existingTarget = NULL; + struct yaffs_obj *obj = NULL; + struct yaffs_obj *existing_target = NULL; int force = 0; int result; - yaffs_Device *dev; + struct yaffs_dev *dev; - - if (!oldDir || oldDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) + if (!old_dir || old_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) YBUG(); - if (!newDir || newDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) + if (!new_dir || new_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) YBUG(); - dev = oldDir->myDev; + dev = old_dir->my_dev; #ifdef CONFIG_YAFFS_CASE_INSENSITIVE - /* Special case for case insemsitive systems (eg. WinCE). + /* Special case for case insemsitive systems. * While look-up is case insensitive, the name isn't. * Therefore we might want to change x.txt to X.txt - */ - if (oldDir == newDir && yaffs_strcmp(oldName, newName) == 0) + */ + if (old_dir == new_dir && yaffs_strcmp(old_name, new_name) == 0) force = 1; #endif - if(yaffs_strnlen(newName,YAFFS_MAX_NAME_LENGTH+1) > YAFFS_MAX_NAME_LENGTH) + if (yaffs_strnlen(new_name, YAFFS_MAX_NAME_LENGTH + 1) > + YAFFS_MAX_NAME_LENGTH) /* ENAMETOOLONG */ return YAFFS_FAIL; - obj = yaffs_FindObjectByName(oldDir, oldName); + obj = yaffs_find_by_name(old_dir, old_name); - if (obj && obj->renameAllowed) { + if (obj && obj->rename_allowed) { /* Now do the handling for an existing target, if there is one */ - existingTarget = yaffs_FindObjectByName(newDir, newName); - if (existingTarget && - existingTarget->variantType == YAFFS_OBJECT_TYPE_DIRECTORY && - !ylist_empty(&existingTarget->variant.directoryVariant.children)) { + existing_target = yaffs_find_by_name(new_dir, new_name); + if (existing_target && + existing_target->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY + && !list_empty(&existing_target->variant.dir_variant. + children)) { /* There is a target that is a non-empty directory, so we fail */ return YAFFS_FAIL; /* EEXIST or ENOTEMPTY */ - } else if (existingTarget && existingTarget != obj) { + } else if (existing_target && existing_target != obj) { /* Nuke the target first, using shadowing, * but only if it isn't the same object. * * Note we must disable gc otherwise it can mess up the shadowing. * */ - dev->gcDisable=1; - yaffs_ChangeObjectName(obj, newDir, newName, force, - existingTarget->objectId); - existingTarget->isShadowed = 1; - yaffs_UnlinkObject(existingTarget); - dev->gcDisable=0; + dev->gc_disable = 1; + yaffs_change_obj_name(obj, new_dir, new_name, force, + existing_target->obj_id); + existing_target->is_shadowed = 1; + yaffs_unlink_obj(existing_target); + dev->gc_disable = 0; } - result = yaffs_ChangeObjectName(obj, newDir, newName, 1, 0); + result = yaffs_change_obj_name(obj, new_dir, new_name, 1, 0); + + yaffs_update_parent(old_dir); + if (new_dir != old_dir) + yaffs_update_parent(new_dir); - yaffs_UpdateParent(oldDir); - if(newDir != oldDir) - yaffs_UpdateParent(newDir); - return result; } return YAFFS_FAIL; @@ -1816,144 +1693,149 @@ int yaffs_RenameObject(yaffs_Object *oldDir, const YCHAR *oldName, /*------------------------- Block Management and Page Allocation ----------------*/ -static int yaffs_InitialiseBlocks(yaffs_Device *dev) +static int yaffs_init_blocks(struct yaffs_dev *dev) { - int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1; + int n_blocks = dev->internal_end_block - dev->internal_start_block + 1; - dev->blockInfo = NULL; - dev->chunkBits = NULL; + dev->block_info = NULL; + dev->chunk_bits = NULL; - dev->allocationBlock = -1; /* force it to get a new one */ + dev->alloc_block = -1; /* force it to get a new one */ /* If the first allocation strategy fails, thry the alternate one */ - dev->blockInfo = YMALLOC(nBlocks * sizeof(yaffs_BlockInfo)); - if (!dev->blockInfo) { - dev->blockInfo = YMALLOC_ALT(nBlocks * sizeof(yaffs_BlockInfo)); - dev->blockInfoAlt = 1; + dev->block_info = YMALLOC(n_blocks * sizeof(struct yaffs_block_info)); + if (!dev->block_info) { + dev->block_info = + YMALLOC_ALT(n_blocks * sizeof(struct yaffs_block_info)); + dev->block_info_alt = 1; } else - dev->blockInfoAlt = 0; + dev->block_info_alt = 0; - if (dev->blockInfo) { + if (dev->block_info) { /* Set up dynamic blockinfo stuff. */ - dev->chunkBitmapStride = (dev->param.nChunksPerBlock + 7) / 8; /* round up bytes */ - dev->chunkBits = YMALLOC(dev->chunkBitmapStride * nBlocks); - if (!dev->chunkBits) { - dev->chunkBits = YMALLOC_ALT(dev->chunkBitmapStride * nBlocks); - dev->chunkBitsAlt = 1; + dev->chunk_bit_stride = (dev->param.chunks_per_block + 7) / 8; /* round up bytes */ + dev->chunk_bits = YMALLOC(dev->chunk_bit_stride * n_blocks); + if (!dev->chunk_bits) { + dev->chunk_bits = + YMALLOC_ALT(dev->chunk_bit_stride * n_blocks); + dev->chunk_bits_alt = 1; } else - dev->chunkBitsAlt = 0; + dev->chunk_bits_alt = 0; } - if (dev->blockInfo && dev->chunkBits) { - memset(dev->blockInfo, 0, nBlocks * sizeof(yaffs_BlockInfo)); - memset(dev->chunkBits, 0, dev->chunkBitmapStride * nBlocks); + if (dev->block_info && dev->chunk_bits) { + memset(dev->block_info, 0, + n_blocks * sizeof(struct yaffs_block_info)); + memset(dev->chunk_bits, 0, dev->chunk_bit_stride * n_blocks); return YAFFS_OK; } return YAFFS_FAIL; } -static void yaffs_DeinitialiseBlocks(yaffs_Device *dev) +static void yaffs_deinit_blocks(struct yaffs_dev *dev) { - if (dev->blockInfoAlt && dev->blockInfo) - YFREE_ALT(dev->blockInfo); - else if (dev->blockInfo) - YFREE(dev->blockInfo); + if (dev->block_info_alt && dev->block_info) + YFREE_ALT(dev->block_info); + else if (dev->block_info) + YFREE(dev->block_info); - dev->blockInfoAlt = 0; + dev->block_info_alt = 0; - dev->blockInfo = NULL; + dev->block_info = NULL; - if (dev->chunkBitsAlt && dev->chunkBits) - YFREE_ALT(dev->chunkBits); - else if (dev->chunkBits) - YFREE(dev->chunkBits); - dev->chunkBitsAlt = 0; - dev->chunkBits = NULL; + if (dev->chunk_bits_alt && dev->chunk_bits) + YFREE_ALT(dev->chunk_bits); + else if (dev->chunk_bits) + YFREE(dev->chunk_bits); + dev->chunk_bits_alt = 0; + dev->chunk_bits = NULL; } -void yaffs_BlockBecameDirty(yaffs_Device *dev, int blockNo) +void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no) { - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockNo); + struct yaffs_block_info *bi = yaffs_get_block_info(dev, block_no); - int erasedOk = 0; + int erased_ok = 0; /* If the block is still healthy erase it and mark as clean. * If the block has had a data failure, then retire it. */ T(YAFFS_TRACE_GC | YAFFS_TRACE_ERASE, - (TSTR("yaffs_BlockBecameDirty block %d state %d %s"TENDSTR), - blockNo, bi->blockState, (bi->needsRetiring) ? "needs retiring" : "")); + (TSTR("yaffs_block_became_dirty block %d state %d %s" TENDSTR), + block_no, bi->block_state, + (bi->needs_retiring) ? "needs retiring" : "")); - yaffs2_ClearOldestDirtySequence(dev,bi); + yaffs2_clear_oldest_dirty_seq(dev, bi); - bi->blockState = YAFFS_BLOCK_STATE_DIRTY; + bi->block_state = YAFFS_BLOCK_STATE_DIRTY; /* If this is the block being garbage collected then stop gc'ing this block */ - if(blockNo == dev->gcBlock) - dev->gcBlock = 0; + if (block_no == dev->gc_block) + dev->gc_block = 0; /* If this block is currently the best candidate for gc then drop as a candidate */ - if(blockNo == dev->gcDirtiest){ - dev->gcDirtiest = 0; - dev->gcPagesInUse = 0; + if (block_no == dev->gc_dirtiest) { + dev->gc_dirtiest = 0; + dev->gc_pages_in_use = 0; } - if (!bi->needsRetiring) { - yaffs2_InvalidateCheckpoint(dev); - erasedOk = yaffs_EraseBlockInNAND(dev, blockNo); - if (!erasedOk) { - dev->nErasureFailures++; + if (!bi->needs_retiring) { + yaffs2_checkpt_invalidate(dev); + erased_ok = yaffs_erase_block(dev, block_no); + if (!erased_ok) { + dev->n_erase_failures++; T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, - (TSTR("**>> Erasure failed %d" TENDSTR), blockNo)); + (TSTR("**>> Erasure failed %d" TENDSTR), block_no)); } } - if (erasedOk && - ((yaffs_traceMask & YAFFS_TRACE_ERASE) || !yaffs_SkipVerification(dev))) { + if (erased_ok && + ((yaffs_trace_mask & YAFFS_TRACE_ERASE) + || !yaffs_skip_verification(dev))) { int i; - for (i = 0; i < dev->param.nChunksPerBlock; i++) { - if (!yaffs_CheckChunkErased - (dev, blockNo * dev->param.nChunksPerBlock + i)) { + for (i = 0; i < dev->param.chunks_per_block; i++) { + if (!yaffs_check_chunk_erased + (dev, block_no * dev->param.chunks_per_block + i)) { T(YAFFS_TRACE_ERROR, (TSTR (">>Block %d erasure supposedly OK, but chunk %d not erased" - TENDSTR), blockNo, i)); + TENDSTR), block_no, i)); } } } - if (erasedOk) { + if (erased_ok) { /* Clean it up... */ - bi->blockState = YAFFS_BLOCK_STATE_EMPTY; - bi->sequenceNumber = 0; - dev->nErasedBlocks++; - bi->pagesInUse = 0; - bi->softDeletions = 0; - bi->hasShrinkHeader = 0; - bi->skipErasedCheck = 1; /* This is clean, so no need to check */ - bi->gcPrioritise = 0; - yaffs_ClearChunkBits(dev, blockNo); + bi->block_state = YAFFS_BLOCK_STATE_EMPTY; + bi->seq_number = 0; + dev->n_erased_blocks++; + bi->pages_in_use = 0; + bi->soft_del_pages = 0; + bi->has_shrink_hdr = 0; + bi->skip_erased_check = 1; /* This is clean, so no need to check */ + bi->gc_prioritise = 0; + yaffs_clear_chunk_bits(dev, block_no); T(YAFFS_TRACE_ERASE, - (TSTR("Erased block %d" TENDSTR), blockNo)); + (TSTR("Erased block %d" TENDSTR), block_no)); } else { - dev->nFreeChunks -= dev->param.nChunksPerBlock; /* We lost a block of free space */ + dev->n_free_chunks -= dev->param.chunks_per_block; /* We lost a block of free space */ - yaffs_RetireBlock(dev, blockNo); + yaffs_retire_block(dev, block_no); T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, - (TSTR("**>> Block %d retired" TENDSTR), blockNo)); + (TSTR("**>> Block %d retired" TENDSTR), block_no)); } } -static int yaffs_FindBlockForAllocation(yaffs_Device *dev) +static int yaffs_find_alloc_block(struct yaffs_dev *dev) { int i; - yaffs_BlockInfo *bi; + struct yaffs_block_info *bi; - if (dev->nErasedBlocks < 1) { + if (dev->n_erased_blocks < 1) { /* Hoosterman we've got a problem. * Can't get space to gc */ @@ -1965,234 +1847,233 @@ static int yaffs_FindBlockForAllocation(yaffs_Device *dev) /* Find an empty block. */ - for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) { - dev->allocationBlockFinder++; - if (dev->allocationBlockFinder < dev->internalStartBlock - || dev->allocationBlockFinder > dev->internalEndBlock) { - dev->allocationBlockFinder = dev->internalStartBlock; + for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) { + dev->alloc_block_finder++; + if (dev->alloc_block_finder < dev->internal_start_block + || dev->alloc_block_finder > dev->internal_end_block) { + dev->alloc_block_finder = dev->internal_start_block; } - bi = yaffs_GetBlockInfo(dev, dev->allocationBlockFinder); + bi = yaffs_get_block_info(dev, dev->alloc_block_finder); - if (bi->blockState == YAFFS_BLOCK_STATE_EMPTY) { - bi->blockState = YAFFS_BLOCK_STATE_ALLOCATING; - dev->sequenceNumber++; - bi->sequenceNumber = dev->sequenceNumber; - dev->nErasedBlocks--; + if (bi->block_state == YAFFS_BLOCK_STATE_EMPTY) { + bi->block_state = YAFFS_BLOCK_STATE_ALLOCATING; + dev->seq_number++; + bi->seq_number = dev->seq_number; + dev->n_erased_blocks--; T(YAFFS_TRACE_ALLOCATE, (TSTR("Allocated block %d, seq %d, %d left" TENDSTR), - dev->allocationBlockFinder, dev->sequenceNumber, - dev->nErasedBlocks)); - return dev->allocationBlockFinder; + dev->alloc_block_finder, dev->seq_number, + dev->n_erased_blocks)); + return dev->alloc_block_finder; } } T(YAFFS_TRACE_ALWAYS, (TSTR ("yaffs tragedy: no more erased blocks, but there should have been %d" - TENDSTR), dev->nErasedBlocks)); + TENDSTR), dev->n_erased_blocks)); return -1; } - /* * Check if there's space to allocate... - * Thinks.... do we need top make this ths same as yaffs_GetFreeChunks()? + * Thinks.... do we need top make this ths same as yaffs_get_free_chunks()? */ -int yaffs_CheckSpaceForAllocation(yaffs_Device *dev, int nChunks) +int yaffs_check_alloc_available(struct yaffs_dev *dev, int n_chunks) { - int reservedChunks; - int reservedBlocks = dev->param.nReservedBlocks; - int checkpointBlocks; + int reserved_chunks; + int reserved_blocks = dev->param.n_reserved_blocks; + int checkpt_blocks; - checkpointBlocks = yaffs2_CalcCheckpointBlocksRequired(dev); + checkpt_blocks = yaffs_calc_checkpt_blocks_required(dev); - reservedChunks = ((reservedBlocks + checkpointBlocks) * dev->param.nChunksPerBlock); + reserved_chunks = + ((reserved_blocks + checkpt_blocks) * dev->param.chunks_per_block); - return (dev->nFreeChunks > (reservedChunks + nChunks)); + return (dev->n_free_chunks > (reserved_chunks + n_chunks)); } -static int yaffs_AllocateChunk(yaffs_Device *dev, int useReserve, - yaffs_BlockInfo **blockUsedPtr) +static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver, + struct yaffs_block_info **block_ptr) { - int retVal; - yaffs_BlockInfo *bi; + int ret_val; + struct yaffs_block_info *bi; - if (dev->allocationBlock < 0) { + if (dev->alloc_block < 0) { /* Get next block to allocate off */ - dev->allocationBlock = yaffs_FindBlockForAllocation(dev); - dev->allocationPage = 0; + dev->alloc_block = yaffs_find_alloc_block(dev); + dev->alloc_page = 0; } - if (!useReserve && !yaffs_CheckSpaceForAllocation(dev, 1)) { + if (!use_reserver && !yaffs_check_alloc_available(dev, 1)) { /* Not enough space to allocate unless we're allowed to use the reserve. */ return -1; } - if (dev->nErasedBlocks < dev->param.nReservedBlocks - && dev->allocationPage == 0) { + if (dev->n_erased_blocks < dev->param.n_reserved_blocks + && dev->alloc_page == 0) { T(YAFFS_TRACE_ALLOCATE, (TSTR("Allocating reserve" TENDSTR))); } /* Next page please.... */ - if (dev->allocationBlock >= 0) { - bi = yaffs_GetBlockInfo(dev, dev->allocationBlock); + if (dev->alloc_block >= 0) { + bi = yaffs_get_block_info(dev, dev->alloc_block); - retVal = (dev->allocationBlock * dev->param.nChunksPerBlock) + - dev->allocationPage; - bi->pagesInUse++; - yaffs_SetChunkBit(dev, dev->allocationBlock, - dev->allocationPage); + ret_val = (dev->alloc_block * dev->param.chunks_per_block) + + dev->alloc_page; + bi->pages_in_use++; + yaffs_set_chunk_bit(dev, dev->alloc_block, dev->alloc_page); - dev->allocationPage++; + dev->alloc_page++; - dev->nFreeChunks--; + dev->n_free_chunks--; /* If the block is full set the state to full */ - if (dev->allocationPage >= dev->param.nChunksPerBlock) { - bi->blockState = YAFFS_BLOCK_STATE_FULL; - dev->allocationBlock = -1; + if (dev->alloc_page >= dev->param.chunks_per_block) { + bi->block_state = YAFFS_BLOCK_STATE_FULL; + dev->alloc_block = -1; } - if (blockUsedPtr) - *blockUsedPtr = bi; + if (block_ptr) + *block_ptr = bi; - return retVal; + return ret_val; } T(YAFFS_TRACE_ERROR, - (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR))); + (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR))); return -1; } -static int yaffs_GetErasedChunks(yaffs_Device *dev) +static int yaffs_get_erased_chunks(struct yaffs_dev *dev) { int n; - n = dev->nErasedBlocks * dev->param.nChunksPerBlock; + n = dev->n_erased_blocks * dev->param.chunks_per_block; - if (dev->allocationBlock > 0) - n += (dev->param.nChunksPerBlock - dev->allocationPage); + if (dev->alloc_block > 0) + n += (dev->param.chunks_per_block - dev->alloc_page); return n; } /* - * yaffs_SkipRestOfBlock() skips over the rest of the allocation block + * yaffs_skip_rest_of_block() skips over the rest of the allocation block * if we don't want to write to it. */ -void yaffs_SkipRestOfBlock(yaffs_Device *dev) +void yaffs_skip_rest_of_block(struct yaffs_dev *dev) { - if(dev->allocationBlock > 0){ - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, dev->allocationBlock); - if(bi->blockState == YAFFS_BLOCK_STATE_ALLOCATING){ - bi->blockState = YAFFS_BLOCK_STATE_FULL; - dev->allocationBlock = -1; + if (dev->alloc_block > 0) { + struct yaffs_block_info *bi = + yaffs_get_block_info(dev, dev->alloc_block); + if (bi->block_state == YAFFS_BLOCK_STATE_ALLOCATING) { + bi->block_state = YAFFS_BLOCK_STATE_FULL; + dev->alloc_block = -1; } } } - -static int yaffs_GarbageCollectBlock(yaffs_Device *dev, int block, - int wholeBlock) +static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block) { - int oldChunk; - int newChunk; - int markNAND; - int retVal = YAFFS_OK; + int old_chunk; + int new_chunk; + int mark_flash; + int ret_val = YAFFS_OK; int i; - int isCheckpointBlock; - int matchingChunk; - int maxCopies; + int is_checkpt_block; + int matching_chunk; + int max_copies; - int chunksBefore = yaffs_GetErasedChunks(dev); - int chunksAfter; + int chunks_before = yaffs_get_erased_chunks(dev); + int chunks_after; - yaffs_ExtendedTags tags; + struct yaffs_ext_tags tags; - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, block); + struct yaffs_block_info *bi = yaffs_get_block_info(dev, block); - yaffs_Object *object; - - isCheckpointBlock = (bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT); + struct yaffs_obj *object; + is_checkpt_block = (bi->block_state == YAFFS_BLOCK_STATE_CHECKPOINT); T(YAFFS_TRACE_TRACING, - (TSTR("Collecting block %d, in use %d, shrink %d, wholeBlock %d" TENDSTR), - block, - bi->pagesInUse, - bi->hasShrinkHeader, - wholeBlock)); + (TSTR + ("Collecting block %d, in use %d, shrink %d, whole_block %d" + TENDSTR), block, bi->pages_in_use, bi->has_shrink_hdr, + whole_block)); - /*yaffs_VerifyFreeChunks(dev); */ + /*yaffs_verify_free_chunks(dev); */ - if(bi->blockState == YAFFS_BLOCK_STATE_FULL) - bi->blockState = YAFFS_BLOCK_STATE_COLLECTING; - - bi->hasShrinkHeader = 0; /* clear the flag so that the block can erase */ + if (bi->block_state == YAFFS_BLOCK_STATE_FULL) + bi->block_state = YAFFS_BLOCK_STATE_COLLECTING; - dev->gcDisable = 1; + bi->has_shrink_hdr = 0; /* clear the flag so that the block can erase */ - if (isCheckpointBlock || - !yaffs_StillSomeChunkBits(dev, block)) { + dev->gc_disable = 1; + + if (is_checkpt_block || !yaffs_still_some_chunks(dev, block)) { T(YAFFS_TRACE_TRACING, - (TSTR - ("Collecting block %d that has no chunks in use" TENDSTR), - block)); - yaffs_BlockBecameDirty(dev, block); + (TSTR + ("Collecting block %d that has no chunks in use" TENDSTR), + block)); + yaffs_block_became_dirty(dev, block); } else { - __u8 *buffer = yaffs_GetTempBuffer(dev, __LINE__); + u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__); - yaffs_VerifyBlock(dev, bi, block); + yaffs_verify_blk(dev, bi, block); - maxCopies = (wholeBlock) ? dev->param.nChunksPerBlock : 5; - oldChunk = block * dev->param.nChunksPerBlock + dev->gcChunk; + max_copies = (whole_block) ? dev->param.chunks_per_block : 5; + old_chunk = block * dev->param.chunks_per_block + dev->gc_chunk; - for (/* init already done */; - retVal == YAFFS_OK && - dev->gcChunk < dev->param.nChunksPerBlock && - (bi->blockState == YAFFS_BLOCK_STATE_COLLECTING) && - maxCopies > 0; - dev->gcChunk++, oldChunk++) { - if (yaffs_CheckChunkBit(dev, block, dev->gcChunk)) { + for ( /* init already done */ ; + ret_val == YAFFS_OK && + dev->gc_chunk < dev->param.chunks_per_block && + (bi->block_state == YAFFS_BLOCK_STATE_COLLECTING) && + max_copies > 0; dev->gc_chunk++, old_chunk++) { + if (yaffs_check_chunk_bit(dev, block, dev->gc_chunk)) { /* This page is in use and might need to be copied off */ - maxCopies--; + max_copies--; - markNAND = 1; + mark_flash = 1; - yaffs_InitialiseTags(&tags); + yaffs_init_tags(&tags); - yaffs_ReadChunkWithTagsFromNAND(dev, oldChunk, - buffer, &tags); + yaffs_rd_chunk_tags_nand(dev, old_chunk, + buffer, &tags); - object = - yaffs_FindObjectByNumber(dev, - tags.objectId); + object = yaffs_find_by_number(dev, tags.obj_id); T(YAFFS_TRACE_GC_DETAIL, (TSTR - ("Collecting chunk in block %d, %d %d %d " TENDSTR), - dev->gcChunk, tags.objectId, tags.chunkId, - tags.byteCount)); + ("Collecting chunk in block %d, %d %d %d " + TENDSTR), dev->gc_chunk, tags.obj_id, + tags.chunk_id, tags.n_bytes)); - if (object && !yaffs_SkipVerification(dev)) { - if (tags.chunkId == 0) - matchingChunk = object->hdrChunk; - else if (object->softDeleted) - matchingChunk = oldChunk; /* Defeat the test */ + if (object && !yaffs_skip_verification(dev)) { + if (tags.chunk_id == 0) + matching_chunk = + object->hdr_chunk; + else if (object->soft_del) + matching_chunk = old_chunk; /* Defeat the test */ else - matchingChunk = yaffs_FindChunkInFile(object, tags.chunkId, NULL); + matching_chunk = + yaffs_find_chunk_in_file + (object, tags.chunk_id, + NULL); - if (oldChunk != matchingChunk) + if (old_chunk != matching_chunk) T(YAFFS_TRACE_ERROR, - (TSTR("gc: page in gc mismatch: %d %d %d %d"TENDSTR), - oldChunk, matchingChunk, tags.objectId, tags.chunkId)); + (TSTR + ("gc: page in gc mismatch: %d %d %d %d" + TENDSTR), old_chunk, + matching_chunk, tags.obj_id, + tags.chunk_id)); } @@ -2200,48 +2081,50 @@ static int yaffs_GarbageCollectBlock(yaffs_Device *dev, int block, T(YAFFS_TRACE_ERROR, (TSTR ("page %d in gc has no object: %d %d %d " - TENDSTR), oldChunk, - tags.objectId, tags.chunkId, tags.byteCount)); + TENDSTR), old_chunk, + tags.obj_id, tags.chunk_id, + tags.n_bytes)); } if (object && object->deleted && - object->softDeleted && - tags.chunkId != 0) { + object->soft_del && tags.chunk_id != 0) { /* Data chunk in a soft deleted file, throw it away * It's a soft deleted data chunk, * No need to copy this, just forget about it and * fix up the object. */ - + /* Free chunks already includes softdeleted chunks. * How ever this chunk is going to soon be really deleted * which will increment free chunks. * We have to decrement free chunks so this works out properly. */ - dev->nFreeChunks--; - bi->softDeletions--; + dev->n_free_chunks--; + bi->soft_del_pages--; - object->nDataChunks--; + object->n_data_chunks--; - if (object->nDataChunks <= 0) { + if (object->n_data_chunks <= 0) { /* remeber to clean up the object */ - dev->gcCleanupList[dev->nCleanups] = - tags.objectId; - dev->nCleanups++; + dev->gc_cleanup_list[dev-> + n_clean_ups] + = tags.obj_id; + dev->n_clean_ups++; } - markNAND = 0; + mark_flash = 0; } else if (0) { - /* Todo object && object->deleted && object->nDataChunks == 0 */ + /* Todo object && object->deleted && object->n_data_chunks == 0 */ /* Deleted object header with no data chunks. * Can be discarded and the file deleted. */ - object->hdrChunk = 0; - yaffs_FreeTnode(object->myDev, - object->variant. - fileVariant.top); - object->variant.fileVariant.top = NULL; - yaffs_DoGenericObjectDeletion(object); + object->hdr_chunk = 0; + yaffs_free_tnode(object->my_dev, + object-> + variant.file_variant. + top); + object->variant.file_variant.top = NULL; + yaffs_generic_obj_del(object); } else if (object) { /* It's either a data chunk in a live file or @@ -2249,123 +2132,131 @@ static int yaffs_GarbageCollectBlock(yaffs_Device *dev, int block, * NB Need to keep the ObjectHeaders of deleted files * until the whole file has been deleted off */ - tags.serialNumber++; + tags.serial_number++; - dev->nGCCopies++; + dev->n_gc_copies++; - if (tags.chunkId == 0) { + if (tags.chunk_id == 0) { /* It is an object Id, * We need to nuke the shrinkheader flags first * Also need to clean up shadowing. - * We no longer want the shrinkHeader flag since its work is done + * We no longer want the shrink_header flag since its work is done * and if it is left in place it will mess up scanning. */ - yaffs_ObjectHeader *oh; - oh = (yaffs_ObjectHeader *)buffer; + struct yaffs_obj_hdr *oh; + oh = (struct yaffs_obj_hdr *) + buffer; - oh->isShrink = 0; - tags.extraIsShrinkHeader = 0; + oh->is_shrink = 0; + tags.extra_is_shrink = 0; - oh->shadowsObject = 0; - oh->inbandShadowsObject = 0; - tags.extraShadows = 0; + oh->shadows_obj = 0; + oh->inband_shadowed_obj_id = 0; + tags.extra_shadows = 0; /* Update file size */ - if(object->variantType == YAFFS_OBJECT_TYPE_FILE){ - oh->fileSize = object->variant.fileVariant.fileSize; - tags.extraFileLength = oh->fileSize; + if (object->variant_type == + YAFFS_OBJECT_TYPE_FILE) { + oh->file_size = + object->variant. + file_variant. + file_size; + tags.extra_length = + oh->file_size; } - yaffs_VerifyObjectHeader(object, oh, &tags, 1); - newChunk = - yaffs_WriteNewChunkWithTagsToNAND(dev,(__u8 *) oh, &tags, 1); + yaffs_verify_oh(object, oh, + &tags, 1); + new_chunk = + yaffs_write_new_chunk(dev, + (u8 *) + oh, + &tags, + 1); } else - newChunk = - yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &tags, 1); + new_chunk = + yaffs_write_new_chunk(dev, + buffer, + &tags, + 1); - if (newChunk < 0) { - retVal = YAFFS_FAIL; + if (new_chunk < 0) { + ret_val = YAFFS_FAIL; } else { /* Ok, now fix up the Tnodes etc. */ - if (tags.chunkId == 0) { + if (tags.chunk_id == 0) { /* It's a header */ - object->hdrChunk = newChunk; - object->serial = tags.serialNumber; + object->hdr_chunk = + new_chunk; + object->serial = + tags.serial_number; } else { /* It's a data chunk */ int ok; - ok = yaffs_PutChunkIntoFile - (object, - tags.chunkId, - newChunk, 0); + ok = yaffs_put_chunk_in_file(object, tags.chunk_id, new_chunk, 0); } } } - if (retVal == YAFFS_OK) - yaffs_DeleteChunk(dev, oldChunk, markNAND, __LINE__); + if (ret_val == YAFFS_OK) + yaffs_chunk_del(dev, old_chunk, + mark_flash, __LINE__); } } - yaffs_ReleaseTempBuffer(dev, buffer, __LINE__); - - + yaffs_release_temp_buffer(dev, buffer, __LINE__); } - yaffs_VerifyCollectedBlock(dev, bi, block); + yaffs_verify_collected_blk(dev, bi, block); - - - if (bi->blockState == YAFFS_BLOCK_STATE_COLLECTING) { + if (bi->block_state == YAFFS_BLOCK_STATE_COLLECTING) { /* * The gc did not complete. Set block state back to FULL * because checkpointing does not restore gc. */ - bi->blockState = YAFFS_BLOCK_STATE_FULL; + bi->block_state = YAFFS_BLOCK_STATE_FULL; } else { /* The gc completed. */ /* Do any required cleanups */ - for (i = 0; i < dev->nCleanups; i++) { + for (i = 0; i < dev->n_clean_ups; i++) { /* Time to delete the file too */ object = - yaffs_FindObjectByNumber(dev, - dev->gcCleanupList[i]); + yaffs_find_by_number(dev, dev->gc_cleanup_list[i]); if (object) { - yaffs_FreeTnode(dev, - object->variant.fileVariant. - top); - object->variant.fileVariant.top = NULL; + yaffs_free_tnode(dev, + object->variant. + file_variant.top); + object->variant.file_variant.top = NULL; T(YAFFS_TRACE_GC, (TSTR ("yaffs: About to finally delete object %d" - TENDSTR), object->objectId)); - yaffs_DoGenericObjectDeletion(object); - object->myDev->nDeletedFiles--; + TENDSTR), object->obj_id)); + yaffs_generic_obj_del(object); + object->my_dev->n_deleted_files--; } } - - chunksAfter = yaffs_GetErasedChunks(dev); - if (chunksBefore >= chunksAfter) { + chunks_after = yaffs_get_erased_chunks(dev); + if (chunks_before >= chunks_after) { T(YAFFS_TRACE_GC, (TSTR ("gc did not increase free chunks before %d after %d" - TENDSTR), chunksBefore, chunksAfter)); + TENDSTR), chunks_before, chunks_after)); } - dev->gcBlock = 0; - dev->gcChunk = 0; - dev->nCleanups = 0; + dev->gc_block = 0; + dev->gc_chunk = 0; + dev->n_clean_ups = 0; } - dev->gcDisable = 0; + dev->gc_disable = 0; - return retVal; + return ret_val; } /* @@ -2373,30 +2264,28 @@ static int yaffs_GarbageCollectBlock(yaffs_Device *dev, int block, * for garbage collection. */ -static unsigned yaffs_FindBlockForGarbageCollection(yaffs_Device *dev, - int aggressive, - int background) +static unsigned yaffs_find_gc_block(struct yaffs_dev *dev, + int aggressive, int background) { int i; int iterations; unsigned selected = 0; int prioritised = 0; - int prioritisedExists = 0; - yaffs_BlockInfo *bi; + int prioritised_exist = 0; + struct yaffs_block_info *bi; int threshold; /* First let's see if we need to grab a prioritised block */ - if (dev->hasPendingPrioritisedGCs && !aggressive) { - dev->gcDirtiest = 0; - bi = dev->blockInfo; - for (i = dev->internalStartBlock; - i <= dev->internalEndBlock && !selected; - i++) { + if (dev->has_pending_prioritised_gc && !aggressive) { + dev->gc_dirtiest = 0; + bi = dev->block_info; + for (i = dev->internal_start_block; + i <= dev->internal_end_block && !selected; i++) { - if (bi->gcPrioritise) { - prioritisedExists = 1; - if (bi->blockState == YAFFS_BLOCK_STATE_FULL && - yaffs2_BlockNotDisqualifiedFromGC(dev, bi)) { + if (bi->gc_prioritise) { + prioritised_exist = 1; + if (bi->block_state == YAFFS_BLOCK_STATE_FULL && + yaffs_block_ok_for_gc(dev, bi)) { selected = i; prioritised = 1; } @@ -2410,13 +2299,12 @@ static unsigned yaffs_FindBlockForGarbageCollection(yaffs_Device *dev, * up the works. Let's gc the oldest dirty block. */ - if(prioritisedExists && - !selected && - dev->oldestDirtyBlock > 0) - selected = dev->oldestDirtyBlock; + if (prioritised_exist && + !selected && dev->oldest_dirty_block > 0) + selected = dev->oldest_dirty_block; - if (!prioritisedExists) /* None found, so we can clear this */ - dev->hasPendingPrioritisedGCs = 0; + if (!prioritised_exist) /* None found, so we can clear this */ + dev->has_pending_prioritised_gc = 0; } /* If we're doing aggressive GC then we are happy to take a less-dirty block, and @@ -2425,60 +2313,61 @@ static unsigned yaffs_FindBlockForGarbageCollection(yaffs_Device *dev, * block has only a few pages in use. */ - if (!selected){ - int pagesUsed; - int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1; - if (aggressive){ - threshold = dev->param.nChunksPerBlock; - iterations = nBlocks; + if (!selected) { + int pages_used; + int n_blocks = + dev->internal_end_block - dev->internal_start_block + 1; + if (aggressive) { + threshold = dev->param.chunks_per_block; + iterations = n_blocks; } else { - int maxThreshold; + int max_threshold; - if(background) - maxThreshold = dev->param.nChunksPerBlock/2; + if (background) + max_threshold = dev->param.chunks_per_block / 2; else - maxThreshold = dev->param.nChunksPerBlock/8; + max_threshold = dev->param.chunks_per_block / 8; - if(maxThreshold < YAFFS_GC_PASSIVE_THRESHOLD) - maxThreshold = YAFFS_GC_PASSIVE_THRESHOLD; + if (max_threshold < YAFFS_GC_PASSIVE_THRESHOLD) + max_threshold = YAFFS_GC_PASSIVE_THRESHOLD; - threshold = background ? - (dev->gcNotDone + 2) * 2 : 0; - if(threshold gc_not_done + 2) * 2 : 0; + if (threshold < YAFFS_GC_PASSIVE_THRESHOLD) threshold = YAFFS_GC_PASSIVE_THRESHOLD; - if(threshold > maxThreshold) - threshold = maxThreshold; + if (threshold > max_threshold) + threshold = max_threshold; - iterations = nBlocks / 16 + 1; + iterations = n_blocks / 16 + 1; if (iterations > 100) iterations = 100; } for (i = 0; - i < iterations && - (dev->gcDirtiest < 1 || - dev->gcPagesInUse > YAFFS_GC_GOOD_ENOUGH); - i++) { - dev->gcBlockFinder++; - if (dev->gcBlockFinder < dev->internalStartBlock || - dev->gcBlockFinder > dev->internalEndBlock) - dev->gcBlockFinder = dev->internalStartBlock; + i < iterations && + (dev->gc_dirtiest < 1 || + dev->gc_pages_in_use > YAFFS_GC_GOOD_ENOUGH); i++) { + dev->gc_block_finder++; + if (dev->gc_block_finder < dev->internal_start_block || + dev->gc_block_finder > dev->internal_end_block) + dev->gc_block_finder = + dev->internal_start_block; - bi = yaffs_GetBlockInfo(dev, dev->gcBlockFinder); + bi = yaffs_get_block_info(dev, dev->gc_block_finder); - pagesUsed = bi->pagesInUse - bi->softDeletions; + pages_used = bi->pages_in_use - bi->soft_del_pages; - if (bi->blockState == YAFFS_BLOCK_STATE_FULL && - pagesUsed < dev->param.nChunksPerBlock && - (dev->gcDirtiest < 1 || pagesUsed < dev->gcPagesInUse) && - yaffs2_BlockNotDisqualifiedFromGC(dev, bi)) { - dev->gcDirtiest = dev->gcBlockFinder; - dev->gcPagesInUse = pagesUsed; + if (bi->block_state == YAFFS_BLOCK_STATE_FULL && + pages_used < dev->param.chunks_per_block && + (dev->gc_dirtiest < 1 + || pages_used < dev->gc_pages_in_use) + && yaffs_block_ok_for_gc(dev, bi)) { + dev->gc_dirtiest = dev->gc_block_finder; + dev->gc_pages_in_use = pages_used; } } - if(dev->gcDirtiest > 0 && dev->gcPagesInUse <= threshold) - selected = dev->gcDirtiest; + if (dev->gc_dirtiest > 0 && dev->gc_pages_in_use <= threshold) + selected = dev->gc_dirtiest; } /* @@ -2486,44 +2375,45 @@ static unsigned yaffs_FindBlockForGarbageCollection(yaffs_Device *dev, * because that's gumming up the works. */ - if(!selected && dev->param.isYaffs2 && - dev->gcNotDone >= ( background ? 10 : 20)){ - yaffs2_FindOldestDirtySequence(dev); - if(dev->oldestDirtyBlock > 0) { - selected = dev->oldestDirtyBlock; - dev->gcDirtiest = selected; - dev->oldestDirtyGCs++; - bi = yaffs_GetBlockInfo(dev, selected); - dev->gcPagesInUse = bi->pagesInUse - bi->softDeletions; + if (!selected && dev->param.is_yaffs2 && + dev->gc_not_done >= (background ? 10 : 20)) { + yaffs2_find_oldest_dirty_seq(dev); + if (dev->oldest_dirty_block > 0) { + selected = dev->oldest_dirty_block; + dev->gc_dirtiest = selected; + dev->oldest_dirty_gc_count++; + bi = yaffs_get_block_info(dev, selected); + dev->gc_pages_in_use = + bi->pages_in_use - bi->soft_del_pages; } else - dev->gcNotDone = 0; + dev->gc_not_done = 0; } - if(selected){ + if (selected) { T(YAFFS_TRACE_GC, - (TSTR("GC Selected block %d with %d free, prioritised:%d" TENDSTR), - selected, - dev->param.nChunksPerBlock - dev->gcPagesInUse, - prioritised)); + (TSTR + ("GC Selected block %d with %d free, prioritised:%d" + TENDSTR), selected, + dev->param.chunks_per_block - dev->gc_pages_in_use, + prioritised)); - dev->nGCBlocks++; - if(background) - dev->backgroundGCs++; + dev->n_gc_blocks++; + if (background) + dev->bg_gcs++; - dev->gcDirtiest = 0; - dev->gcPagesInUse = 0; - dev->gcNotDone = 0; - if(dev->refreshSkip > 0) - dev->refreshSkip--; - } else{ - dev->gcNotDone++; + dev->gc_dirtiest = 0; + dev->gc_pages_in_use = 0; + dev->gc_not_done = 0; + if (dev->refresh_skip > 0) + dev->refresh_skip--; + } else { + dev->gc_not_done++; T(YAFFS_TRACE_GC, - (TSTR("GC none: finder %d skip %d threshold %d dirtiest %d using %d oldest %d%s" TENDSTR), - dev->gcBlockFinder, dev->gcNotDone, - threshold, - dev->gcDirtiest, dev->gcPagesInUse, - dev->oldestDirtyBlock, - background ? " bg" : "")); + (TSTR + ("GC none: finder %d skip %d threshold %d dirtiest %d using %d oldest %d%s" + TENDSTR), dev->gc_block_finder, dev->gc_not_done, threshold, + dev->gc_dirtiest, dev->gc_pages_in_use, + dev->oldest_dirty_block, background ? " bg" : "")); } return selected; @@ -2538,20 +2428,19 @@ static unsigned yaffs_FindBlockForGarbageCollection(yaffs_Device *dev, * The idea is to help clear out space in a more spread-out manner. * Dunno if it really does anything useful. */ -static int yaffs_CheckGarbageCollection(yaffs_Device *dev, int background) +static int yaffs_check_gc(struct yaffs_dev *dev, int background) { int aggressive = 0; - int gcOk = YAFFS_OK; - int maxTries = 0; - int minErased; - int erasedChunks; - int checkpointBlockAdjust; + int gc_ok = YAFFS_OK; + int max_tries = 0; + int min_erased; + int erased_chunks; + int checkpt_block_adjust; - if(dev->param.gcControl && - (dev->param.gcControl(dev) & 1) == 0) + if (dev->param.gc_control && (dev->param.gc_control(dev) & 1) == 0) return YAFFS_OK; - if (dev->gcDisable) { + if (dev->gc_disable) { /* Bail out so we don't get recursive gc */ return YAFFS_OK; } @@ -2561,186 +2450,188 @@ static int yaffs_CheckGarbageCollection(yaffs_Device *dev, int background) */ do { - maxTries++; + max_tries++; - checkpointBlockAdjust = yaffs2_CalcCheckpointBlocksRequired(dev); + checkpt_block_adjust = yaffs_calc_checkpt_blocks_required(dev); - minErased = dev->param.nReservedBlocks + checkpointBlockAdjust + 1; - erasedChunks = dev->nErasedBlocks * dev->param.nChunksPerBlock; + min_erased = + dev->param.n_reserved_blocks + checkpt_block_adjust + 1; + erased_chunks = + dev->n_erased_blocks * dev->param.chunks_per_block; - /* If we need a block soon then do aggressive gc.*/ - if (dev->nErasedBlocks < minErased) + /* If we need a block soon then do aggressive gc. */ + if (dev->n_erased_blocks < min_erased) aggressive = 1; else { - if(!background && erasedChunks > (dev->nFreeChunks / 4)) + if (!background + && erased_chunks > (dev->n_free_chunks / 4)) break; - if(dev->gcSkip > 20) - dev->gcSkip = 20; - if(erasedChunks < dev->nFreeChunks/2 || - dev->gcSkip < 1 || - background) + if (dev->gc_skip > 20) + dev->gc_skip = 20; + if (erased_chunks < dev->n_free_chunks / 2 || + dev->gc_skip < 1 || background) aggressive = 0; else { - dev->gcSkip--; + dev->gc_skip--; break; } } - dev->gcSkip = 5; + dev->gc_skip = 5; - /* If we don't already have a block being gc'd then see if we should start another */ + /* If we don't already have a block being gc'd then see if we should start another */ - if (dev->gcBlock < 1 && !aggressive) { - dev->gcBlock = yaffs2_FindRefreshBlock(dev); - dev->gcChunk = 0; - dev->nCleanups=0; + if (dev->gc_block < 1 && !aggressive) { + dev->gc_block = yaffs2_find_refresh_block(dev); + dev->gc_chunk = 0; + dev->n_clean_ups = 0; } - if (dev->gcBlock < 1) { - dev->gcBlock = yaffs_FindBlockForGarbageCollection(dev, aggressive, background); - dev->gcChunk = 0; - dev->nCleanups=0; + if (dev->gc_block < 1) { + dev->gc_block = + yaffs_find_gc_block(dev, aggressive, background); + dev->gc_chunk = 0; + dev->n_clean_ups = 0; } - if (dev->gcBlock > 0) { - dev->allGCs++; + if (dev->gc_block > 0) { + dev->all_gcs++; if (!aggressive) - dev->passiveGCs++; + dev->passive_gc_count++; T(YAFFS_TRACE_GC, (TSTR - ("yaffs: GC erasedBlocks %d aggressive %d" TENDSTR), - dev->nErasedBlocks, aggressive)); + ("yaffs: GC n_erased_blocks %d aggressive %d" + TENDSTR), dev->n_erased_blocks, aggressive)); - gcOk = yaffs_GarbageCollectBlock(dev, dev->gcBlock, aggressive); + gc_ok = yaffs_gc_block(dev, dev->gc_block, aggressive); } - if (dev->nErasedBlocks < (dev->param.nReservedBlocks) && dev->gcBlock > 0) { + if (dev->n_erased_blocks < (dev->param.n_reserved_blocks) + && dev->gc_block > 0) { T(YAFFS_TRACE_GC, (TSTR - ("yaffs: GC !!!no reclaim!!! erasedBlocks %d after try %d block %d" - TENDSTR), dev->nErasedBlocks, maxTries, dev->gcBlock)); + ("yaffs: GC !!!no reclaim!!! n_erased_blocks %d after try %d block %d" + TENDSTR), dev->n_erased_blocks, max_tries, + dev->gc_block)); } - } while ((dev->nErasedBlocks < dev->param.nReservedBlocks) && - (dev->gcBlock > 0) && - (maxTries < 2)); + } while ((dev->n_erased_blocks < dev->param.n_reserved_blocks) && + (dev->gc_block > 0) && (max_tries < 2)); - return aggressive ? gcOk : YAFFS_OK; + return aggressive ? gc_ok : YAFFS_OK; } /* - * yaffs_BackgroundGarbageCollect() + * yaffs_bg_gc() * Garbage collects. Intended to be called from a background thread. * Returns non-zero if at least half the free chunks are erased. */ -int yaffs_BackgroundGarbageCollect(yaffs_Device *dev, unsigned urgency) +int yaffs_bg_gc(struct yaffs_dev *dev, unsigned urgency) { - int erasedChunks = dev->nErasedBlocks * dev->param.nChunksPerBlock; + int erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block; - T(YAFFS_TRACE_BACKGROUND, (TSTR("Background gc %u" TENDSTR),urgency)); + T(YAFFS_TRACE_BACKGROUND, (TSTR("Background gc %u" TENDSTR), urgency)); - yaffs_CheckGarbageCollection(dev, 1); - return erasedChunks > dev->nFreeChunks/2; + yaffs_check_gc(dev, 1); + return erased_chunks > dev->n_free_chunks / 2; } /*------------------------- TAGS --------------------------------*/ -static int yaffs_TagsMatch(const yaffs_ExtendedTags *tags, int objectId, - int chunkInObject) +static int yaffs_tags_match(const struct yaffs_ext_tags *tags, int obj_id, + int chunk_obj) { - return (tags->chunkId == chunkInObject && - tags->objectId == objectId && !tags->chunkDeleted) ? 1 : 0; + return (tags->chunk_id == chunk_obj && + tags->obj_id == obj_id && !tags->is_deleted) ? 1 : 0; } - /*-------------------- Data file manipulation -----------------*/ -static int yaffs_FindChunkInFile(yaffs_Object *in, int chunkInInode, - yaffs_ExtendedTags *tags) +static int yaffs_find_chunk_in_file(struct yaffs_obj *in, int inode_chunk, + struct yaffs_ext_tags *tags) { /*Get the Tnode, then get the level 0 offset chunk offset */ - yaffs_Tnode *tn; - int theChunk = -1; - yaffs_ExtendedTags localTags; - int retVal = -1; + struct yaffs_tnode *tn; + int the_chunk = -1; + struct yaffs_ext_tags local_tags; + int ret_val = -1; - yaffs_Device *dev = in->myDev; + struct yaffs_dev *dev = in->my_dev; if (!tags) { /* Passed a NULL, so use our own tags space */ - tags = &localTags; + tags = &local_tags; } - tn = yaffs_FindLevel0Tnode(dev, &in->variant.fileVariant, chunkInInode); + tn = yaffs_find_tnode_0(dev, &in->variant.file_variant, inode_chunk); if (tn) { - theChunk = yaffs_GetChunkGroupBase(dev, tn, chunkInInode); + the_chunk = yaffs_get_group_base(dev, tn, inode_chunk); - retVal = - yaffs_FindChunkInGroup(dev, theChunk, tags, in->objectId, - chunkInInode); + ret_val = + yaffs_find_chunk_in_group(dev, the_chunk, tags, in->obj_id, + inode_chunk); } - return retVal; + return ret_val; } -static int yaffs_FindAndDeleteChunkInFile(yaffs_Object *in, int chunkInInode, - yaffs_ExtendedTags *tags) +static int yaffs_find_del_file_chunk(struct yaffs_obj *in, int inode_chunk, + struct yaffs_ext_tags *tags) { /* Get the Tnode, then get the level 0 offset chunk offset */ - yaffs_Tnode *tn; - int theChunk = -1; - yaffs_ExtendedTags localTags; + struct yaffs_tnode *tn; + int the_chunk = -1; + struct yaffs_ext_tags local_tags; - yaffs_Device *dev = in->myDev; - int retVal = -1; + struct yaffs_dev *dev = in->my_dev; + int ret_val = -1; if (!tags) { /* Passed a NULL, so use our own tags space */ - tags = &localTags; + tags = &local_tags; } - tn = yaffs_FindLevel0Tnode(dev, &in->variant.fileVariant, chunkInInode); + tn = yaffs_find_tnode_0(dev, &in->variant.file_variant, inode_chunk); if (tn) { - theChunk = yaffs_GetChunkGroupBase(dev, tn, chunkInInode); + the_chunk = yaffs_get_group_base(dev, tn, inode_chunk); - retVal = - yaffs_FindChunkInGroup(dev, theChunk, tags, in->objectId, - chunkInInode); + ret_val = + yaffs_find_chunk_in_group(dev, the_chunk, tags, in->obj_id, + inode_chunk); /* Delete the entry in the filestructure (if found) */ - if (retVal != -1) - yaffs_LoadLevel0Tnode(dev, tn, chunkInInode, 0); + if (ret_val != -1) + yaffs_load_tnode_0(dev, tn, inode_chunk, 0); } - return retVal; + return ret_val; } - -int yaffs_PutChunkIntoFile(yaffs_Object *in, int chunkInInode, - int chunkInNAND, int inScan) +int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk, + int nand_chunk, int in_scan) { - /* NB inScan is zero unless scanning. - * For forward scanning, inScan is > 0; - * for backward scanning inScan is < 0 + /* NB in_scan is zero unless scanning. + * For forward scanning, in_scan is > 0; + * for backward scanning in_scan is < 0 * - * chunkInNAND = 0 is a dummy insert to make sure the tnodes are there. + * nand_chunk = 0 is a dummy insert to make sure the tnodes are there. */ - yaffs_Tnode *tn; - yaffs_Device *dev = in->myDev; - int existingChunk; - yaffs_ExtendedTags existingTags; - yaffs_ExtendedTags newTags; - unsigned existingSerial, newSerial; + struct yaffs_tnode *tn; + struct yaffs_dev *dev = in->my_dev; + int existing_cunk; + struct yaffs_ext_tags existing_tags; + struct yaffs_ext_tags new_tags; + unsigned existing_serial, new_serial; - if (in->variantType != YAFFS_OBJECT_TYPE_FILE) { + if (in->variant_type != YAFFS_OBJECT_TYPE_FILE) { /* Just ignore an attempt at putting a chunk into a non-file during scanning * If it is not during Scanning then something went wrong! */ - if (!inScan) { + if (!in_scan) { T(YAFFS_TRACE_ERROR, (TSTR ("yaffs tragedy:attempt to put data chunk into a non-file" @@ -2748,24 +2639,23 @@ int yaffs_PutChunkIntoFile(yaffs_Object *in, int chunkInInode, YBUG(); } - yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__); + yaffs_chunk_del(dev, nand_chunk, 1, __LINE__); return YAFFS_OK; } - tn = yaffs_AddOrFindLevel0Tnode(dev, - &in->variant.fileVariant, - chunkInInode, - NULL); + tn = yaffs_add_find_tnode_0(dev, + &in->variant.file_variant, + inode_chunk, NULL); if (!tn) return YAFFS_FAIL; - - if(!chunkInNAND) + + if (!nand_chunk) /* Dummy insert, bail now */ return YAFFS_OK; - existingChunk = yaffs_GetChunkGroupBase(dev, tn, chunkInInode); + existing_cunk = yaffs_get_group_base(dev, tn, inode_chunk); - if (inScan != 0) { + if (in_scan != 0) { /* If we're scanning then we need to test for duplicates * NB This does not need to be efficient since it should only ever * happen when the power fails during a write, then only one @@ -2775,8 +2665,8 @@ int yaffs_PutChunkIntoFile(yaffs_Object *in, int chunkInInode, * Update: For backward scanning we don't need to re-read tags so this is quite cheap. */ - if (existingChunk > 0) { - /* NB Right now existing chunk will not be real chunkId if the chunk group size > 1 + if (existing_cunk > 0) { + /* NB Right now existing chunk will not be real chunk_id if the chunk group size > 1 * thus we have to do a FindChunkInFile to get the real chunk id. * * We have a duplicate now we need to decide which one to use: @@ -2786,19 +2676,19 @@ int yaffs_PutChunkIntoFile(yaffs_Object *in, int chunkInInode, * YAFFS1: Get both sets of tags and compare serial numbers. */ - if (inScan > 0) { + if (in_scan > 0) { /* Only do this for forward scanning */ - yaffs_ReadChunkWithTagsFromNAND(dev, - chunkInNAND, - NULL, &newTags); + yaffs_rd_chunk_tags_nand(dev, + nand_chunk, + NULL, &new_tags); /* Do a proper find */ - existingChunk = - yaffs_FindChunkInFile(in, chunkInInode, - &existingTags); + existing_cunk = + yaffs_find_chunk_in_file(in, inode_chunk, + &existing_tags); } - if (existingChunk <= 0) { + if (existing_cunk <= 0) { /*Hoosterman - how did this happen? */ T(YAFFS_TRACE_ERROR, @@ -2812,283 +2702,262 @@ int yaffs_PutChunkIntoFile(yaffs_Object *in, int chunkInInode, * not be loaded during a scan */ - if (inScan > 0) { - newSerial = newTags.serialNumber; - existingSerial = existingTags.serialNumber; + if (in_scan > 0) { + new_serial = new_tags.serial_number; + existing_serial = existing_tags.serial_number; } - if ((inScan > 0) && - (existingChunk <= 0 || - ((existingSerial + 1) & 3) == newSerial)) { + if ((in_scan > 0) && + (existing_cunk <= 0 || + ((existing_serial + 1) & 3) == new_serial)) { /* Forward scanning. * Use new * Delete the old one and drop through to update the tnode */ - yaffs_DeleteChunk(dev, existingChunk, 1, - __LINE__); + yaffs_chunk_del(dev, existing_cunk, 1, + __LINE__); } else { /* Backward scanning or we want to use the existing one * Use existing. * Delete the new one and return early so that the tnode isn't changed */ - yaffs_DeleteChunk(dev, chunkInNAND, 1, - __LINE__); + yaffs_chunk_del(dev, nand_chunk, 1, __LINE__); return YAFFS_OK; } } } - if (existingChunk == 0) - in->nDataChunks++; + if (existing_cunk == 0) + in->n_data_chunks++; - yaffs_LoadLevel0Tnode(dev, tn, chunkInInode, chunkInNAND); + yaffs_load_tnode_0(dev, tn, inode_chunk, nand_chunk); return YAFFS_OK; } -static int yaffs_ReadChunkDataFromObject(yaffs_Object *in, int chunkInInode, - __u8 *buffer) +static int yaffs_rd_data_obj(struct yaffs_obj *in, int inode_chunk, u8 * buffer) { - int chunkInNAND = yaffs_FindChunkInFile(in, chunkInInode, NULL); + int nand_chunk = yaffs_find_chunk_in_file(in, inode_chunk, NULL); - if (chunkInNAND >= 0) - return yaffs_ReadChunkWithTagsFromNAND(in->myDev, chunkInNAND, + if (nand_chunk >= 0) + return yaffs_rd_chunk_tags_nand(in->my_dev, nand_chunk, buffer, NULL); else { T(YAFFS_TRACE_NANDACCESS, (TSTR("Chunk %d not found zero instead" TENDSTR), - chunkInNAND)); + nand_chunk)); /* get sane (zero) data if you read a hole */ - memset(buffer, 0, in->myDev->nDataBytesPerChunk); + memset(buffer, 0, in->my_dev->data_bytes_per_chunk); return 0; } } -void yaffs_DeleteChunk(yaffs_Device *dev, int chunkId, int markNAND, int lyn) +void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash, + int lyn) { int block; int page; - yaffs_ExtendedTags tags; - yaffs_BlockInfo *bi; + struct yaffs_ext_tags tags; + struct yaffs_block_info *bi; - if (chunkId <= 0) + if (chunk_id <= 0) return; - dev->nDeletions++; - block = chunkId / dev->param.nChunksPerBlock; - page = chunkId % dev->param.nChunksPerBlock; + dev->n_deletions++; + block = chunk_id / dev->param.chunks_per_block; + page = chunk_id % dev->param.chunks_per_block; - - if (!yaffs_CheckChunkBit(dev, block, page)) + if (!yaffs_check_chunk_bit(dev, block, page)) T(YAFFS_TRACE_VERIFY, - (TSTR("Deleting invalid chunk %d"TENDSTR), - chunkId)); + (TSTR("Deleting invalid chunk %d" TENDSTR), chunk_id)); - bi = yaffs_GetBlockInfo(dev, block); - - yaffs2_UpdateOldestDirtySequence(dev, block, bi); + bi = yaffs_get_block_info(dev, block); + + yaffs2_update_oldest_dirty_seq(dev, block, bi); T(YAFFS_TRACE_DELETION, - (TSTR("line %d delete of chunk %d" TENDSTR), lyn, chunkId)); + (TSTR("line %d delete of chunk %d" TENDSTR), lyn, chunk_id)); - if (!dev->param.isYaffs2 && markNAND && - bi->blockState != YAFFS_BLOCK_STATE_COLLECTING) { + if (!dev->param.is_yaffs2 && mark_flash && + bi->block_state != YAFFS_BLOCK_STATE_COLLECTING) { - yaffs_InitialiseTags(&tags); + yaffs_init_tags(&tags); - tags.chunkDeleted = 1; + tags.is_deleted = 1; - yaffs_WriteChunkWithTagsToNAND(dev, chunkId, NULL, &tags); - yaffs_HandleUpdateChunk(dev, chunkId, &tags); + yaffs_wr_chunk_tags_nand(dev, chunk_id, NULL, &tags); + yaffs_handle_chunk_update(dev, chunk_id, &tags); } else { - dev->nUnmarkedDeletions++; + dev->n_unmarked_deletions++; } /* Pull out of the management area. * If the whole block became dirty, this will kick off an erasure. */ - if (bi->blockState == YAFFS_BLOCK_STATE_ALLOCATING || - bi->blockState == YAFFS_BLOCK_STATE_FULL || - bi->blockState == YAFFS_BLOCK_STATE_NEEDS_SCANNING || - bi->blockState == YAFFS_BLOCK_STATE_COLLECTING) { - dev->nFreeChunks++; + if (bi->block_state == YAFFS_BLOCK_STATE_ALLOCATING || + bi->block_state == YAFFS_BLOCK_STATE_FULL || + bi->block_state == YAFFS_BLOCK_STATE_NEEDS_SCANNING || + bi->block_state == YAFFS_BLOCK_STATE_COLLECTING) { + dev->n_free_chunks++; - yaffs_ClearChunkBit(dev, block, page); + yaffs_clear_chunk_bit(dev, block, page); - bi->pagesInUse--; + bi->pages_in_use--; - if (bi->pagesInUse == 0 && - !bi->hasShrinkHeader && - bi->blockState != YAFFS_BLOCK_STATE_ALLOCATING && - bi->blockState != YAFFS_BLOCK_STATE_NEEDS_SCANNING) { - yaffs_BlockBecameDirty(dev, block); + if (bi->pages_in_use == 0 && + !bi->has_shrink_hdr && + bi->block_state != YAFFS_BLOCK_STATE_ALLOCATING && + bi->block_state != YAFFS_BLOCK_STATE_NEEDS_SCANNING) { + yaffs_block_became_dirty(dev, block); } } } -static int yaffs_WriteChunkDataToObject(yaffs_Object *in, int chunkInInode, - const __u8 *buffer, int nBytes, - int useReserve) +static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk, + const u8 * buffer, int n_bytes, int use_reserve) { /* Find old chunk Need to do this to get serial number * Write new one and patch into tree. * Invalidate old tags. */ - int prevChunkId; - yaffs_ExtendedTags prevTags; + int prev_chunk_id; + struct yaffs_ext_tags prev_tags; - int newChunkId; - yaffs_ExtendedTags newTags; + int new_chunk_id; + struct yaffs_ext_tags new_tags; - yaffs_Device *dev = in->myDev; + struct yaffs_dev *dev = in->my_dev; - yaffs_CheckGarbageCollection(dev,0); + yaffs_check_gc(dev, 0); /* Get the previous chunk at this location in the file if it exists. * If it does not exist then put a zero into the tree. This creates * the tnode now, rather than later when it is harder to clean up. */ - prevChunkId = yaffs_FindChunkInFile(in, chunkInInode, &prevTags); - if(prevChunkId < 1 && - !yaffs_PutChunkIntoFile(in, chunkInInode, 0, 0)) + prev_chunk_id = yaffs_find_chunk_in_file(in, inode_chunk, &prev_tags); + if (prev_chunk_id < 1 && + !yaffs_put_chunk_in_file(in, inode_chunk, 0, 0)) return 0; /* Set up new tags */ - yaffs_InitialiseTags(&newTags); + yaffs_init_tags(&new_tags); - newTags.chunkId = chunkInInode; - newTags.objectId = in->objectId; - newTags.serialNumber = - (prevChunkId > 0) ? prevTags.serialNumber + 1 : 1; - newTags.byteCount = nBytes; + new_tags.chunk_id = inode_chunk; + new_tags.obj_id = in->obj_id; + new_tags.serial_number = + (prev_chunk_id > 0) ? prev_tags.serial_number + 1 : 1; + new_tags.n_bytes = n_bytes; - if (nBytes < 1 || nBytes > dev->param.totalBytesPerChunk) { + if (n_bytes < 1 || n_bytes > dev->param.total_bytes_per_chunk) { T(YAFFS_TRACE_ERROR, - (TSTR("Writing %d bytes to chunk!!!!!!!!!" TENDSTR), nBytes)); + (TSTR("Writing %d bytes to chunk!!!!!!!!!" TENDSTR), + n_bytes)); YBUG(); } - - - newChunkId = - yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &newTags, - useReserve); - if (newChunkId > 0) { - yaffs_PutChunkIntoFile(in, chunkInInode, newChunkId, 0); + new_chunk_id = + yaffs_write_new_chunk(dev, buffer, &new_tags, use_reserve); - if (prevChunkId > 0) - yaffs_DeleteChunk(dev, prevChunkId, 1, __LINE__); + if (new_chunk_id > 0) { + yaffs_put_chunk_in_file(in, inode_chunk, new_chunk_id, 0); - yaffs_VerifyFileSanity(in); + if (prev_chunk_id > 0) + yaffs_chunk_del(dev, prev_chunk_id, 1, __LINE__); + + yaffs_verify_file_sane(in); } - return newChunkId; + return new_chunk_id; } /* UpdateObjectHeader updates the header on NAND for an object. * If name is not NULL, then that new name is used. */ -int yaffs_UpdateObjectHeader(yaffs_Object *in, const YCHAR *name, int force, - int isShrink, int shadows, yaffs_XAttrMod *xmod) +int yaffs_update_oh(struct yaffs_obj *in, const YCHAR * name, int force, + int is_shrink, int shadows, struct yaffs_xattr_mod *xmod) { - yaffs_BlockInfo *bi; + struct yaffs_block_info *bi; - yaffs_Device *dev = in->myDev; + struct yaffs_dev *dev = in->my_dev; - int prevChunkId; - int retVal = 0; + int prev_chunk_id; + int ret_val = 0; int result = 0; - int newChunkId; - yaffs_ExtendedTags newTags; - yaffs_ExtendedTags oldTags; + int new_chunk_id; + struct yaffs_ext_tags new_tags; + struct yaffs_ext_tags old_tags; const YCHAR *alias = NULL; - __u8 *buffer = NULL; - YCHAR oldName[YAFFS_MAX_NAME_LENGTH + 1]; + u8 *buffer = NULL; + YCHAR old_name[YAFFS_MAX_NAME_LENGTH + 1]; - yaffs_ObjectHeader *oh = NULL; + struct yaffs_obj_hdr *oh = NULL; - yaffs_strcpy(oldName, _Y("silly old name")); + yaffs_strcpy(old_name, _Y("silly old name")); + if (!in->fake || in == dev->root_dir || /* The root_dir should also be saved */ + force || xmod) { - if (!in->fake || - in == dev->rootDir || /* The rootDir should also be saved */ - force || xmod) { + yaffs_check_gc(dev, 0); + yaffs_check_obj_details_loaded(in); - yaffs_CheckGarbageCollection(dev,0); - yaffs_CheckObjectDetailsLoaded(in); + buffer = yaffs_get_temp_buffer(in->my_dev, __LINE__); + oh = (struct yaffs_obj_hdr *)buffer; - buffer = yaffs_GetTempBuffer(in->myDev, __LINE__); - oh = (yaffs_ObjectHeader *) buffer; + prev_chunk_id = in->hdr_chunk; - prevChunkId = in->hdrChunk; + if (prev_chunk_id > 0) { + result = yaffs_rd_chunk_tags_nand(dev, prev_chunk_id, + buffer, &old_tags); - if (prevChunkId > 0) { - result = yaffs_ReadChunkWithTagsFromNAND(dev, prevChunkId, - buffer, &oldTags); + yaffs_verify_oh(in, oh, &old_tags, 0); - yaffs_VerifyObjectHeader(in, oh, &oldTags, 0); - - memcpy(oldName, oh->name, sizeof(oh->name)); - memset(buffer, 0xFF, sizeof(yaffs_ObjectHeader)); + memcpy(old_name, oh->name, sizeof(oh->name)); + memset(buffer, 0xFF, sizeof(struct yaffs_obj_hdr)); } else - memset(buffer, 0xFF, dev->nDataBytesPerChunk); + memset(buffer, 0xFF, dev->data_bytes_per_chunk); - oh->type = in->variantType; + oh->type = in->variant_type; oh->yst_mode = in->yst_mode; - oh->shadowsObject = oh->inbandShadowsObject = shadows; + oh->shadows_obj = oh->inband_shadowed_obj_id = shadows; + + yaffs_load_attribs_oh(oh, in); -#ifdef CONFIG_YAFFS_WINCE - oh->win_atime[0] = in->win_atime[0]; - oh->win_ctime[0] = in->win_ctime[0]; - oh->win_mtime[0] = in->win_mtime[0]; - oh->win_atime[1] = in->win_atime[1]; - oh->win_ctime[1] = in->win_ctime[1]; - oh->win_mtime[1] = in->win_mtime[1]; -#else - oh->yst_uid = in->yst_uid; - oh->yst_gid = in->yst_gid; - oh->yst_atime = in->yst_atime; - oh->yst_mtime = in->yst_mtime; - oh->yst_ctime = in->yst_ctime; - oh->yst_rdev = in->yst_rdev; -#endif if (in->parent) - oh->parentObjectId = in->parent->objectId; + oh->parent_obj_id = in->parent->obj_id; else - oh->parentObjectId = 0; + oh->parent_obj_id = 0; if (name && *name) { memset(oh->name, 0, sizeof(oh->name)); - yaffs_LoadObjectHeaderFromName(dev,oh->name,name); - } else if (prevChunkId > 0) - memcpy(oh->name, oldName, sizeof(oh->name)); + yaffs_load_oh_from_name(dev, oh->name, name); + } else if (prev_chunk_id > 0) + memcpy(oh->name, old_name, sizeof(oh->name)); else memset(oh->name, 0, sizeof(oh->name)); - oh->isShrink = isShrink; + oh->is_shrink = is_shrink; - switch (in->variantType) { + switch (in->variant_type) { case YAFFS_OBJECT_TYPE_UNKNOWN: /* Should not happen */ break; case YAFFS_OBJECT_TYPE_FILE: - oh->fileSize = - (oh->parentObjectId == YAFFS_OBJECTID_DELETED - || oh->parentObjectId == - YAFFS_OBJECTID_UNLINKED) ? 0 : in->variant. - fileVariant.fileSize; + oh->file_size = + (oh->parent_obj_id == YAFFS_OBJECTID_DELETED + || oh->parent_obj_id == + YAFFS_OBJECTID_UNLINKED) ? 0 : in-> + variant.file_variant.file_size; break; case YAFFS_OBJECT_TYPE_HARDLINK: - oh->equivalentObjectId = - in->variant.hardLinkVariant.equivalentObjectId; + oh->equiv_id = in->variant.hardlink_variant.equiv_id; break; case YAFFS_OBJECT_TYPE_SPECIAL: /* Do nothing */ @@ -3097,129 +2966,126 @@ int yaffs_UpdateObjectHeader(yaffs_Object *in, const YCHAR *name, int force, /* Do nothing */ break; case YAFFS_OBJECT_TYPE_SYMLINK: - alias = in->variant.symLinkVariant.alias; - if(!alias) + alias = in->variant.symlink_variant.alias; + if (!alias) alias = _Y("no alias"); - yaffs_strncpy(oh->alias, - alias, - YAFFS_MAX_ALIAS_LENGTH); + yaffs_strncpy(oh->alias, alias, YAFFS_MAX_ALIAS_LENGTH); oh->alias[YAFFS_MAX_ALIAS_LENGTH] = 0; break; } /* process any xattrib modifications */ - if(xmod) - yaffs_ApplyXMod(in, (char *)buffer, xmod); - + if (xmod) + yaffs_apply_xattrib_mod(in, (char *)buffer, xmod); /* Tags */ - yaffs_InitialiseTags(&newTags); + yaffs_init_tags(&new_tags); in->serial++; - newTags.chunkId = 0; - newTags.objectId = in->objectId; - newTags.serialNumber = in->serial; + new_tags.chunk_id = 0; + new_tags.obj_id = in->obj_id; + new_tags.serial_number = in->serial; /* Add extra info for file header */ - newTags.extraHeaderInfoAvailable = 1; - newTags.extraParentObjectId = oh->parentObjectId; - newTags.extraFileLength = oh->fileSize; - newTags.extraIsShrinkHeader = oh->isShrink; - newTags.extraEquivalentObjectId = oh->equivalentObjectId; - newTags.extraShadows = (oh->shadowsObject > 0) ? 1 : 0; - newTags.extraObjectType = in->variantType; + new_tags.extra_available = 1; + new_tags.extra_parent_id = oh->parent_obj_id; + new_tags.extra_length = oh->file_size; + new_tags.extra_is_shrink = oh->is_shrink; + new_tags.extra_equiv_id = oh->equiv_id; + new_tags.extra_shadows = (oh->shadows_obj > 0) ? 1 : 0; + new_tags.extra_obj_type = in->variant_type; - yaffs_VerifyObjectHeader(in, oh, &newTags, 1); + yaffs_verify_oh(in, oh, &new_tags, 1); /* Create new chunk in NAND */ - newChunkId = - yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &newTags, - (prevChunkId > 0) ? 1 : 0); + new_chunk_id = + yaffs_write_new_chunk(dev, buffer, &new_tags, + (prev_chunk_id > 0) ? 1 : 0); - if (newChunkId >= 0) { + if (new_chunk_id >= 0) { - in->hdrChunk = newChunkId; + in->hdr_chunk = new_chunk_id; - if (prevChunkId > 0) { - yaffs_DeleteChunk(dev, prevChunkId, 1, - __LINE__); + if (prev_chunk_id > 0) { + yaffs_chunk_del(dev, prev_chunk_id, 1, + __LINE__); } - if (!yaffs_ObjectHasCachedWriteData(in)) + if (!yaffs_obj_cache_dirty(in)) in->dirty = 0; /* If this was a shrink, then mark the block that the chunk lives on */ - if (isShrink) { - bi = yaffs_GetBlockInfo(in->myDev, - newChunkId / in->myDev->param.nChunksPerBlock); - bi->hasShrinkHeader = 1; + if (is_shrink) { + bi = yaffs_get_block_info(in->my_dev, + new_chunk_id / + in->my_dev->param. + chunks_per_block); + bi->has_shrink_hdr = 1; } } - retVal = newChunkId; + ret_val = new_chunk_id; } if (buffer) - yaffs_ReleaseTempBuffer(dev, buffer, __LINE__); + yaffs_release_temp_buffer(dev, buffer, __LINE__); - return retVal; + return ret_val; } /*------------------------ Short Operations Cache ---------------------------------------- - * In many situations where there is no high level buffering (eg WinCE) a lot of + * In many situations where there is no high level buffering a lot of * reads might be short sequential reads, and a lot of writes may be short * sequential writes. eg. scanning/writing a jpeg file. - * In these cases, a short read/write cache can provide a huge perfomance benefit - * with dumb-as-a-rock code. - * In Linux, the page cache provides read buffering aand the short op cache provides write - * buffering. + * In these cases, a short read/write cache can provide a huge perfomance + * benefit with dumb-as-a-rock code. + * In Linux, the page cache provides read buffering and the short op cache + * provides write buffering. * * There are a limited number (~10) of cache chunks per device so that we don't * need a very intelligent search. */ -static int yaffs_ObjectHasCachedWriteData(yaffs_Object *obj) +static int yaffs_obj_cache_dirty(struct yaffs_obj *obj) { - yaffs_Device *dev = obj->myDev; + struct yaffs_dev *dev = obj->my_dev; int i; - yaffs_ChunkCache *cache; - int nCaches = obj->myDev->param.nShortOpCaches; + struct yaffs_cache *cache; + int n_caches = obj->my_dev->param.n_caches; - for (i = 0; i < nCaches; i++) { - cache = &dev->srCache[i]; - if (cache->object == obj && - cache->dirty) + for (i = 0; i < n_caches; i++) { + cache = &dev->cache[i]; + if (cache->object == obj && cache->dirty) return 1; } return 0; } - -static void yaffs_FlushFilesChunkCache(yaffs_Object *obj) +static void yaffs_flush_file_cache(struct yaffs_obj *obj) { - yaffs_Device *dev = obj->myDev; + struct yaffs_dev *dev = obj->my_dev; int lowest = -99; /* Stop compiler whining. */ int i; - yaffs_ChunkCache *cache; - int chunkWritten = 0; - int nCaches = obj->myDev->param.nShortOpCaches; + struct yaffs_cache *cache; + int chunk_written = 0; + int n_caches = obj->my_dev->param.n_caches; - if (nCaches > 0) { + if (n_caches > 0) { do { cache = NULL; /* Find the dirty cache for this object with the lowest chunk id. */ - for (i = 0; i < nCaches; i++) { - if (dev->srCache[i].object == obj && - dev->srCache[i].dirty) { + for (i = 0; i < n_caches; i++) { + if (dev->cache[i].object == obj && + dev->cache[i].dirty) { if (!cache - || dev->srCache[i].chunkId < + || dev->cache[i].chunk_id < lowest) { - cache = &dev->srCache[i]; - lowest = cache->chunkId; + cache = &dev->cache[i]; + lowest = cache->chunk_id; } } } @@ -3227,37 +3093,38 @@ static void yaffs_FlushFilesChunkCache(yaffs_Object *obj) if (cache && !cache->locked) { /* Write it out and free it up */ - chunkWritten = - yaffs_WriteChunkDataToObject(cache->object, - cache->chunkId, - cache->data, - cache->nBytes, - 1); + chunk_written = + yaffs_wr_data_obj(cache->object, + cache->chunk_id, + cache->data, + cache->n_bytes, 1); cache->dirty = 0; cache->object = NULL; } - } while (cache && chunkWritten > 0); + } while (cache && chunk_written > 0); if (cache) { /* Hoosterman, disk full while writing cache out. */ T(YAFFS_TRACE_ERROR, - (TSTR("yaffs tragedy: no space during cache write" TENDSTR))); + (TSTR + ("yaffs tragedy: no space during cache write" + TENDSTR))); } } } -/*yaffs_FlushEntireDeviceCache(dev) +/*yaffs_flush_whole_cache(dev) * * */ -void yaffs_FlushEntireDeviceCache(yaffs_Device *dev) +void yaffs_flush_whole_cache(struct yaffs_dev *dev) { - yaffs_Object *obj; - int nCaches = dev->param.nShortOpCaches; + struct yaffs_obj *obj; + int n_caches = dev->param.n_caches; int i; /* Find a dirty object in the cache and flush it... @@ -3265,51 +3132,49 @@ void yaffs_FlushEntireDeviceCache(yaffs_Device *dev) */ do { obj = NULL; - for (i = 0; i < nCaches && !obj; i++) { - if (dev->srCache[i].object && - dev->srCache[i].dirty) - obj = dev->srCache[i].object; + for (i = 0; i < n_caches && !obj; i++) { + if (dev->cache[i].object && dev->cache[i].dirty) + obj = dev->cache[i].object; } if (obj) - yaffs_FlushFilesChunkCache(obj); + yaffs_flush_file_cache(obj); } while (obj); } - /* Grab us a cache chunk for use. * First look for an empty one. * Then look for the least recently used non-dirty one. * Then look for the least recently used dirty one...., flush and look again. */ -static yaffs_ChunkCache *yaffs_GrabChunkCacheWorker(yaffs_Device *dev) +static struct yaffs_cache *yaffs_grab_chunk_worker(struct yaffs_dev *dev) { int i; - if (dev->param.nShortOpCaches > 0) { - for (i = 0; i < dev->param.nShortOpCaches; i++) { - if (!dev->srCache[i].object) - return &dev->srCache[i]; + if (dev->param.n_caches > 0) { + for (i = 0; i < dev->param.n_caches; i++) { + if (!dev->cache[i].object) + return &dev->cache[i]; } } return NULL; } -static yaffs_ChunkCache *yaffs_GrabChunkCache(yaffs_Device *dev) +static struct yaffs_cache *yaffs_grab_chunk_cache(struct yaffs_dev *dev) { - yaffs_ChunkCache *cache; - yaffs_Object *theObj; + struct yaffs_cache *cache; + struct yaffs_obj *the_obj; int usage; int i; int pushout; - if (dev->param.nShortOpCaches > 0) { + if (dev->param.n_caches > 0) { /* Try find a non-dirty one... */ - cache = yaffs_GrabChunkCacheWorker(dev); + cache = yaffs_grab_chunk_worker(dev); if (!cache) { /* They were all dirty, find the last recently used object and flush @@ -3320,26 +3185,27 @@ static yaffs_ChunkCache *yaffs_GrabChunkCache(yaffs_Device *dev) /* With locking we can't assume we can use entry zero */ - theObj = NULL; + the_obj = NULL; usage = -1; cache = NULL; pushout = -1; - for (i = 0; i < dev->param.nShortOpCaches; i++) { - if (dev->srCache[i].object && - !dev->srCache[i].locked && - (dev->srCache[i].lastUse < usage || !cache)) { - usage = dev->srCache[i].lastUse; - theObj = dev->srCache[i].object; - cache = &dev->srCache[i]; + for (i = 0; i < dev->param.n_caches; i++) { + if (dev->cache[i].object && + !dev->cache[i].locked && + (dev->cache[i].last_use < usage + || !cache)) { + usage = dev->cache[i].last_use; + the_obj = dev->cache[i].object; + cache = &dev->cache[i]; pushout = i; } } if (!cache || cache->dirty) { /* Flush and try again */ - yaffs_FlushFilesChunkCache(theObj); - cache = yaffs_GrabChunkCacheWorker(dev); + yaffs_flush_file_cache(the_obj); + cache = yaffs_grab_chunk_worker(dev); } } @@ -3350,18 +3216,18 @@ static yaffs_ChunkCache *yaffs_GrabChunkCache(yaffs_Device *dev) } /* Find a cached chunk */ -static yaffs_ChunkCache *yaffs_FindChunkCache(const yaffs_Object *obj, - int chunkId) +static struct yaffs_cache *yaffs_find_chunk_cache(const struct yaffs_obj *obj, + int chunk_id) { - yaffs_Device *dev = obj->myDev; + struct yaffs_dev *dev = obj->my_dev; int i; - if (dev->param.nShortOpCaches > 0) { - for (i = 0; i < dev->param.nShortOpCaches; i++) { - if (dev->srCache[i].object == obj && - dev->srCache[i].chunkId == chunkId) { - dev->cacheHits++; + if (dev->param.n_caches > 0) { + for (i = 0; i < dev->param.n_caches; i++) { + if (dev->cache[i].object == obj && + dev->cache[i].chunk_id == chunk_id) { + dev->cache_hits++; - return &dev->srCache[i]; + return &dev->cache[i]; } } } @@ -3369,25 +3235,25 @@ static yaffs_ChunkCache *yaffs_FindChunkCache(const yaffs_Object *obj, } /* Mark the chunk for the least recently used algorithym */ -static void yaffs_UseChunkCache(yaffs_Device *dev, yaffs_ChunkCache *cache, - int isAWrite) +static void yaffs_use_cache(struct yaffs_dev *dev, struct yaffs_cache *cache, + int is_write) { - if (dev->param.nShortOpCaches > 0) { - if (dev->srLastUse < 0 || dev->srLastUse > 100000000) { + if (dev->param.n_caches > 0) { + if (dev->cache_last_use < 0 || dev->cache_last_use > 100000000) { /* Reset the cache usages */ int i; - for (i = 1; i < dev->param.nShortOpCaches; i++) - dev->srCache[i].lastUse = 0; + for (i = 1; i < dev->param.n_caches; i++) + dev->cache[i].last_use = 0; - dev->srLastUse = 0; + dev->cache_last_use = 0; } - dev->srLastUse++; + dev->cache_last_use++; - cache->lastUse = dev->srLastUse; + cache->last_use = dev->cache_last_use; - if (isAWrite) + if (is_write) cache->dirty = 1; } } @@ -3396,10 +3262,11 @@ static void yaffs_UseChunkCache(yaffs_Device *dev, yaffs_ChunkCache *cache, * Do this when a whole page gets written, * ie the short cache for this page is no longer valid. */ -static void yaffs_InvalidateChunkCache(yaffs_Object *object, int chunkId) +static void yaffs_invalidate_chunk_cache(struct yaffs_obj *object, int chunk_id) { - if (object->myDev->param.nShortOpCaches > 0) { - yaffs_ChunkCache *cache = yaffs_FindChunkCache(object, chunkId); + if (object->my_dev->param.n_caches > 0) { + struct yaffs_cache *cache = + yaffs_find_chunk_cache(object, chunk_id); if (cache) cache->object = NULL; @@ -3409,21 +3276,20 @@ static void yaffs_InvalidateChunkCache(yaffs_Object *object, int chunkId) /* Invalidate all the cache pages associated with this object * Do this whenever ther file is deleted or resized. */ -static void yaffs_InvalidateWholeChunkCache(yaffs_Object *in) +static void yaffs_invalidate_whole_cache(struct yaffs_obj *in) { int i; - yaffs_Device *dev = in->myDev; + struct yaffs_dev *dev = in->my_dev; - if (dev->param.nShortOpCaches > 0) { + if (dev->param.n_caches > 0) { /* Invalidate it. */ - for (i = 0; i < dev->param.nShortOpCaches; i++) { - if (dev->srCache[i].object == in) - dev->srCache[i].object = NULL; + for (i = 0; i < dev->param.n_caches; i++) { + if (dev->cache[i].object == in) + dev->cache[i].object = NULL; } } } - /*--------------------- File read/write ------------------------ * Read and write have very similar structures. * In general the read/write has three parts to it @@ -3434,381 +3300,372 @@ static void yaffs_InvalidateWholeChunkCache(yaffs_Object *in) * Curve-balls: the first chunk might also be the last chunk. */ -int yaffs_ReadDataFromFile(yaffs_Object *in, __u8 *buffer, loff_t offset, - int nBytes) +int yaffs_file_rd(struct yaffs_obj *in, u8 * buffer, loff_t offset, int n_bytes) { int chunk; - __u32 start; - int nToCopy; - int n = nBytes; - int nDone = 0; - yaffs_ChunkCache *cache; + u32 start; + int n_copy; + int n = n_bytes; + int n_done = 0; + struct yaffs_cache *cache; - yaffs_Device *dev; + struct yaffs_dev *dev; - dev = in->myDev; + dev = in->my_dev; while (n > 0) { - /* chunk = offset / dev->nDataBytesPerChunk + 1; */ - /* start = offset % dev->nDataBytesPerChunk; */ - yaffs_AddrToChunk(dev, offset, &chunk, &start); + /* chunk = offset / dev->data_bytes_per_chunk + 1; */ + /* start = offset % dev->data_bytes_per_chunk; */ + yaffs_addr_to_chunk(dev, offset, &chunk, &start); chunk++; /* OK now check for the curveball where the start and end are in * the same chunk. */ - if ((start + n) < dev->nDataBytesPerChunk) - nToCopy = n; + if ((start + n) < dev->data_bytes_per_chunk) + n_copy = n; else - nToCopy = dev->nDataBytesPerChunk - start; + n_copy = dev->data_bytes_per_chunk - start; - cache = yaffs_FindChunkCache(in, chunk); + cache = yaffs_find_chunk_cache(in, chunk); /* If the chunk is already in the cache or it is less than a whole chunk * or we're using inband tags then use the cache (if there is caching) * else bypass the cache. */ - if (cache || nToCopy != dev->nDataBytesPerChunk || dev->param.inbandTags) { - if (dev->param.nShortOpCaches > 0) { + if (cache || n_copy != dev->data_bytes_per_chunk + || dev->param.inband_tags) { + if (dev->param.n_caches > 0) { /* If we can't find the data in the cache, then load it up. */ if (!cache) { - cache = yaffs_GrabChunkCache(in->myDev); + cache = + yaffs_grab_chunk_cache(in->my_dev); cache->object = in; - cache->chunkId = chunk; + cache->chunk_id = chunk; cache->dirty = 0; cache->locked = 0; - yaffs_ReadChunkDataFromObject(in, chunk, - cache-> - data); - cache->nBytes = 0; + yaffs_rd_data_obj(in, chunk, + cache->data); + cache->n_bytes = 0; } - yaffs_UseChunkCache(dev, cache, 0); + yaffs_use_cache(dev, cache, 0); cache->locked = 1; - - memcpy(buffer, &cache->data[start], nToCopy); + memcpy(buffer, &cache->data[start], n_copy); cache->locked = 0; } else { - /* Read into the local buffer then copy..*/ + /* Read into the local buffer then copy.. */ - __u8 *localBuffer = - yaffs_GetTempBuffer(dev, __LINE__); - yaffs_ReadChunkDataFromObject(in, chunk, - localBuffer); + u8 *local_buffer = + yaffs_get_temp_buffer(dev, __LINE__); + yaffs_rd_data_obj(in, chunk, local_buffer); - memcpy(buffer, &localBuffer[start], nToCopy); + memcpy(buffer, &local_buffer[start], n_copy); - - yaffs_ReleaseTempBuffer(dev, localBuffer, - __LINE__); + yaffs_release_temp_buffer(dev, local_buffer, + __LINE__); } } else { /* A full chunk. Read directly into the supplied buffer. */ - yaffs_ReadChunkDataFromObject(in, chunk, buffer); + yaffs_rd_data_obj(in, chunk, buffer); } - n -= nToCopy; - offset += nToCopy; - buffer += nToCopy; - nDone += nToCopy; + n -= n_copy; + offset += n_copy; + buffer += n_copy; + n_done += n_copy; } - return nDone; + return n_done; } -int yaffs_DoWriteDataToFile(yaffs_Object *in, const __u8 *buffer, loff_t offset, - int nBytes, int writeThrough) +int yaffs_do_file_wr(struct yaffs_obj *in, const u8 * buffer, loff_t offset, + int n_bytes, int write_trhrough) { int chunk; - __u32 start; - int nToCopy; - int n = nBytes; - int nDone = 0; - int nToWriteBack; - int startOfWrite = offset; - int chunkWritten = 0; - __u32 nBytesRead; - __u32 chunkStart; + u32 start; + int n_copy; + int n = n_bytes; + int n_done = 0; + int n_writeback; + int start_write = offset; + int chunk_written = 0; + u32 n_bytes_read; + u32 chunk_start; - yaffs_Device *dev; + struct yaffs_dev *dev; - dev = in->myDev; + dev = in->my_dev; - while (n > 0 && chunkWritten >= 0) { - yaffs_AddrToChunk(dev, offset, &chunk, &start); + while (n > 0 && chunk_written >= 0) { + yaffs_addr_to_chunk(dev, offset, &chunk, &start); - if (chunk * dev->nDataBytesPerChunk + start != offset || - start >= dev->nDataBytesPerChunk) { - T(YAFFS_TRACE_ERROR, ( - TSTR("AddrToChunk of offset %d gives chunk %d start %d" - TENDSTR), - (int)offset, chunk, start)); + if (chunk * dev->data_bytes_per_chunk + start != offset || + start >= dev->data_bytes_per_chunk) { + T(YAFFS_TRACE_ERROR, + (TSTR + ("AddrToChunk of offset %d gives chunk %d start %d" + TENDSTR), (int)offset, chunk, start)); } - chunk++; /* File pos to chunk in file offset */ + chunk++; /* File pos to chunk in file offset */ /* OK now check for the curveball where the start and end are in * the same chunk. */ - if ((start + n) < dev->nDataBytesPerChunk) { - nToCopy = n; + if ((start + n) < dev->data_bytes_per_chunk) { + n_copy = n; /* Now folks, to calculate how many bytes to write back.... * If we're overwriting and not writing to then end of file then * we need to write back as much as was there before. */ - chunkStart = ((chunk - 1) * dev->nDataBytesPerChunk); + chunk_start = ((chunk - 1) * dev->data_bytes_per_chunk); - if (chunkStart > in->variant.fileVariant.fileSize) - nBytesRead = 0; /* Past end of file */ + if (chunk_start > in->variant.file_variant.file_size) + n_bytes_read = 0; /* Past end of file */ else - nBytesRead = in->variant.fileVariant.fileSize - chunkStart; + n_bytes_read = + in->variant.file_variant.file_size - + chunk_start; - if (nBytesRead > dev->nDataBytesPerChunk) - nBytesRead = dev->nDataBytesPerChunk; + if (n_bytes_read > dev->data_bytes_per_chunk) + n_bytes_read = dev->data_bytes_per_chunk; - nToWriteBack = - (nBytesRead > - (start + n)) ? nBytesRead : (start + n); + n_writeback = + (n_bytes_read > + (start + n)) ? n_bytes_read : (start + n); - if (nToWriteBack < 0 || nToWriteBack > dev->nDataBytesPerChunk) + if (n_writeback < 0 + || n_writeback > dev->data_bytes_per_chunk) YBUG(); } else { - nToCopy = dev->nDataBytesPerChunk - start; - nToWriteBack = dev->nDataBytesPerChunk; + n_copy = dev->data_bytes_per_chunk - start; + n_writeback = dev->data_bytes_per_chunk; } - if (nToCopy != dev->nDataBytesPerChunk || dev->param.inbandTags) { + if (n_copy != dev->data_bytes_per_chunk + || dev->param.inband_tags) { /* An incomplete start or end chunk (or maybe both start and end chunk), * or we're using inband tags, so we want to use the cache buffers. */ - if (dev->param.nShortOpCaches > 0) { - yaffs_ChunkCache *cache; + if (dev->param.n_caches > 0) { + struct yaffs_cache *cache; /* If we can't find the data in the cache, then load the cache */ - cache = yaffs_FindChunkCache(in, chunk); + cache = yaffs_find_chunk_cache(in, chunk); if (!cache - && yaffs_CheckSpaceForAllocation(dev, 1)) { - cache = yaffs_GrabChunkCache(dev); + && yaffs_check_alloc_available(dev, 1)) { + cache = yaffs_grab_chunk_cache(dev); cache->object = in; - cache->chunkId = chunk; + cache->chunk_id = chunk; cache->dirty = 0; cache->locked = 0; - yaffs_ReadChunkDataFromObject(in, chunk, - cache->data); + yaffs_rd_data_obj(in, chunk, + cache->data); } else if (cache && - !cache->dirty && - !yaffs_CheckSpaceForAllocation(dev, 1)) { + !cache->dirty && + !yaffs_check_alloc_available(dev, + 1)) { /* Drop the cache if it was a read cache item and * no space check has been made for it. */ - cache = NULL; + cache = NULL; } if (cache) { - yaffs_UseChunkCache(dev, cache, 1); + yaffs_use_cache(dev, cache, 1); cache->locked = 1; - memcpy(&cache->data[start], buffer, - nToCopy); - + n_copy); cache->locked = 0; - cache->nBytes = nToWriteBack; + cache->n_bytes = n_writeback; - if (writeThrough) { - chunkWritten = - yaffs_WriteChunkDataToObject + if (write_trhrough) { + chunk_written = + yaffs_wr_data_obj (cache->object, - cache->chunkId, - cache->data, cache->nBytes, - 1); + cache->chunk_id, + cache->data, + cache->n_bytes, 1); cache->dirty = 0; } } else { - chunkWritten = -1; /* fail the write */ + chunk_written = -1; /* fail the write */ } } else { /* An incomplete start or end chunk (or maybe both start and end chunk) * Read into the local buffer then copy, then copy over and write back. */ - __u8 *localBuffer = - yaffs_GetTempBuffer(dev, __LINE__); + u8 *local_buffer = + yaffs_get_temp_buffer(dev, __LINE__); - yaffs_ReadChunkDataFromObject(in, chunk, - localBuffer); + yaffs_rd_data_obj(in, chunk, local_buffer); + memcpy(&local_buffer[start], buffer, n_copy); + chunk_written = + yaffs_wr_data_obj(in, chunk, + local_buffer, + n_writeback, 0); - memcpy(&localBuffer[start], buffer, nToCopy); - - chunkWritten = - yaffs_WriteChunkDataToObject(in, chunk, - localBuffer, - nToWriteBack, - 0); - - yaffs_ReleaseTempBuffer(dev, localBuffer, - __LINE__); + yaffs_release_temp_buffer(dev, local_buffer, + __LINE__); } } else { /* A full chunk. Write directly from the supplied buffer. */ - - - chunkWritten = - yaffs_WriteChunkDataToObject(in, chunk, buffer, - dev->nDataBytesPerChunk, - 0); + chunk_written = + yaffs_wr_data_obj(in, chunk, buffer, + dev->data_bytes_per_chunk, 0); /* Since we've overwritten the cached data, we better invalidate it. */ - yaffs_InvalidateChunkCache(in, chunk); + yaffs_invalidate_chunk_cache(in, chunk); } - if (chunkWritten >= 0) { - n -= nToCopy; - offset += nToCopy; - buffer += nToCopy; - nDone += nToCopy; + if (chunk_written >= 0) { + n -= n_copy; + offset += n_copy; + buffer += n_copy; + n_done += n_copy; } } /* Update file object */ - if ((startOfWrite + nDone) > in->variant.fileVariant.fileSize) - in->variant.fileVariant.fileSize = (startOfWrite + nDone); + if ((start_write + n_done) > in->variant.file_variant.file_size) + in->variant.file_variant.file_size = (start_write + n_done); in->dirty = 1; - return nDone; + return n_done; } -int yaffs_WriteDataToFile(yaffs_Object *in, const __u8 *buffer, loff_t offset, - int nBytes, int writeThrough) +int yaffs_wr_file(struct yaffs_obj *in, const u8 * buffer, loff_t offset, + int n_bytes, int write_trhrough) { - yaffs2_HandleHole(in,offset); - return yaffs_DoWriteDataToFile(in,buffer,offset,nBytes,writeThrough); + yaffs2_handle_hole(in, offset); + return yaffs_do_file_wr(in, buffer, offset, n_bytes, write_trhrough); } - - /* ---------------------- File resizing stuff ------------------ */ -static void yaffs_PruneResizedChunks(yaffs_Object *in, int newSize) +static void yaffs_prune_chunks(struct yaffs_obj *in, int new_size) { - yaffs_Device *dev = in->myDev; - int oldFileSize = in->variant.fileVariant.fileSize; + struct yaffs_dev *dev = in->my_dev; + int old_size = in->variant.file_variant.file_size; - int lastDel = 1 + (oldFileSize - 1) / dev->nDataBytesPerChunk; + int last_del = 1 + (old_size - 1) / dev->data_bytes_per_chunk; - int startDel = 1 + (newSize + dev->nDataBytesPerChunk - 1) / - dev->nDataBytesPerChunk; + int start_del = 1 + (new_size + dev->data_bytes_per_chunk - 1) / + dev->data_bytes_per_chunk; int i; - int chunkId; + int chunk_id; /* Delete backwards so that we don't end up with holes if * power is lost part-way through the operation. */ - for (i = lastDel; i >= startDel; i--) { + for (i = last_del; i >= start_del; i--) { /* NB this could be optimised somewhat, * eg. could retrieve the tags and write them without - * using yaffs_DeleteChunk + * using yaffs_chunk_del */ - chunkId = yaffs_FindAndDeleteChunkInFile(in, i, NULL); - if (chunkId > 0) { - if (chunkId < - (dev->internalStartBlock * dev->param.nChunksPerBlock) - || chunkId >= - ((dev->internalEndBlock + - 1) * dev->param.nChunksPerBlock)) { + chunk_id = yaffs_find_del_file_chunk(in, i, NULL); + if (chunk_id > 0) { + if (chunk_id < + (dev->internal_start_block * + dev->param.chunks_per_block) + || chunk_id >= + ((dev->internal_end_block + + 1) * dev->param.chunks_per_block)) { T(YAFFS_TRACE_ALWAYS, - (TSTR("Found daft chunkId %d for %d" TENDSTR), - chunkId, i)); + (TSTR + ("Found daft chunk_id %d for %d" TENDSTR), + chunk_id, i)); } else { - in->nDataChunks--; - yaffs_DeleteChunk(dev, chunkId, 1, __LINE__); + in->n_data_chunks--; + yaffs_chunk_del(dev, chunk_id, 1, __LINE__); } } } } - -void yaffs_ResizeDown( yaffs_Object *obj, loff_t newSize) +void yaffs_resize_file_down(struct yaffs_obj *obj, loff_t new_size) { - int newFullChunks; - __u32 newSizeOfPartialChunk; - yaffs_Device *dev = obj->myDev; + int new_full; + u32 new_partial; + struct yaffs_dev *dev = obj->my_dev; - yaffs_AddrToChunk(dev, newSize, &newFullChunks, &newSizeOfPartialChunk); + yaffs_addr_to_chunk(dev, new_size, &new_full, &new_partial); - yaffs_PruneResizedChunks(obj, newSize); + yaffs_prune_chunks(obj, new_size); - if (newSizeOfPartialChunk != 0) { - int lastChunk = 1 + newFullChunks; - __u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__); + if (new_partial != 0) { + int last_chunk = 1 + new_full; + u8 *local_buffer = yaffs_get_temp_buffer(dev, __LINE__); /* Got to read and rewrite the last chunk with its new size and zero pad */ - yaffs_ReadChunkDataFromObject(obj, lastChunk, localBuffer); - memset(localBuffer + newSizeOfPartialChunk, 0, - dev->nDataBytesPerChunk - newSizeOfPartialChunk); + yaffs_rd_data_obj(obj, last_chunk, local_buffer); + memset(local_buffer + new_partial, 0, + dev->data_bytes_per_chunk - new_partial); - yaffs_WriteChunkDataToObject(obj, lastChunk, localBuffer, - newSizeOfPartialChunk, 1); + yaffs_wr_data_obj(obj, last_chunk, local_buffer, + new_partial, 1); - yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__); + yaffs_release_temp_buffer(dev, local_buffer, __LINE__); } - obj->variant.fileVariant.fileSize = newSize; + obj->variant.file_variant.file_size = new_size; - yaffs_PruneFileStructure(dev, &obj->variant.fileVariant); + yaffs_prune_tree(dev, &obj->variant.file_variant); } - -int yaffs_ResizeFile(yaffs_Object *in, loff_t newSize) +int yaffs_resize_file(struct yaffs_obj *in, loff_t new_size) { - yaffs_Device *dev = in->myDev; - int oldFileSize = in->variant.fileVariant.fileSize; + struct yaffs_dev *dev = in->my_dev; + int old_size = in->variant.file_variant.file_size; - yaffs_FlushFilesChunkCache(in); - yaffs_InvalidateWholeChunkCache(in); + yaffs_flush_file_cache(in); + yaffs_invalidate_whole_cache(in); - yaffs_CheckGarbageCollection(dev,0); + yaffs_check_gc(dev, 0); - if (in->variantType != YAFFS_OBJECT_TYPE_FILE) + if (in->variant_type != YAFFS_OBJECT_TYPE_FILE) return YAFFS_FAIL; - if (newSize == oldFileSize) + if (new_size == old_size) return YAFFS_OK; - - if(newSize > oldFileSize){ - yaffs2_HandleHole(in,newSize); - in->variant.fileVariant.fileSize = newSize; + + if (new_size > old_size) { + yaffs2_handle_hole(in, new_size); + in->variant.file_variant.file_size = new_size; } else { - /* newSize < oldFileSize */ - yaffs_ResizeDown(in, newSize); - } + /* new_size < old_size */ + yaffs_resize_file_down(in, new_size); + } /* Write a new object header to reflect the resize. * show we've shrunk the file, if need be @@ -3816,234 +3673,209 @@ int yaffs_ResizeFile(yaffs_Object *in, loff_t newSize) * and is not shadowed. */ if (in->parent && - !in->isShadowed && - in->parent->objectId != YAFFS_OBJECTID_UNLINKED && - in->parent->objectId != YAFFS_OBJECTID_DELETED) - yaffs_UpdateObjectHeader(in, NULL, 0, 0, 0, NULL); - + !in->is_shadowed && + in->parent->obj_id != YAFFS_OBJECTID_UNLINKED && + in->parent->obj_id != YAFFS_OBJECTID_DELETED) + yaffs_update_oh(in, NULL, 0, 0, 0, NULL); return YAFFS_OK; } -loff_t yaffs_GetFileSize(yaffs_Object *obj) +int yaffs_flush_file(struct yaffs_obj *in, int update_time, int data_sync) { - YCHAR *alias = NULL; - obj = yaffs_GetEquivalentObject(obj); - - switch (obj->variantType) { - case YAFFS_OBJECT_TYPE_FILE: - return obj->variant.fileVariant.fileSize; - case YAFFS_OBJECT_TYPE_SYMLINK: - alias = obj->variant.symLinkVariant.alias; - if(!alias) - return 0; - return yaffs_strnlen(alias,YAFFS_MAX_ALIAS_LENGTH); - default: - return 0; - } -} - - - -int yaffs_FlushFile(yaffs_Object *in, int updateTime, int dataSync) -{ - int retVal; + int ret_val; if (in->dirty) { - yaffs_FlushFilesChunkCache(in); - if(dataSync) /* Only sync data */ - retVal=YAFFS_OK; + yaffs_flush_file_cache(in); + if (data_sync) /* Only sync data */ + ret_val = YAFFS_OK; else { - if (updateTime) { -#ifdef CONFIG_YAFFS_WINCE - yfsd_WinFileTimeNow(in->win_mtime); -#else + if (update_time) + yaffs_load_current_time(in, 0, 0); - in->yst_mtime = Y_CURRENT_TIME; - -#endif - } - - retVal = (yaffs_UpdateObjectHeader(in, NULL, 0, 0, 0, NULL) >= - 0) ? YAFFS_OK : YAFFS_FAIL; + ret_val = (yaffs_update_oh(in, NULL, 0, 0, 0, NULL) >= + 0) ? YAFFS_OK : YAFFS_FAIL; } } else { - retVal = YAFFS_OK; + ret_val = YAFFS_OK; } - return retVal; + return ret_val; } -static int yaffs_DoGenericObjectDeletion(yaffs_Object *in) +static int yaffs_generic_obj_del(struct yaffs_obj *in) { /* First off, invalidate the file's data in the cache, without flushing. */ - yaffs_InvalidateWholeChunkCache(in); + yaffs_invalidate_whole_cache(in); - if (in->myDev->param.isYaffs2 && (in->parent != in->myDev->deletedDir)) { + if (in->my_dev->param.is_yaffs2 && (in->parent != in->my_dev->del_dir)) { /* Move to the unlinked directory so we have a record that it was deleted. */ - yaffs_ChangeObjectName(in, in->myDev->deletedDir, _Y("deleted"), 0, 0); + yaffs_change_obj_name(in, in->my_dev->del_dir, _Y("deleted"), 0, + 0); } - yaffs_RemoveObjectFromDirectory(in); - yaffs_DeleteChunk(in->myDev, in->hdrChunk, 1, __LINE__); - in->hdrChunk = 0; + yaffs_remove_obj_from_dir(in); + yaffs_chunk_del(in->my_dev, in->hdr_chunk, 1, __LINE__); + in->hdr_chunk = 0; - yaffs_FreeObject(in); + yaffs_free_obj(in); return YAFFS_OK; } -/* yaffs_DeleteFile deletes the whole file data +/* yaffs_del_file deletes the whole file data * and the inode associated with the file. * It does not delete the links associated with the file. */ -static int yaffs_UnlinkFileIfNeeded(yaffs_Object *in) +static int yaffs_unlink_file_if_needed(struct yaffs_obj *in) { - int retVal; - int immediateDeletion = 0; - yaffs_Device *dev = in->myDev; + int ret_val; + int del_now = 0; + struct yaffs_dev *dev = in->my_dev; - if (!in->myInode) - immediateDeletion = 1; + if (!in->my_inode) + del_now = 1; - if (immediateDeletion) { - retVal = - yaffs_ChangeObjectName(in, in->myDev->deletedDir, - _Y("deleted"), 0, 0); + if (del_now) { + ret_val = + yaffs_change_obj_name(in, in->my_dev->del_dir, + _Y("deleted"), 0, 0); T(YAFFS_TRACE_TRACING, (TSTR("yaffs: immediate deletion of file %d" TENDSTR), - in->objectId)); + in->obj_id)); in->deleted = 1; - in->myDev->nDeletedFiles++; - if (dev->param.disableSoftDelete || dev->param.isYaffs2) - yaffs_ResizeFile(in, 0); - yaffs_SoftDeleteFile(in); + in->my_dev->n_deleted_files++; + if (dev->param.disable_soft_del || dev->param.is_yaffs2) + yaffs_resize_file(in, 0); + yaffs_soft_del_file(in); } else { - retVal = - yaffs_ChangeObjectName(in, in->myDev->unlinkedDir, - _Y("unlinked"), 0, 0); + ret_val = + yaffs_change_obj_name(in, in->my_dev->unlinked_dir, + _Y("unlinked"), 0, 0); } - - return retVal; + return ret_val; } -int yaffs_DeleteFile(yaffs_Object *in) +int yaffs_del_file(struct yaffs_obj *in) { - int retVal = YAFFS_OK; - int deleted; /* Need to cache value on stack if in is freed */ - yaffs_Device *dev = in->myDev; + int ret_val = YAFFS_OK; + int deleted; /* Need to cache value on stack if in is freed */ + struct yaffs_dev *dev = in->my_dev; - if (dev->param.disableSoftDelete || dev->param.isYaffs2) - yaffs_ResizeFile(in, 0); + if (dev->param.disable_soft_del || dev->param.is_yaffs2) + yaffs_resize_file(in, 0); - if (in->nDataChunks > 0) { + if (in->n_data_chunks > 0) { /* Use soft deletion if there is data in the file. * That won't be the case if it has been resized to zero. */ if (!in->unlinked) - retVal = yaffs_UnlinkFileIfNeeded(in); + ret_val = yaffs_unlink_file_if_needed(in); deleted = in->deleted; - if (retVal == YAFFS_OK && in->unlinked && !in->deleted) { + if (ret_val == YAFFS_OK && in->unlinked && !in->deleted) { in->deleted = 1; deleted = 1; - in->myDev->nDeletedFiles++; - yaffs_SoftDeleteFile(in); + in->my_dev->n_deleted_files++; + yaffs_soft_del_file(in); } return deleted ? YAFFS_OK : YAFFS_FAIL; } else { /* The file has no data chunks so we toss it immediately */ - yaffs_FreeTnode(in->myDev, in->variant.fileVariant.top); - in->variant.fileVariant.top = NULL; - yaffs_DoGenericObjectDeletion(in); + yaffs_free_tnode(in->my_dev, in->variant.file_variant.top); + in->variant.file_variant.top = NULL; + yaffs_generic_obj_del(in); return YAFFS_OK; } } -static int yaffs_IsNonEmptyDirectory(yaffs_Object *obj) +static int yaffs_is_non_empty_dir(struct yaffs_obj *obj) { - return (obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY) && - !(ylist_empty(&obj->variant.directoryVariant.children)); + return (obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) && + !(list_empty(&obj->variant.dir_variant.children)); } -static int yaffs_DeleteDirectory(yaffs_Object *obj) +static int yaffs_del_dir(struct yaffs_obj *obj) { /* First check that the directory is empty. */ - if (yaffs_IsNonEmptyDirectory(obj)) + if (yaffs_is_non_empty_dir(obj)) return YAFFS_FAIL; - return yaffs_DoGenericObjectDeletion(obj); + return yaffs_generic_obj_del(obj); } -static int yaffs_DeleteSymLink(yaffs_Object *in) +static int yaffs_del_symlink(struct yaffs_obj *in) { - if(in->variant.symLinkVariant.alias) - YFREE(in->variant.symLinkVariant.alias); - in->variant.symLinkVariant.alias=NULL; + if (in->variant.symlink_variant.alias) + YFREE(in->variant.symlink_variant.alias); + in->variant.symlink_variant.alias = NULL; - return yaffs_DoGenericObjectDeletion(in); + return yaffs_generic_obj_del(in); } -static int yaffs_DeleteHardLink(yaffs_Object *in) +static int yaffs_del_link(struct yaffs_obj *in) { /* remove this hardlink from the list assocaited with the equivalent * object */ - ylist_del_init(&in->hardLinks); - return yaffs_DoGenericObjectDeletion(in); + list_del_init(&in->hard_links); + return yaffs_generic_obj_del(in); } -int yaffs_DeleteObject(yaffs_Object *obj) +int yaffs_del_obj(struct yaffs_obj *obj) { -int retVal = -1; - switch (obj->variantType) { + int ret_val = -1; + switch (obj->variant_type) { case YAFFS_OBJECT_TYPE_FILE: - retVal = yaffs_DeleteFile(obj); + ret_val = yaffs_del_file(obj); break; case YAFFS_OBJECT_TYPE_DIRECTORY: - if(!ylist_empty(&obj->variant.directoryVariant.dirty)){ - T(YAFFS_TRACE_BACKGROUND, (TSTR("Remove object %d from dirty directories" TENDSTR),obj->objectId)); - ylist_del_init(&obj->variant.directoryVariant.dirty); + if (!list_empty(&obj->variant.dir_variant.dirty)) { + T(YAFFS_TRACE_BACKGROUND, + (TSTR + ("Remove object %d from dirty directories" TENDSTR), + obj->obj_id)); + list_del_init(&obj->variant.dir_variant.dirty); } - return yaffs_DeleteDirectory(obj); + return yaffs_del_dir(obj); break; case YAFFS_OBJECT_TYPE_SYMLINK: - retVal = yaffs_DeleteSymLink(obj); + ret_val = yaffs_del_symlink(obj); break; case YAFFS_OBJECT_TYPE_HARDLINK: - retVal = yaffs_DeleteHardLink(obj); + ret_val = yaffs_del_link(obj); break; case YAFFS_OBJECT_TYPE_SPECIAL: - retVal = yaffs_DoGenericObjectDeletion(obj); + ret_val = yaffs_generic_obj_del(obj); break; case YAFFS_OBJECT_TYPE_UNKNOWN: - retVal = 0; + ret_val = 0; break; /* should not happen. */ } - return retVal; + return ret_val; } -static int yaffs_UnlinkWorker(yaffs_Object *obj) +static int yaffs_unlink_worker(struct yaffs_obj *obj) { - int immediateDeletion = 0; + int del_now = 0; - if (!obj->myInode) - immediateDeletion = 1; + if (!obj->my_inode) + del_now = 1; - if(obj) - yaffs_UpdateParent(obj->parent); + if (obj) + yaffs_update_parent(obj->parent); - if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) { - return yaffs_DeleteHardLink(obj); - } else if (!ylist_empty(&obj->hardLinks)) { + if (obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) { + return yaffs_del_link(obj); + } else if (!list_empty(&obj->hard_links)) { /* Curve ball: We're unlinking an object that has a hardlink. * * This problem arises because we are not strictly following @@ -4058,80 +3890,81 @@ static int yaffs_UnlinkWorker(yaffs_Object *obj) * - Delete the hardlink */ - yaffs_Object *hl; - yaffs_Object *parent; - int retVal; + struct yaffs_obj *hl; + struct yaffs_obj *parent; + int ret_val; YCHAR name[YAFFS_MAX_NAME_LENGTH + 1]; - hl = ylist_entry(obj->hardLinks.next, yaffs_Object, hardLinks); + hl = list_entry(obj->hard_links.next, struct yaffs_obj, + hard_links); - yaffs_GetObjectName(hl, name, YAFFS_MAX_NAME_LENGTH + 1); + yaffs_get_obj_name(hl, name, YAFFS_MAX_NAME_LENGTH + 1); parent = hl->parent; - ylist_del_init(&hl->hardLinks); + list_del_init(&hl->hard_links); - yaffs_AddObjectToDirectory(obj->myDev->unlinkedDir, hl); + yaffs_add_obj_to_dir(obj->my_dev->unlinked_dir, hl); - retVal = yaffs_ChangeObjectName(obj,parent, name, 0, 0); + ret_val = yaffs_change_obj_name(obj, parent, name, 0, 0); - if (retVal == YAFFS_OK) - retVal = yaffs_DoGenericObjectDeletion(hl); + if (ret_val == YAFFS_OK) + ret_val = yaffs_generic_obj_del(hl); - return retVal; + return ret_val; - } else if (immediateDeletion) { - switch (obj->variantType) { + } else if (del_now) { + switch (obj->variant_type) { case YAFFS_OBJECT_TYPE_FILE: - return yaffs_DeleteFile(obj); + return yaffs_del_file(obj); break; case YAFFS_OBJECT_TYPE_DIRECTORY: - ylist_del_init(&obj->variant.directoryVariant.dirty); - return yaffs_DeleteDirectory(obj); + list_del_init(&obj->variant.dir_variant.dirty); + return yaffs_del_dir(obj); break; case YAFFS_OBJECT_TYPE_SYMLINK: - return yaffs_DeleteSymLink(obj); + return yaffs_del_symlink(obj); break; case YAFFS_OBJECT_TYPE_SPECIAL: - return yaffs_DoGenericObjectDeletion(obj); + return yaffs_generic_obj_del(obj); break; case YAFFS_OBJECT_TYPE_HARDLINK: case YAFFS_OBJECT_TYPE_UNKNOWN: default: return YAFFS_FAIL; } - } else if(yaffs_IsNonEmptyDirectory(obj)) + } else if (yaffs_is_non_empty_dir(obj)) return YAFFS_FAIL; else - return yaffs_ChangeObjectName(obj, obj->myDev->unlinkedDir, - _Y("unlinked"), 0, 0); + return yaffs_change_obj_name(obj, obj->my_dev->unlinked_dir, + _Y("unlinked"), 0, 0); } - -static int yaffs_UnlinkObject(yaffs_Object *obj) +static int yaffs_unlink_obj(struct yaffs_obj *obj) { - if (obj && obj->unlinkAllowed) - return yaffs_UnlinkWorker(obj); + if (obj && obj->unlink_allowed) + return yaffs_unlink_worker(obj); return YAFFS_FAIL; } -int yaffs_Unlink(yaffs_Object *dir, const YCHAR *name) -{ - yaffs_Object *obj; - obj = yaffs_FindObjectByName(dir, name); - return yaffs_UnlinkObject(obj); +int yaffs_unlinker(struct yaffs_obj *dir, const YCHAR * name) +{ + struct yaffs_obj *obj; + + obj = yaffs_find_by_name(dir, name); + return yaffs_unlink_obj(obj); } /*----------------------- Initialisation Scanning ---------------------- */ -void yaffs_HandleShadowedObject(yaffs_Device *dev, int objId, - int backwardScanning) +void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id, + int backward_scanning) { - yaffs_Object *obj; + struct yaffs_obj *obj; - if (!backwardScanning) { + if (!backward_scanning) { /* Handle YAFFS1 forward scanning case * For YAFFS1 we always do the deletion */ @@ -4140,8 +3973,8 @@ void yaffs_HandleShadowedObject(yaffs_Device *dev, int objId, /* Handle YAFFS2 case (backward scanning) * If the shadowed object exists then ignore. */ - obj = yaffs_FindObjectByNumber(dev, objId); - if(obj) + obj = yaffs_find_by_number(dev, obj_id); + if (obj) return; } @@ -4149,73 +3982,69 @@ void yaffs_HandleShadowedObject(yaffs_Device *dev, int objId, * We put it in unlinked dir to be cleaned up after the scanning */ obj = - yaffs_FindOrCreateObjectByNumber(dev, objId, - YAFFS_OBJECT_TYPE_FILE); + yaffs_find_or_create_by_number(dev, obj_id, YAFFS_OBJECT_TYPE_FILE); if (!obj) return; - obj->isShadowed = 1; - yaffs_AddObjectToDirectory(dev->unlinkedDir, obj); - obj->variant.fileVariant.shrinkSize = 0; + obj->is_shadowed = 1; + yaffs_add_obj_to_dir(dev->unlinked_dir, obj); + obj->variant.file_variant.shrink_size = 0; obj->valid = 1; /* So that we don't read any other info for this file */ } - -void yaffs_HardlinkFixup(yaffs_Device *dev, yaffs_Object *hardList) +void yaffs_link_fixup(struct yaffs_dev *dev, struct yaffs_obj *hard_list) { - yaffs_Object *hl; - yaffs_Object *in; + struct yaffs_obj *hl; + struct yaffs_obj *in; - while (hardList) { - hl = hardList; - hardList = (yaffs_Object *) (hardList->hardLinks.next); + while (hard_list) { + hl = hard_list; + hard_list = (struct yaffs_obj *)(hard_list->hard_links.next); - in = yaffs_FindObjectByNumber(dev, - hl->variant.hardLinkVariant. - equivalentObjectId); + in = yaffs_find_by_number(dev, + hl->variant. + hardlink_variant.equiv_id); if (in) { /* Add the hardlink pointers */ - hl->variant.hardLinkVariant.equivalentObject = in; - ylist_add(&hl->hardLinks, &in->hardLinks); + hl->variant.hardlink_variant.equiv_obj = in; + list_add(&hl->hard_links, &in->hard_links); } else { /* Todo Need to report/handle this better. * Got a problem... hardlink to a non-existant object */ - hl->variant.hardLinkVariant.equivalentObject = NULL; - YINIT_LIST_HEAD(&hl->hardLinks); + hl->variant.hardlink_variant.equiv_obj = NULL; + INIT_LIST_HEAD(&hl->hard_links); } } } - -static void yaffs_StripDeletedObjects(yaffs_Device *dev) +static void yaffs_strip_deleted_objs(struct yaffs_dev *dev) { /* - * Sort out state of unlinked and deleted objects after scanning. - */ - struct ylist_head *i; - struct ylist_head *n; - yaffs_Object *l; + * Sort out state of unlinked and deleted objects after scanning. + */ + struct list_head *i; + struct list_head *n; + struct yaffs_obj *l; - if (dev->readOnly) + if (dev->read_only) return; /* Soft delete all the unlinked files */ - ylist_for_each_safe(i, n, - &dev->unlinkedDir->variant.directoryVariant.children) { + list_for_each_safe(i, n, + &dev->unlinked_dir->variant.dir_variant.children) { if (i) { - l = ylist_entry(i, yaffs_Object, siblings); - yaffs_DeleteObject(l); + l = list_entry(i, struct yaffs_obj, siblings); + yaffs_del_obj(l); } } - ylist_for_each_safe(i, n, - &dev->deletedDir->variant.directoryVariant.children) { + list_for_each_safe(i, n, &dev->del_dir->variant.dir_variant.children) { if (i) { - l = ylist_entry(i, yaffs_Object, siblings); - yaffs_DeleteObject(l); + l = list_entry(i, struct yaffs_obj, siblings); + yaffs_del_obj(l); } } @@ -4231,31 +4060,30 @@ static void yaffs_StripDeletedObjects(yaffs_Device *dev) * Note: * This code assumes that we don't ever change the current relationships between * directories: - * rootDir->parent == unlinkedDir->parent == deletedDir->parent == NULL - * lostNfound->parent == rootDir + * root_dir->parent == unlinked_dir->parent == del_dir->parent == NULL + * lost-n-found->parent == root_dir * * This fixes the problem where directories might have inadvertently been deleted * leaving the object "hanging" without being rooted in the directory tree. */ - -static int yaffs_HasNULLParent(yaffs_Device *dev, yaffs_Object *obj) + +static int yaffs_has_null_parent(struct yaffs_dev *dev, struct yaffs_obj *obj) { - return (obj == dev->deletedDir || - obj == dev->unlinkedDir|| - obj == dev->rootDir); + return (obj == dev->del_dir || + obj == dev->unlinked_dir || obj == dev->root_dir); } -static void yaffs_FixHangingObjects(yaffs_Device *dev) +static void yaffs_fix_hanging_objs(struct yaffs_dev *dev) { - yaffs_Object *obj; - yaffs_Object *parent; + struct yaffs_obj *obj; + struct yaffs_obj *parent; int i; - struct ylist_head *lh; - struct ylist_head *n; - int depthLimit; + struct list_head *lh; + struct list_head *n; + int depth_limit; int hanging; - if (dev->readOnly) + if (dev->read_only) return; /* Iterate through the objects in each hash entry, @@ -4263,146 +4091,131 @@ static void yaffs_FixHangingObjects(yaffs_Device *dev) * Make sure it is rooted. */ - for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { - ylist_for_each_safe(lh, n, &dev->objectBucket[i].list) { + for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { + list_for_each_safe(lh, n, &dev->obj_bucket[i].list) { if (lh) { - obj = ylist_entry(lh, yaffs_Object, hashLink); - parent= obj->parent; - - if(yaffs_HasNULLParent(dev,obj)){ + obj = + list_entry(lh, struct yaffs_obj, hash_link); + parent = obj->parent; + + if (yaffs_has_null_parent(dev, obj)) { /* These directories are not hanging */ hanging = 0; - } - else if(!parent || parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) + } else if (!parent + || parent->variant_type != + YAFFS_OBJECT_TYPE_DIRECTORY) hanging = 1; - else if(yaffs_HasNULLParent(dev,parent)) + else if (yaffs_has_null_parent(dev, parent)) hanging = 0; else { /* * Need to follow the parent chain to see if it is hanging. */ hanging = 0; - depthLimit=100; + depth_limit = 100; - while(parent != dev->rootDir && - parent->parent && - parent->parent->variantType == YAFFS_OBJECT_TYPE_DIRECTORY && - depthLimit > 0){ + while (parent != dev->root_dir && + parent->parent && + parent->parent->variant_type == + YAFFS_OBJECT_TYPE_DIRECTORY + && depth_limit > 0) { parent = parent->parent; - depthLimit--; + depth_limit--; } - if(parent != dev->rootDir) + if (parent != dev->root_dir) hanging = 1; } - if(hanging){ + if (hanging) { T(YAFFS_TRACE_SCAN, - (TSTR("Hanging object %d moved to lost and found" TENDSTR), - obj->objectId)); - yaffs_AddObjectToDirectory(dev->lostNFoundDir,obj); + (TSTR + ("Hanging object %d moved to lost and found" + TENDSTR), obj->obj_id)); + yaffs_add_obj_to_dir(dev->lost_n_found, + obj); } } } } } - /* * Delete directory contents for cleaning up lost and found. */ -static void yaffs_DeleteDirectoryContents(yaffs_Object *dir) +static void yaffs_del_dir_contents(struct yaffs_obj *dir) { - yaffs_Object *obj; - struct ylist_head *lh; - struct ylist_head *n; + struct yaffs_obj *obj; + struct list_head *lh; + struct list_head *n; - if(dir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) + if (dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) YBUG(); - - ylist_for_each_safe(lh, n, &dir->variant.directoryVariant.children) { + + list_for_each_safe(lh, n, &dir->variant.dir_variant.children) { if (lh) { - obj = ylist_entry(lh, yaffs_Object, siblings); - if(obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY) - yaffs_DeleteDirectoryContents(obj); + obj = list_entry(lh, struct yaffs_obj, siblings); + if (obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) + yaffs_del_dir_contents(obj); T(YAFFS_TRACE_SCAN, - (TSTR("Deleting lost_found object %d" TENDSTR), - obj->objectId)); + (TSTR("Deleting lost_found object %d" TENDSTR), + obj->obj_id)); /* Need to use UnlinkObject since Delete would not handle * hardlinked objects correctly. */ - yaffs_UnlinkObject(obj); + yaffs_unlink_obj(obj); } } - + } -static void yaffs_EmptyLostAndFound(yaffs_Device *dev) +static void yaffs_empty_l_n_f(struct yaffs_dev *dev) { - yaffs_DeleteDirectoryContents(dev->lostNFoundDir); + yaffs_del_dir_contents(dev->lost_n_found); } -static void yaffs_CheckObjectDetailsLoaded(yaffs_Object *in) +static void yaffs_check_obj_details_loaded(struct yaffs_obj *in) { - __u8 *chunkData; - yaffs_ObjectHeader *oh; - yaffs_Device *dev; - yaffs_ExtendedTags tags; + u8 *chunk_data; + struct yaffs_obj_hdr *oh; + struct yaffs_dev *dev; + struct yaffs_ext_tags tags; int result; int alloc_failed = 0; if (!in) return; - dev = in->myDev; + dev = in->my_dev; -#if 0 - T(YAFFS_TRACE_SCAN, (TSTR("details for object %d %s loaded" TENDSTR), - in->objectId, - in->lazyLoaded ? "not yet" : "already")); -#endif + if (in->lazy_loaded && in->hdr_chunk > 0) { + in->lazy_loaded = 0; + chunk_data = yaffs_get_temp_buffer(dev, __LINE__); - if (in->lazyLoaded && in->hdrChunk > 0) { - in->lazyLoaded = 0; - chunkData = yaffs_GetTempBuffer(dev, __LINE__); - - result = yaffs_ReadChunkWithTagsFromNAND(dev, in->hdrChunk, chunkData, &tags); - oh = (yaffs_ObjectHeader *) chunkData; + result = + yaffs_rd_chunk_tags_nand(dev, in->hdr_chunk, chunk_data, + &tags); + oh = (struct yaffs_obj_hdr *)chunk_data; in->yst_mode = oh->yst_mode; -#ifdef CONFIG_YAFFS_WINCE - in->win_atime[0] = oh->win_atime[0]; - in->win_ctime[0] = oh->win_ctime[0]; - in->win_mtime[0] = oh->win_mtime[0]; - in->win_atime[1] = oh->win_atime[1]; - in->win_ctime[1] = oh->win_ctime[1]; - in->win_mtime[1] = oh->win_mtime[1]; -#else - in->yst_uid = oh->yst_uid; - in->yst_gid = oh->yst_gid; - in->yst_atime = oh->yst_atime; - in->yst_mtime = oh->yst_mtime; - in->yst_ctime = oh->yst_ctime; - in->yst_rdev = oh->yst_rdev; + yaffs_load_attribs(in, oh); + yaffs_set_obj_name_from_oh(in, oh); -#endif - yaffs_SetObjectNameFromOH(in, oh); - - if (in->variantType == YAFFS_OBJECT_TYPE_SYMLINK) { - in->variant.symLinkVariant.alias = - yaffs_CloneString(oh->alias); - if (!in->variant.symLinkVariant.alias) - alloc_failed = 1; /* Not returned to caller */ + if (in->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) { + in->variant.symlink_variant.alias = + yaffs_clone_str(oh->alias); + if (!in->variant.symlink_variant.alias) + alloc_failed = 1; /* Not returned to caller */ } - yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__); + yaffs_release_temp_buffer(dev, chunk_data, __LINE__); } } /*------------------------------ Directory Functions ----------------------------- */ /* - *yaffs_UpdateParent() handles fixing a directories mtime and ctime when a new + *yaffs_update_parent() handles fixing a directories mtime and ctime when a new * link (ie. name) is created or deleted in the directory. * * ie. @@ -4413,79 +4226,77 @@ static void yaffs_CheckObjectDetailsLoaded(yaffs_Object *in) * This can be handled immediately or defered. Defering helps reduce the number * of updates when many files in a directory are changed within a brief period. * - * If the directory updating is defered then yaffs_UpdateDirtyDirecories must be + * If the directory updating is defered then yaffs_update_dirty_dirs must be * called periodically. */ - -static void yaffs_UpdateParent(yaffs_Object *obj) -{ - yaffs_Device *dev; - if(!obj) - return; -#ifndef CONFIG_YAFFS_WINCE - dev = obj->myDev; +static void yaffs_update_parent(struct yaffs_obj *obj) +{ + struct yaffs_dev *dev; + if (!obj) + return; + dev = obj->my_dev; obj->dirty = 1; - obj->yst_mtime = obj->yst_ctime = Y_CURRENT_TIME; - if(dev->param.deferDirectoryUpdate){ - struct ylist_head *link = &obj->variant.directoryVariant.dirty; - - if(ylist_empty(link)){ - ylist_add(link,&dev->dirtyDirectories); - T(YAFFS_TRACE_BACKGROUND, (TSTR("Added object %d to dirty directories" TENDSTR),obj->objectId)); + yaffs_load_current_time(obj, 0, 1); + if (dev->param.defered_dir_update) { + struct list_head *link = &obj->variant.dir_variant.dirty; + + if (list_empty(link)) { + list_add(link, &dev->dirty_dirs); + T(YAFFS_TRACE_BACKGROUND, + (TSTR("Added object %d to dirty directories" TENDSTR), + obj->obj_id)); } } else - yaffs_UpdateObjectHeader(obj, NULL, 0, 0, 0, NULL); -#endif + yaffs_update_oh(obj, NULL, 0, 0, 0, NULL); } -void yaffs_UpdateDirtyDirectories(yaffs_Device *dev) +void yaffs_update_dirty_dirs(struct yaffs_dev *dev) { - struct ylist_head *link; - yaffs_Object *obj; - yaffs_DirectoryStructure *dS; - yaffs_ObjectVariant *oV; + struct list_head *link; + struct yaffs_obj *obj; + struct yaffs_dir_var *d_s; + union yaffs_obj_var *o_v; T(YAFFS_TRACE_BACKGROUND, (TSTR("Update dirty directories" TENDSTR))); - while(!ylist_empty(&dev->dirtyDirectories)){ - link = dev->dirtyDirectories.next; - ylist_del_init(link); - - dS=ylist_entry(link,yaffs_DirectoryStructure,dirty); - oV = ylist_entry(dS,yaffs_ObjectVariant,directoryVariant); - obj = ylist_entry(oV,yaffs_Object,variant); + while (!list_empty(&dev->dirty_dirs)) { + link = dev->dirty_dirs.next; + list_del_init(link); - T(YAFFS_TRACE_BACKGROUND, (TSTR("Update directory %d" TENDSTR), obj->objectId)); + d_s = list_entry(link, struct yaffs_dir_var, dirty); + o_v = list_entry(d_s, union yaffs_obj_var, dir_variant); + obj = list_entry(o_v, struct yaffs_obj, variant); - if(obj->dirty) - yaffs_UpdateObjectHeader(obj, NULL, 0, 0, 0, NULL); + T(YAFFS_TRACE_BACKGROUND, + (TSTR("Update directory %d" TENDSTR), obj->obj_id)); + + if (obj->dirty) + yaffs_update_oh(obj, NULL, 0, 0, 0, NULL); } } -static void yaffs_RemoveObjectFromDirectory(yaffs_Object *obj) +static void yaffs_remove_obj_from_dir(struct yaffs_obj *obj) { - yaffs_Device *dev = obj->myDev; - yaffs_Object *parent; + struct yaffs_dev *dev = obj->my_dev; + struct yaffs_obj *parent; - yaffs_VerifyObjectInDirectory(obj); + yaffs_verify_obj_in_dir(obj); parent = obj->parent; - yaffs_VerifyDirectory(parent); + yaffs_verify_dir(parent); - if (dev && dev->param.removeObjectCallback) - dev->param.removeObjectCallback(obj); + if (dev && dev->param.remove_obj_fn) + dev->param.remove_obj_fn(obj); - - ylist_del_init(&obj->siblings); + list_del_init(&obj->siblings); obj->parent = NULL; - - yaffs_VerifyDirectory(parent); + + yaffs_verify_dir(parent); } -void yaffs_AddObjectToDirectory(yaffs_Object *directory, - yaffs_Object *obj) +void yaffs_add_obj_to_dir(struct yaffs_obj *directory, struct yaffs_obj *obj) { if (!directory) { T(YAFFS_TRACE_ALWAYS, @@ -4495,7 +4306,7 @@ void yaffs_AddObjectToDirectory(yaffs_Object *directory, YBUG(); return; } - if (directory->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { + if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { T(YAFFS_TRACE_ALWAYS, (TSTR ("tragedy: Trying to add an object to a non-directory" @@ -4508,36 +4319,34 @@ void yaffs_AddObjectToDirectory(yaffs_Object *directory, YBUG(); } + yaffs_verify_dir(directory); - yaffs_VerifyDirectory(directory); - - yaffs_RemoveObjectFromDirectory(obj); - + yaffs_remove_obj_from_dir(obj); /* Now add it */ - ylist_add(&obj->siblings, &directory->variant.directoryVariant.children); + list_add(&obj->siblings, &directory->variant.dir_variant.children); obj->parent = directory; - if (directory == obj->myDev->unlinkedDir - || directory == obj->myDev->deletedDir) { + if (directory == obj->my_dev->unlinked_dir + || directory == obj->my_dev->del_dir) { obj->unlinked = 1; - obj->myDev->nUnlinkedFiles++; - obj->renameAllowed = 0; + obj->my_dev->n_unlinked_files++; + obj->rename_allowed = 0; } - yaffs_VerifyDirectory(directory); - yaffs_VerifyObjectInDirectory(obj); + yaffs_verify_dir(directory); + yaffs_verify_obj_in_dir(obj); } -yaffs_Object *yaffs_FindObjectByName(yaffs_Object *directory, - const YCHAR *name) +struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory, + const YCHAR * name) { int sum; - struct ylist_head *i; + struct list_head *i; YCHAR buffer[YAFFS_MAX_NAME_LENGTH + 1]; - yaffs_Object *l; + struct yaffs_obj *l; if (!name) return NULL; @@ -4545,40 +4354,42 @@ yaffs_Object *yaffs_FindObjectByName(yaffs_Object *directory, if (!directory) { T(YAFFS_TRACE_ALWAYS, (TSTR - ("tragedy: yaffs_FindObjectByName: null pointer directory" + ("tragedy: yaffs_find_by_name: null pointer directory" TENDSTR))); YBUG(); return NULL; } - if (directory->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { + if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { T(YAFFS_TRACE_ALWAYS, - (TSTR - ("tragedy: yaffs_FindObjectByName: non-directory" TENDSTR))); + (TSTR("tragedy: yaffs_find_by_name: non-directory" TENDSTR))); YBUG(); } - sum = yaffs_CalcNameSum(name); + sum = yaffs_calc_name_sum(name); - ylist_for_each(i, &directory->variant.directoryVariant.children) { + list_for_each(i, &directory->variant.dir_variant.children) { if (i) { - l = ylist_entry(i, yaffs_Object, siblings); + l = list_entry(i, struct yaffs_obj, siblings); if (l->parent != directory) YBUG(); - yaffs_CheckObjectDetailsLoaded(l); + yaffs_check_obj_details_loaded(l); /* Special case for lost-n-found */ - if (l->objectId == YAFFS_OBJECTID_LOSTNFOUND) { - if (yaffs_strcmp(name, YAFFS_LOSTNFOUND_NAME) == 0) + if (l->obj_id == YAFFS_OBJECTID_LOSTNFOUND) { + if (yaffs_strcmp(name, YAFFS_LOSTNFOUND_NAME) == + 0) return l; - } else if (yaffs_SumCompare(l->sum, sum) || l->hdrChunk <= 0) { + } else if (yaffs_sum_cmp(l->sum, sum) + || l->hdr_chunk <= 0) { /* LostnFound chunk called Objxxx * Do a real check */ - yaffs_GetObjectName(l, buffer, - YAFFS_MAX_NAME_LENGTH + 1); - if (yaffs_strncmp(name, buffer, YAFFS_MAX_NAME_LENGTH) == 0) + yaffs_get_obj_name(l, buffer, + YAFFS_MAX_NAME_LENGTH + 1); + if (yaffs_strncmp + (name, buffer, YAFFS_MAX_NAME_LENGTH) == 0) return l; } } @@ -4587,53 +4398,16 @@ yaffs_Object *yaffs_FindObjectByName(yaffs_Object *directory, return NULL; } - -#if 0 -int yaffs_ApplyToDirectoryChildren(yaffs_Object *theDir, - int (*fn) (yaffs_Object *)) -{ - struct ylist_head *i; - yaffs_Object *l; - - if (!theDir) { - T(YAFFS_TRACE_ALWAYS, - (TSTR - ("tragedy: yaffs_FindObjectByName: null pointer directory" - TENDSTR))); - YBUG(); - return YAFFS_FAIL; - } - if (theDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { - T(YAFFS_TRACE_ALWAYS, - (TSTR - ("tragedy: yaffs_FindObjectByName: non-directory" TENDSTR))); - YBUG(); - return YAFFS_FAIL; - } - - ylist_for_each(i, &theDir->variant.directoryVariant.children) { - if (i) { - l = ylist_entry(i, yaffs_Object, siblings); - if (l && !fn(l)) - return YAFFS_FAIL; - } - } - - return YAFFS_OK; - -} -#endif - /* GetEquivalentObject dereferences any hard links to get to the * actual object. */ -yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object *obj) +struct yaffs_obj *yaffs_get_equivalent_obj(struct yaffs_obj *obj) { - if (obj && obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) { + if (obj && obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) { /* We want the object id of the equivalent object, not this one */ - obj = obj->variant.hardLinkVariant.equivalentObject; - yaffs_CheckObjectDetailsLoaded(obj); + obj = obj->variant.hardlink_variant.equiv_obj; + yaffs_check_obj_details_loaded(obj); } return obj; } @@ -4657,171 +4431,174 @@ yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object *obj) * starting at oh->name[1]. */ -static void yaffs_FixNullName(yaffs_Object * obj,YCHAR * name, int buffSize) +static void yaffs_fix_null_name(struct yaffs_obj *obj, YCHAR * name, + int buffer_size) { /* Create an object name if we could not find one. */ - if(yaffs_strnlen(name,YAFFS_MAX_NAME_LENGTH) == 0){ - YCHAR locName[20]; - YCHAR numString[20]; - YCHAR *x = &numString[19]; - unsigned v = obj->objectId; - numString[19] = 0; - while(v>0){ + if (yaffs_strnlen(name, YAFFS_MAX_NAME_LENGTH) == 0) { + YCHAR local_name[20]; + YCHAR num_string[20]; + YCHAR *x = &num_string[19]; + unsigned v = obj->obj_id; + num_string[19] = 0; + while (v > 0) { x--; *x = '0' + (v % 10); v /= 10; } /* make up a name */ - yaffs_strcpy(locName, YAFFS_LOSTNFOUND_PREFIX); - yaffs_strcat(locName,x); - yaffs_strncpy(name, locName, buffSize - 1); + yaffs_strcpy(local_name, YAFFS_LOSTNFOUND_PREFIX); + yaffs_strcat(local_name, x); + yaffs_strncpy(name, local_name, buffer_size - 1); } } -static void yaffs_LoadNameFromObjectHeader(yaffs_Device *dev,YCHAR *name, const YCHAR *ohName, int bufferSize) +static void yaffs_load_name_from_oh(struct yaffs_dev *dev, YCHAR * name, + const YCHAR * oh_name, int buff_size) { #ifdef CONFIG_YAFFS_AUTO_UNICODE - if(dev->param.autoUnicode){ - if(*ohName){ + if (dev->param.auto_unicode) { + if (*oh_name) { /* It is an ASCII name, so do an ASCII to unicode conversion */ - const char *asciiOhName = (const char *)ohName; - int n = bufferSize - 1; - while(n > 0 && *asciiOhName){ - *name = *asciiOhName; + const char *ascii_oh_name = (const char *)oh_name; + int n = buff_size - 1; + while (n > 0 && *ascii_oh_name) { + *name = *ascii_oh_name; name++; - asciiOhName++; + ascii_oh_name++; n--; } - } else - yaffs_strncpy(name,ohName+1, bufferSize -1); + } else + yaffs_strncpy(name, oh_name + 1, buff_size - 1); } else #endif - yaffs_strncpy(name, ohName, bufferSize - 1); + yaffs_strncpy(name, oh_name, buff_size - 1); } - -static void yaffs_LoadObjectHeaderFromName(yaffs_Device *dev, YCHAR *ohName, const YCHAR *name) +static void yaffs_load_oh_from_name(struct yaffs_dev *dev, YCHAR * oh_name, + const YCHAR * name) { #ifdef CONFIG_YAFFS_AUTO_UNICODE - int isAscii; + int is_ascii; YCHAR *w; - if(dev->param.autoUnicode){ + if (dev->param.auto_unicode) { - isAscii = 1; + is_ascii = 1; w = name; - + /* Figure out if the name will fit in ascii character set */ - while(isAscii && *w){ - if((*w) & 0xff00) - isAscii = 0; + while (is_ascii && *w) { + if ((*w) & 0xff00) + is_ascii = 0; w++; } - if(isAscii){ + if (is_ascii) { /* It is an ASCII name, so do a unicode to ascii conversion */ - char *asciiOhName = (char *)ohName; - int n = YAFFS_MAX_NAME_LENGTH - 1; - while(n > 0 && *name){ - *asciiOhName= *name; + char *ascii_oh_name = (char *)oh_name; + int n = YAFFS_MAX_NAME_LENGTH - 1; + while (n > 0 && *name) { + *ascii_oh_name = *name; name++; - asciiOhName++; + ascii_oh_name++; n--; } - } else{ + } else { /* It is a unicode name, so save starting at the second YCHAR */ - *ohName = 0; - yaffs_strncpy(ohName+1,name, YAFFS_MAX_NAME_LENGTH -2); + *oh_name = 0; + yaffs_strncpy(oh_name + 1, name, + YAFFS_MAX_NAME_LENGTH - 2); } - } - else + } else #endif - yaffs_strncpy(ohName,name, YAFFS_MAX_NAME_LENGTH - 1); + yaffs_strncpy(oh_name, name, YAFFS_MAX_NAME_LENGTH - 1); } -int yaffs_GetObjectName(yaffs_Object * obj, YCHAR * name, int buffSize) +int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR * name, int buffer_size) { - memset(name, 0, buffSize * sizeof(YCHAR)); - - yaffs_CheckObjectDetailsLoaded(obj); + memset(name, 0, buffer_size * sizeof(YCHAR)); - if (obj->objectId == YAFFS_OBJECTID_LOSTNFOUND) { - yaffs_strncpy(name, YAFFS_LOSTNFOUND_NAME, buffSize - 1); - } + yaffs_check_obj_details_loaded(obj); + + if (obj->obj_id == YAFFS_OBJECTID_LOSTNFOUND) { + yaffs_strncpy(name, YAFFS_LOSTNFOUND_NAME, buffer_size - 1); + } #ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM - else if (obj->shortName[0]) { - yaffs_strcpy(name, obj->shortName); + else if (obj->short_name[0]) { + yaffs_strcpy(name, obj->short_name); } #endif - else if(obj->hdrChunk > 0) { + else if (obj->hdr_chunk > 0) { int result; - __u8 *buffer = yaffs_GetTempBuffer(obj->myDev, __LINE__); + u8 *buffer = yaffs_get_temp_buffer(obj->my_dev, __LINE__); - yaffs_ObjectHeader *oh = (yaffs_ObjectHeader *) buffer; + struct yaffs_obj_hdr *oh = (struct yaffs_obj_hdr *)buffer; - memset(buffer, 0, obj->myDev->nDataBytesPerChunk); + memset(buffer, 0, obj->my_dev->data_bytes_per_chunk); - if (obj->hdrChunk > 0) { - result = yaffs_ReadChunkWithTagsFromNAND(obj->myDev, - obj->hdrChunk, buffer, - NULL); + if (obj->hdr_chunk > 0) { + result = yaffs_rd_chunk_tags_nand(obj->my_dev, + obj->hdr_chunk, + buffer, NULL); } - yaffs_LoadNameFromObjectHeader(obj->myDev,name,oh->name,buffSize); + yaffs_load_name_from_oh(obj->my_dev, name, oh->name, + buffer_size); - yaffs_ReleaseTempBuffer(obj->myDev, buffer, __LINE__); + yaffs_release_temp_buffer(obj->my_dev, buffer, __LINE__); } - yaffs_FixNullName(obj,name,buffSize); + yaffs_fix_null_name(obj, name, buffer_size); - return yaffs_strnlen(name,YAFFS_MAX_NAME_LENGTH); + return yaffs_strnlen(name, YAFFS_MAX_NAME_LENGTH); } - -int yaffs_GetObjectFileLength(yaffs_Object *obj) +int yaffs_get_obj_length(struct yaffs_obj *obj) { /* Dereference any hard linking */ - obj = yaffs_GetEquivalentObject(obj); + obj = yaffs_get_equivalent_obj(obj); - if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) - return obj->variant.fileVariant.fileSize; - if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK){ - if(!obj->variant.symLinkVariant.alias) + if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) + return obj->variant.file_variant.file_size; + if (obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) { + if (!obj->variant.symlink_variant.alias) return 0; - return yaffs_strnlen(obj->variant.symLinkVariant.alias,YAFFS_MAX_ALIAS_LENGTH); + return yaffs_strnlen(obj->variant.symlink_variant.alias, + YAFFS_MAX_ALIAS_LENGTH); } else { /* Only a directory should drop through to here */ - return obj->myDev->nDataBytesPerChunk; + return obj->my_dev->data_bytes_per_chunk; } } -int yaffs_GetObjectLinkCount(yaffs_Object *obj) +int yaffs_get_obj_link_count(struct yaffs_obj *obj) { int count = 0; - struct ylist_head *i; + struct list_head *i; if (!obj->unlinked) - count++; /* the object itself */ + count++; /* the object itself */ - ylist_for_each(i, &obj->hardLinks) - count++; /* add the hard links; */ + list_for_each(i, &obj->hard_links) + count++; /* add the hard links; */ return count; } -int yaffs_GetObjectInode(yaffs_Object *obj) +int yaffs_get_obj_inode(struct yaffs_obj *obj) { - obj = yaffs_GetEquivalentObject(obj); + obj = yaffs_get_equivalent_obj(obj); - return obj->objectId; + return obj->obj_id; } -unsigned yaffs_GetObjectType(yaffs_Object *obj) +unsigned yaffs_get_obj_type(struct yaffs_obj *obj) { - obj = yaffs_GetEquivalentObject(obj); + obj = yaffs_get_equivalent_obj(obj); - switch (obj->variantType) { + switch (obj->variant_type) { case YAFFS_OBJECT_TYPE_FILE: return DT_REG; break; @@ -4849,277 +4626,207 @@ unsigned yaffs_GetObjectType(yaffs_Object *obj) } } -YCHAR *yaffs_GetSymlinkAlias(yaffs_Object *obj) +YCHAR *yaffs_get_symlink_alias(struct yaffs_obj *obj) { - obj = yaffs_GetEquivalentObject(obj); - if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK) - return yaffs_CloneString(obj->variant.symLinkVariant.alias); + obj = yaffs_get_equivalent_obj(obj); + if (obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) + return yaffs_clone_str(obj->variant.symlink_variant.alias); else - return yaffs_CloneString(_Y("")); + return yaffs_clone_str(_Y("")); } -#ifndef CONFIG_YAFFS_WINCE - -int yaffs_SetAttributes(yaffs_Object *obj, struct iattr *attr) +static int yaffs_do_xattrib_mod(struct yaffs_obj *obj, int set, + const YCHAR * name, const void *value, int size, + int flags) { - unsigned int valid = attr->ia_valid; - - if (valid & ATTR_MODE) - obj->yst_mode = attr->ia_mode; - if (valid & ATTR_UID) - obj->yst_uid = attr->ia_uid; - if (valid & ATTR_GID) - obj->yst_gid = attr->ia_gid; - - if (valid & ATTR_ATIME) - obj->yst_atime = Y_TIME_CONVERT(attr->ia_atime); - if (valid & ATTR_CTIME) - obj->yst_ctime = Y_TIME_CONVERT(attr->ia_ctime); - if (valid & ATTR_MTIME) - obj->yst_mtime = Y_TIME_CONVERT(attr->ia_mtime); - - if (valid & ATTR_SIZE) - yaffs_ResizeFile(obj, attr->ia_size); - - yaffs_UpdateObjectHeader(obj, NULL, 1, 0, 0, NULL); - - return YAFFS_OK; - -} -int yaffs_GetAttributes(yaffs_Object *obj, struct iattr *attr) -{ - unsigned int valid = 0; - - attr->ia_mode = obj->yst_mode; - valid |= ATTR_MODE; - attr->ia_uid = obj->yst_uid; - valid |= ATTR_UID; - attr->ia_gid = obj->yst_gid; - valid |= ATTR_GID; - - Y_TIME_CONVERT(attr->ia_atime) = obj->yst_atime; - valid |= ATTR_ATIME; - Y_TIME_CONVERT(attr->ia_ctime) = obj->yst_ctime; - valid |= ATTR_CTIME; - Y_TIME_CONVERT(attr->ia_mtime) = obj->yst_mtime; - valid |= ATTR_MTIME; - - attr->ia_size = yaffs_GetFileSize(obj); - valid |= ATTR_SIZE; - - attr->ia_valid = valid; - - return YAFFS_OK; -} - -#endif - - -static int yaffs_DoXMod(yaffs_Object *obj, int set, const YCHAR *name, const void *value, int size, int flags) -{ - yaffs_XAttrMod xmod; + struct yaffs_xattr_mod xmod; int result; xmod.set = set; xmod.name = name; xmod.data = value; - xmod.size = size; + xmod.size = size; xmod.flags = flags; xmod.result = -ENOSPC; - result = yaffs_UpdateObjectHeader(obj, NULL, 0, 0, 0, &xmod); + result = yaffs_update_oh(obj, NULL, 0, 0, 0, &xmod); - if(result > 0) + if (result > 0) return xmod.result; else return -ENOSPC; } -static int yaffs_ApplyXMod(yaffs_Object *obj, char *buffer, yaffs_XAttrMod *xmod) +static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer, + struct yaffs_xattr_mod *xmod) { int retval = 0; - int x_offs = sizeof(yaffs_ObjectHeader); - yaffs_Device *dev = obj->myDev; - int x_size = dev->nDataBytesPerChunk - sizeof(yaffs_ObjectHeader); + int x_offs = sizeof(struct yaffs_obj_hdr); + struct yaffs_dev *dev = obj->my_dev; + int x_size = dev->data_bytes_per_chunk - sizeof(struct yaffs_obj_hdr); - char * x_buffer = buffer + x_offs; + char *x_buffer = buffer + x_offs; - if(xmod->set) - retval = nval_set(x_buffer, x_size, xmod->name, xmod->data, xmod->size, xmod->flags); + if (xmod->set) + retval = + nval_set(x_buffer, x_size, xmod->name, xmod->data, + xmod->size, xmod->flags); else retval = nval_del(x_buffer, x_size, xmod->name); - obj->hasXattr = nval_hasvalues(x_buffer, x_size); - obj->xattrKnown = 1; + obj->has_xattr = nval_hasvalues(x_buffer, x_size); + obj->xattr_known = 1; xmod->result = retval; return retval; } -static int yaffs_DoXFetch(yaffs_Object *obj, const YCHAR *name, void *value, int size) +static int yaffs_do_xattrib_fetch(struct yaffs_obj *obj, const YCHAR * name, + void *value, int size) { char *buffer = NULL; int result; - yaffs_ExtendedTags tags; - yaffs_Device *dev = obj->myDev; - int x_offs = sizeof(yaffs_ObjectHeader); - int x_size = dev->nDataBytesPerChunk - sizeof(yaffs_ObjectHeader); + struct yaffs_ext_tags tags; + struct yaffs_dev *dev = obj->my_dev; + int x_offs = sizeof(struct yaffs_obj_hdr); + int x_size = dev->data_bytes_per_chunk - sizeof(struct yaffs_obj_hdr); - char * x_buffer; + char *x_buffer; int retval = 0; - if(obj->hdrChunk < 1) + if (obj->hdr_chunk < 1) return -ENODATA; /* If we know that the object has no xattribs then don't do all the * reading and parsing. */ - if(obj->xattrKnown && !obj->hasXattr){ - if(name) + if (obj->xattr_known && !obj->has_xattr) { + if (name) return -ENODATA; else return 0; } - buffer = (char *) yaffs_GetTempBuffer(dev, __LINE__); - if(!buffer) + buffer = (char *)yaffs_get_temp_buffer(dev, __LINE__); + if (!buffer) return -ENOMEM; - result = yaffs_ReadChunkWithTagsFromNAND(dev,obj->hdrChunk, (__u8 *)buffer, &tags); + result = + yaffs_rd_chunk_tags_nand(dev, obj->hdr_chunk, (u8 *) buffer, &tags); - if(result != YAFFS_OK) + if (result != YAFFS_OK) retval = -ENOENT; - else{ - x_buffer = buffer + x_offs; + else { + x_buffer = buffer + x_offs; - if (!obj->xattrKnown){ - obj->hasXattr = nval_hasvalues(x_buffer, x_size); - obj->xattrKnown = 1; + if (!obj->xattr_known) { + obj->has_xattr = nval_hasvalues(x_buffer, x_size); + obj->xattr_known = 1; } - if(name) + if (name) retval = nval_get(x_buffer, x_size, name, value, size); else - retval = nval_list(x_buffer, x_size, value,size); + retval = nval_list(x_buffer, x_size, value, size); } - yaffs_ReleaseTempBuffer(dev,(__u8 *)buffer,__LINE__); + yaffs_release_temp_buffer(dev, (u8 *) buffer, __LINE__); return retval; } -int yaffs_SetXAttribute(yaffs_Object *obj, const YCHAR *name, const void * value, int size, int flags) +int yaffs_set_xattrib(struct yaffs_obj *obj, const YCHAR * name, + const void *value, int size, int flags) { - return yaffs_DoXMod(obj, 1, name, value, size, flags); + return yaffs_do_xattrib_mod(obj, 1, name, value, size, flags); } -int yaffs_RemoveXAttribute(yaffs_Object *obj, const YCHAR *name) +int yaffs_remove_xattrib(struct yaffs_obj *obj, const YCHAR * name) { - return yaffs_DoXMod(obj, 0, name, NULL, 0, 0); + return yaffs_do_xattrib_mod(obj, 0, name, NULL, 0, 0); } -int yaffs_GetXAttribute(yaffs_Object *obj, const YCHAR *name, void *value, int size) +int yaffs_get_xattrib(struct yaffs_obj *obj, const YCHAR * name, void *value, + int size) { - return yaffs_DoXFetch(obj, name, value, size); + return yaffs_do_xattrib_fetch(obj, name, value, size); } -int yaffs_ListXAttributes(yaffs_Object *obj, char *buffer, int size) +int yaffs_list_xattrib(struct yaffs_obj *obj, char *buffer, int size) { - return yaffs_DoXFetch(obj, NULL, buffer,size); + return yaffs_do_xattrib_fetch(obj, NULL, buffer, size); } - - -#if 0 -int yaffs_DumpObject(yaffs_Object *obj) -{ - YCHAR name[257]; - - yaffs_GetObjectName(obj, name, YAFFS_MAX_NAME_LENGTH + 1); - - T(YAFFS_TRACE_ALWAYS, - (TSTR - ("Object %d, inode %d \"%s\"\n dirty %d valid %d serial %d sum %d" - " chunk %d type %d size %d\n" - TENDSTR), obj->objectId, yaffs_GetObjectInode(obj), name, - obj->dirty, obj->valid, obj->serial, obj->sum, obj->hdrChunk, - yaffs_GetObjectType(obj), yaffs_GetObjectFileLength(obj))); - - return YAFFS_OK; -} -#endif - /*---------------------------- Initialisation code -------------------------------------- */ -static int yaffs_CheckDevFunctions(const yaffs_Device *dev) +static int yaffs_check_dev_fns(const struct yaffs_dev *dev) { /* Common functions, gotta have */ - if (!dev->param.eraseBlockInNAND || !dev->param.initialiseNAND) + if (!dev->param.erase_fn || !dev->param.initialise_flash_fn) return 0; #ifdef CONFIG_YAFFS_YAFFS2 /* Can use the "with tags" style interface for yaffs1 or yaffs2 */ - if (dev->param.writeChunkWithTagsToNAND && - dev->param.readChunkWithTagsFromNAND && - !dev->param.writeChunkToNAND && - !dev->param.readChunkFromNAND && - dev->param.markNANDBlockBad && - dev->param.queryNANDBlock) + if (dev->param.write_chunk_tags_fn && + dev->param.read_chunk_tags_fn && + !dev->param.write_chunk_fn && + !dev->param.read_chunk_fn && + dev->param.bad_block_fn && dev->param.query_block_fn) return 1; #endif /* Can use the "spare" style interface for yaffs1 */ - if (!dev->param.isYaffs2 && - !dev->param.writeChunkWithTagsToNAND && - !dev->param.readChunkWithTagsFromNAND && - dev->param.writeChunkToNAND && - dev->param.readChunkFromNAND && - !dev->param.markNANDBlockBad && - !dev->param.queryNANDBlock) + if (!dev->param.is_yaffs2 && + !dev->param.write_chunk_tags_fn && + !dev->param.read_chunk_tags_fn && + dev->param.write_chunk_fn && + dev->param.read_chunk_fn && + !dev->param.bad_block_fn && !dev->param.query_block_fn) return 1; - return 0; /* bad */ + return 0; /* bad */ } - -static int yaffs_CreateInitialDirectories(yaffs_Device *dev) +static int yaffs_create_initial_dir(struct yaffs_dev *dev) { /* Initialise the unlinked, deleted, root and lost and found directories */ - dev->lostNFoundDir = dev->rootDir = NULL; - dev->unlinkedDir = dev->deletedDir = NULL; + dev->lost_n_found = dev->root_dir = NULL; + dev->unlinked_dir = dev->del_dir = NULL; - dev->unlinkedDir = - yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_UNLINKED, S_IFDIR); + dev->unlinked_dir = + yaffs_create_fake_dir(dev, YAFFS_OBJECTID_UNLINKED, S_IFDIR); - dev->deletedDir = - yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_DELETED, S_IFDIR); + dev->del_dir = + yaffs_create_fake_dir(dev, YAFFS_OBJECTID_DELETED, S_IFDIR); - dev->rootDir = - yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_ROOT, - YAFFS_ROOT_MODE | S_IFDIR); - dev->lostNFoundDir = - yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_LOSTNFOUND, - YAFFS_LOSTNFOUND_MODE | S_IFDIR); + dev->root_dir = + yaffs_create_fake_dir(dev, YAFFS_OBJECTID_ROOT, + YAFFS_ROOT_MODE | S_IFDIR); + dev->lost_n_found = + yaffs_create_fake_dir(dev, YAFFS_OBJECTID_LOSTNFOUND, + YAFFS_LOSTNFOUND_MODE | S_IFDIR); - if (dev->lostNFoundDir && dev->rootDir && dev->unlinkedDir && dev->deletedDir) { - yaffs_AddObjectToDirectory(dev->rootDir, dev->lostNFoundDir); + if (dev->lost_n_found && dev->root_dir && dev->unlinked_dir + && dev->del_dir) { + yaffs_add_obj_to_dir(dev->root_dir, dev->lost_n_found); return YAFFS_OK; } return YAFFS_FAIL; } -int yaffs_GutsInitialise(yaffs_Device *dev) +int yaffs_guts_initialise(struct yaffs_dev *dev) { int init_failed = 0; unsigned x; int bits; - T(YAFFS_TRACE_TRACING, (TSTR("yaffs: yaffs_GutsInitialise()" TENDSTR))); + T(YAFFS_TRACE_TRACING, + (TSTR("yaffs: yaffs_guts_initialise()" TENDSTR))); /* Check stuff that must be set */ @@ -5128,52 +4835,48 @@ int yaffs_GutsInitialise(yaffs_Device *dev) return YAFFS_FAIL; } - dev->internalStartBlock = dev->param.startBlock; - dev->internalEndBlock = dev->param.endBlock; - dev->blockOffset = 0; - dev->chunkOffset = 0; - dev->nFreeChunks = 0; + dev->internal_start_block = dev->param.start_block; + dev->internal_end_block = dev->param.end_block; + dev->block_offset = 0; + dev->chunk_offset = 0; + dev->n_free_chunks = 0; - dev->gcBlock = 0; + dev->gc_block = 0; - if (dev->param.startBlock == 0) { - dev->internalStartBlock = dev->param.startBlock + 1; - dev->internalEndBlock = dev->param.endBlock + 1; - dev->blockOffset = 1; - dev->chunkOffset = dev->param.nChunksPerBlock; + if (dev->param.start_block == 0) { + dev->internal_start_block = dev->param.start_block + 1; + dev->internal_end_block = dev->param.end_block + 1; + dev->block_offset = 1; + dev->chunk_offset = dev->param.chunks_per_block; } /* Check geometry parameters. */ - if ((!dev->param.inbandTags && dev->param.isYaffs2 && dev->param.totalBytesPerChunk < 1024) || - (!dev->param.isYaffs2 && dev->param.totalBytesPerChunk < 512) || - (dev->param.inbandTags && !dev->param.isYaffs2) || - dev->param.nChunksPerBlock < 2 || - dev->param.nReservedBlocks < 2 || - dev->internalStartBlock <= 0 || - dev->internalEndBlock <= 0 || - dev->internalEndBlock <= (dev->internalStartBlock + dev->param.nReservedBlocks + 2)) { /* otherwise it is too small */ + if ((!dev->param.inband_tags && dev->param.is_yaffs2 && dev->param.total_bytes_per_chunk < 1024) || (!dev->param.is_yaffs2 && dev->param.total_bytes_per_chunk < 512) || (dev->param.inband_tags && !dev->param.is_yaffs2) || dev->param.chunks_per_block < 2 || dev->param.n_reserved_blocks < 2 || dev->internal_start_block <= 0 || dev->internal_end_block <= 0 || dev->internal_end_block <= (dev->internal_start_block + dev->param.n_reserved_blocks + 2)) { /* otherwise it is too small */ T(YAFFS_TRACE_ALWAYS, (TSTR - ("yaffs: NAND geometry problems: chunk size %d, type is yaffs%s, inbandTags %d " - TENDSTR), dev->param.totalBytesPerChunk, dev->param.isYaffs2 ? "2" : "", dev->param.inbandTags)); + ("yaffs: NAND geometry problems: chunk size %d, type is yaffs%s, inband_tags %d " + TENDSTR), dev->param.total_bytes_per_chunk, + dev->param.is_yaffs2 ? "2" : "", dev->param.inband_tags)); return YAFFS_FAIL; } - if (yaffs_InitialiseNAND(dev) != YAFFS_OK) { + if (yaffs_init_nand(dev) != YAFFS_OK) { T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: InitialiseNAND failed" TENDSTR))); return YAFFS_FAIL; } /* Sort out space for inband tags, if required */ - if (dev->param.inbandTags) - dev->nDataBytesPerChunk = dev->param.totalBytesPerChunk - sizeof(yaffs_PackedTags2TagsPart); + if (dev->param.inband_tags) + dev->data_bytes_per_chunk = + dev->param.total_bytes_per_chunk - + sizeof(struct yaffs_packed_tags2_tags_only); else - dev->nDataBytesPerChunk = dev->param.totalBytesPerChunk; + dev->data_bytes_per_chunk = dev->param.total_bytes_per_chunk; /* Got the right mix of functions? */ - if (!yaffs_CheckDevFunctions(dev)) { + if (!yaffs_check_dev_fns(dev)) { /* Function missing */ T(YAFFS_TRACE_ALWAYS, (TSTR @@ -5182,14 +4885,7 @@ int yaffs_GutsInitialise(yaffs_Device *dev) return YAFFS_FAIL; } - /* This is really a compilation check. */ - if (!yaffs_CheckStructures()) { - T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs_CheckStructures failed\n" TENDSTR))); - return YAFFS_FAIL; - } - - if (dev->isMounted) { + if (dev->is_mounted) { T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: device already mounted\n" TENDSTR))); return YAFFS_FAIL; @@ -5197,62 +4893,62 @@ int yaffs_GutsInitialise(yaffs_Device *dev) /* Finished with most checks. One or two more checks happen later on too. */ - dev->isMounted = 1; + dev->is_mounted = 1; /* OK now calculate a few things for the device */ /* * Calculate all the chunk size manipulation numbers: */ - x = dev->nDataBytesPerChunk; - /* We always use dev->chunkShift and dev->chunkDiv */ - dev->chunkShift = Shifts(x); - x >>= dev->chunkShift; - dev->chunkDiv = x; - /* We only use chunk mask if chunkDiv is 1 */ - dev->chunkMask = (1<chunkShift) - 1; + x = dev->data_bytes_per_chunk; + /* We always use dev->chunk_shift and dev->chunk_div */ + dev->chunk_shift = calc_shifts(x); + x >>= dev->chunk_shift; + dev->chunk_div = x; + /* We only use chunk mask if chunk_div is 1 */ + dev->chunk_mask = (1 << dev->chunk_shift) - 1; /* - * Calculate chunkGroupBits. - * We need to find the next power of 2 > than internalEndBlock + * Calculate chunk_grp_bits. + * We need to find the next power of 2 > than internal_end_block */ - x = dev->param.nChunksPerBlock * (dev->internalEndBlock + 1); + x = dev->param.chunks_per_block * (dev->internal_end_block + 1); - bits = ShiftsGE(x); + bits = calc_shifts_ceiling(x); /* Set up tnode width if wide tnodes are enabled. */ - if (!dev->param.wideTnodesDisabled) { + if (!dev->param.wide_tnodes_disabled) { /* bits must be even so that we end up with 32-bit words */ if (bits & 1) bits++; if (bits < 16) - dev->tnodeWidth = 16; + dev->tnode_width = 16; else - dev->tnodeWidth = bits; + dev->tnode_width = bits; } else - dev->tnodeWidth = 16; + dev->tnode_width = 16; - dev->tnodeMask = (1<tnodeWidth)-1; + dev->tnode_mask = (1 << dev->tnode_width) - 1; /* Level0 Tnodes are 16 bits or wider (if wide tnodes are enabled), * so if the bitwidth of the * chunk range we're using is greater than 16 we need - * to figure out chunk shift and chunkGroupSize + * to figure out chunk shift and chunk_grp_size */ - if (bits <= dev->tnodeWidth) - dev->chunkGroupBits = 0; + if (bits <= dev->tnode_width) + dev->chunk_grp_bits = 0; else - dev->chunkGroupBits = bits - dev->tnodeWidth; + dev->chunk_grp_bits = bits - dev->tnode_width; - dev->tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8; - if(dev->tnodeSize < sizeof(yaffs_Tnode)) - dev->tnodeSize = sizeof(yaffs_Tnode); + dev->tnode_size = (dev->tnode_width * YAFFS_NTNODES_LEVEL0) / 8; + if (dev->tnode_size < sizeof(struct yaffs_tnode)) + dev->tnode_size = sizeof(struct yaffs_tnode); - dev->chunkGroupSize = 1 << dev->chunkGroupBits; + dev->chunk_grp_size = 1 << dev->chunk_grp_bits; - if (dev->param.nChunksPerBlock < dev->chunkGroupSize) { + if (dev->param.chunks_per_block < dev->chunk_grp_size) { /* We have a problem because the soft delete won't work if * the chunk group size > chunks per block. * This can be remedied by using larger "virtual blocks". @@ -5266,208 +4962,210 @@ int yaffs_GutsInitialise(yaffs_Device *dev) /* OK, we've finished verifying the device, lets continue with initialisation */ /* More device initialisation */ - dev->allGCs = 0; - dev->passiveGCs = 0; - dev->oldestDirtyGCs = 0; - dev->backgroundGCs = 0; - dev->gcBlockFinder = 0; - dev->bufferedBlock = -1; - dev->doingBufferedBlockRewrite = 0; - dev->nDeletedFiles = 0; - dev->nBackgroundDeletions = 0; - dev->nUnlinkedFiles = 0; - dev->eccFixed = 0; - dev->eccUnfixed = 0; - dev->tagsEccFixed = 0; - dev->tagsEccUnfixed = 0; - dev->nErasureFailures = 0; - dev->nErasedBlocks = 0; - dev->gcDisable= 0; - dev->hasPendingPrioritisedGCs = 1; /* Assume the worst for now, will get fixed on first GC */ - YINIT_LIST_HEAD(&dev->dirtyDirectories); - dev->oldestDirtySequence = 0; - dev->oldestDirtyBlock = 0; + dev->all_gcs = 0; + dev->passive_gc_count = 0; + dev->oldest_dirty_gc_count = 0; + dev->bg_gcs = 0; + dev->gc_block_finder = 0; + dev->buffered_block = -1; + dev->doing_buffered_block_rewrite = 0; + dev->n_deleted_files = 0; + dev->n_bg_deletions = 0; + dev->n_unlinked_files = 0; + dev->n_ecc_fixed = 0; + dev->n_ecc_unfixed = 0; + dev->n_tags_ecc_fixed = 0; + dev->n_tags_ecc_unfixed = 0; + dev->n_erase_failures = 0; + dev->n_erased_blocks = 0; + dev->gc_disable = 0; + dev->has_pending_prioritised_gc = 1; /* Assume the worst for now, will get fixed on first GC */ + INIT_LIST_HEAD(&dev->dirty_dirs); + dev->oldest_dirty_seq = 0; + dev->oldest_dirty_block = 0; /* Initialise temporary buffers and caches. */ - if (!yaffs_InitialiseTempBuffers(dev)) + if (!yaffs_init_tmp_buffers(dev)) init_failed = 1; - dev->srCache = NULL; - dev->gcCleanupList = NULL; + dev->cache = NULL; + dev->gc_cleanup_list = NULL; - - if (!init_failed && - dev->param.nShortOpCaches > 0) { + if (!init_failed && dev->param.n_caches > 0) { int i; void *buf; - int srCacheBytes = dev->param.nShortOpCaches * sizeof(yaffs_ChunkCache); + int cache_bytes = + dev->param.n_caches * sizeof(struct yaffs_cache); - if (dev->param.nShortOpCaches > YAFFS_MAX_SHORT_OP_CACHES) - dev->param.nShortOpCaches = YAFFS_MAX_SHORT_OP_CACHES; + if (dev->param.n_caches > YAFFS_MAX_SHORT_OP_CACHES) + dev->param.n_caches = YAFFS_MAX_SHORT_OP_CACHES; - dev->srCache = YMALLOC(srCacheBytes); + dev->cache = YMALLOC(cache_bytes); - buf = (__u8 *) dev->srCache; + buf = (u8 *) dev->cache; - if (dev->srCache) - memset(dev->srCache, 0, srCacheBytes); + if (dev->cache) + memset(dev->cache, 0, cache_bytes); - for (i = 0; i < dev->param.nShortOpCaches && buf; i++) { - dev->srCache[i].object = NULL; - dev->srCache[i].lastUse = 0; - dev->srCache[i].dirty = 0; - dev->srCache[i].data = buf = YMALLOC_DMA(dev->param.totalBytesPerChunk); + for (i = 0; i < dev->param.n_caches && buf; i++) { + dev->cache[i].object = NULL; + dev->cache[i].last_use = 0; + dev->cache[i].dirty = 0; + dev->cache[i].data = buf = + YMALLOC_DMA(dev->param.total_bytes_per_chunk); } if (!buf) init_failed = 1; - dev->srLastUse = 0; + dev->cache_last_use = 0; } - dev->cacheHits = 0; + dev->cache_hits = 0; if (!init_failed) { - dev->gcCleanupList = YMALLOC(dev->param.nChunksPerBlock * sizeof(__u32)); - if (!dev->gcCleanupList) + dev->gc_cleanup_list = + YMALLOC(dev->param.chunks_per_block * sizeof(u32)); + if (!dev->gc_cleanup_list) init_failed = 1; } - if (dev->param.isYaffs2) - dev->param.useHeaderFileSize = 1; + if (dev->param.is_yaffs2) + dev->param.use_header_file_size = 1; - if (!init_failed && !yaffs_InitialiseBlocks(dev)) + if (!init_failed && !yaffs_init_blocks(dev)) init_failed = 1; - yaffs_InitialiseTnodesAndObjects(dev); + yaffs_init_tnodes_and_objs(dev); - if (!init_failed && !yaffs_CreateInitialDirectories(dev)) + if (!init_failed && !yaffs_create_initial_dir(dev)) init_failed = 1; - if (!init_failed) { /* Now scan the flash. */ - if (dev->param.isYaffs2) { - if (yaffs2_CheckpointRestore(dev)) { - yaffs_CheckObjectDetailsLoaded(dev->rootDir); + if (dev->param.is_yaffs2) { + if (yaffs2_checkpt_restore(dev)) { + yaffs_check_obj_details_loaded(dev->root_dir); T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: restored from checkpoint" TENDSTR))); + (TSTR + ("yaffs: restored from checkpoint" + TENDSTR))); } else { /* Clean up the mess caused by an aborted checkpoint load * and scan backwards. */ - yaffs_DeinitialiseBlocks(dev); + yaffs_deinit_blocks(dev); - yaffs_DeinitialiseTnodesAndObjects(dev); + yaffs_deinit_tnodes_and_objs(dev); - dev->nErasedBlocks = 0; - dev->nFreeChunks = 0; - dev->allocationBlock = -1; - dev->allocationPage = -1; - dev->nDeletedFiles = 0; - dev->nUnlinkedFiles = 0; - dev->nBackgroundDeletions = 0; + dev->n_erased_blocks = 0; + dev->n_free_chunks = 0; + dev->alloc_block = -1; + dev->alloc_page = -1; + dev->n_deleted_files = 0; + dev->n_unlinked_files = 0; + dev->n_bg_deletions = 0; - if (!init_failed && !yaffs_InitialiseBlocks(dev)) + if (!init_failed && !yaffs_init_blocks(dev)) init_failed = 1; - yaffs_InitialiseTnodesAndObjects(dev); + yaffs_init_tnodes_and_objs(dev); - if (!init_failed && !yaffs_CreateInitialDirectories(dev)) + if (!init_failed + && !yaffs_create_initial_dir(dev)) init_failed = 1; - if (!init_failed && !yaffs2_ScanBackwards(dev)) + if (!init_failed && !yaffs2_scan_backwards(dev)) init_failed = 1; } - } else if (!yaffs1_Scan(dev)) - init_failed = 1; + } else if (!yaffs1_scan(dev)) + init_failed = 1; - yaffs_StripDeletedObjects(dev); - yaffs_FixHangingObjects(dev); - if(dev->param.emptyLostAndFound) - yaffs_EmptyLostAndFound(dev); + yaffs_strip_deleted_objs(dev); + yaffs_fix_hanging_objs(dev); + if (dev->param.empty_lost_n_found) + yaffs_empty_l_n_f(dev); } if (init_failed) { /* Clean up the mess */ T(YAFFS_TRACE_TRACING, - (TSTR("yaffs: yaffs_GutsInitialise() aborted.\n" TENDSTR))); + (TSTR("yaffs: yaffs_guts_initialise() aborted.\n" TENDSTR))); - yaffs_Deinitialise(dev); + yaffs_deinitialise(dev); return YAFFS_FAIL; } /* Zero out stats */ - dev->nPageReads = 0; - dev->nPageWrites = 0; - dev->nBlockErasures = 0; - dev->nGCCopies = 0; - dev->nRetriedWrites = 0; + dev->n_page_reads = 0; + dev->n_page_writes = 0; + dev->n_erasures = 0; + dev->n_gc_copies = 0; + dev->n_retired_writes = 0; - dev->nRetiredBlocks = 0; + dev->n_retired_blocks = 0; - yaffs_VerifyFreeChunks(dev); - yaffs_VerifyBlocks(dev); + yaffs_verify_free_chunks(dev); + yaffs_verify_blocks(dev); /* Clean up any aborted checkpoint data */ - if(!dev->isCheckpointed && dev->blocksInCheckpoint > 0) - yaffs2_InvalidateCheckpoint(dev); + if (!dev->is_checkpointed && dev->blocks_in_checkpt > 0) + yaffs2_checkpt_invalidate(dev); T(YAFFS_TRACE_TRACING, - (TSTR("yaffs: yaffs_GutsInitialise() done.\n" TENDSTR))); + (TSTR("yaffs: yaffs_guts_initialise() done.\n" TENDSTR))); return YAFFS_OK; } -void yaffs_Deinitialise(yaffs_Device *dev) +void yaffs_deinitialise(struct yaffs_dev *dev) { - if (dev->isMounted) { + if (dev->is_mounted) { int i; - yaffs_DeinitialiseBlocks(dev); - yaffs_DeinitialiseTnodesAndObjects(dev); - if (dev->param.nShortOpCaches > 0 && - dev->srCache) { + yaffs_deinit_blocks(dev); + yaffs_deinit_tnodes_and_objs(dev); + if (dev->param.n_caches > 0 && dev->cache) { - for (i = 0; i < dev->param.nShortOpCaches; i++) { - if (dev->srCache[i].data) - YFREE(dev->srCache[i].data); - dev->srCache[i].data = NULL; + for (i = 0; i < dev->param.n_caches; i++) { + if (dev->cache[i].data) + YFREE(dev->cache[i].data); + dev->cache[i].data = NULL; } - YFREE(dev->srCache); - dev->srCache = NULL; + YFREE(dev->cache); + dev->cache = NULL; } - YFREE(dev->gcCleanupList); + YFREE(dev->gc_cleanup_list); for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) - YFREE(dev->tempBuffer[i].buffer); + YFREE(dev->temp_buffer[i].buffer); - dev->isMounted = 0; + dev->is_mounted = 0; - if (dev->param.deinitialiseNAND) - dev->param.deinitialiseNAND(dev); + if (dev->param.deinitialise_flash_fn) + dev->param.deinitialise_flash_fn(dev); } } -int yaffs_CountFreeChunks(yaffs_Device *dev) +int yaffs_count_free_chunks(struct yaffs_dev *dev) { - int nFree=0; + int n_free = 0; int b; - yaffs_BlockInfo *blk; + struct yaffs_block_info *blk; - blk = dev->blockInfo; - for (b = dev->internalStartBlock; b <= dev->internalEndBlock; b++) { - switch (blk->blockState) { + blk = dev->block_info; + for (b = dev->internal_start_block; b <= dev->internal_end_block; b++) { + switch (blk->block_state) { case YAFFS_BLOCK_STATE_EMPTY: case YAFFS_BLOCK_STATE_ALLOCATING: case YAFFS_BLOCK_STATE_COLLECTING: case YAFFS_BLOCK_STATE_FULL: - nFree += - (dev->param.nChunksPerBlock - blk->pagesInUse + - blk->softDeletions); + n_free += + (dev->param.chunks_per_block - blk->pages_in_use + + blk->soft_del_pages); break; default: break; @@ -5475,70 +5173,41 @@ int yaffs_CountFreeChunks(yaffs_Device *dev) blk++; } - return nFree; + return n_free; } -int yaffs_GetNumberOfFreeChunks(yaffs_Device *dev) +int yaffs_get_n_free_chunks(struct yaffs_dev *dev) { /* This is what we report to the outside world */ - int nFree; - int nDirtyCacheChunks; - int blocksForCheckpoint; + int n_free; + int n_dirty_caches; + int blocks_for_checkpt; int i; -#if 1 - nFree = dev->nFreeChunks; -#else - nFree = yaffs_CountFreeChunks(dev); -#endif - - nFree += dev->nDeletedFiles; + n_free = dev->n_free_chunks; + n_free += dev->n_deleted_files; /* Now count the number of dirty chunks in the cache and subtract those */ - for (nDirtyCacheChunks = 0, i = 0; i < dev->param.nShortOpCaches; i++) { - if (dev->srCache[i].dirty) - nDirtyCacheChunks++; + for (n_dirty_caches = 0, i = 0; i < dev->param.n_caches; i++) { + if (dev->cache[i].dirty) + n_dirty_caches++; } - nFree -= nDirtyCacheChunks; + n_free -= n_dirty_caches; - nFree -= ((dev->param.nReservedBlocks + 1) * dev->param.nChunksPerBlock); + n_free -= + ((dev->param.n_reserved_blocks + 1) * dev->param.chunks_per_block); /* Now we figure out how much to reserve for the checkpoint and report that... */ - blocksForCheckpoint = yaffs2_CalcCheckpointBlocksRequired(dev); + blocks_for_checkpt = yaffs_calc_checkpt_blocks_required(dev); - nFree -= (blocksForCheckpoint * dev->param.nChunksPerBlock); + n_free -= (blocks_for_checkpt * dev->param.chunks_per_block); - if (nFree < 0) - nFree = 0; + if (n_free < 0) + n_free = 0; - return nFree; + return n_free; } - - -/*---------------------------------------- YAFFS test code ----------------------*/ - -#define yaffs_CheckStruct(structure, syze, name) \ - do { \ - if (sizeof(structure) != syze) { \ - T(YAFFS_TRACE_ALWAYS, (TSTR("%s should be %d but is %d\n" TENDSTR),\ - name, syze, (int) sizeof(structure))); \ - return YAFFS_FAIL; \ - } \ - } while (0) - -static int yaffs_CheckStructures(void) -{ -/* yaffs_CheckStruct(yaffs_Tags,8,"yaffs_Tags"); */ -/* yaffs_CheckStruct(yaffs_TagsUnion,8,"yaffs_TagsUnion"); */ -/* yaffs_CheckStruct(yaffs_Spare,16,"yaffs_Spare"); */ -/* yaffs_CheckStruct(yaffs_Tnode, 2 * YAFFS_NTNODES_LEVEL0, "yaffs_Tnode"); */ - -#ifndef CONFIG_YAFFS_WINCE - yaffs_CheckStruct(yaffs_ObjectHeader, 512, "yaffs_ObjectHeader"); -#endif - return YAFFS_OK; -} diff --git a/fs/yaffs2/yaffs_guts.h b/fs/yaffs2/yaffs_guts.h index 4dc70a2a..60770ca7 100644 --- a/fs/yaffs2/yaffs_guts.h +++ b/fs/yaffs2/yaffs_guts.h @@ -17,8 +17,6 @@ #define __YAFFS_GUTS_H__ #include "yportenv.h" -#include "devextras.h" -#include "yaffs_list.h" #define YAFFS_OK 1 #define YAFFS_FAIL 0 @@ -53,14 +51,12 @@ #define YAFFS_MAX_CHUNK_ID 0x000FFFFF - #define YAFFS_ALLOCATION_NOBJECTS 100 #define YAFFS_ALLOCATION_NTNODES 100 #define YAFFS_ALLOCATION_NLINKS 100 #define YAFFS_NOBJECT_BUCKETS 256 - #define YAFFS_OBJECT_SPACE 0x40000 #define YAFFS_MAX_OBJECT_ID (YAFFS_OBJECT_SPACE -1) @@ -87,7 +83,6 @@ #define YAFFS_OBJECTID_CHECKPOINT_DATA 0x20 #define YAFFS_SEQUENCE_CHECKPOINT_DATA 0x21 - #define YAFFS_MAX_SHORT_OP_CACHES 20 #define YAFFS_N_TEMP_BUFFERS 6 @@ -112,17 +107,15 @@ #define YAFFS_SEQUENCE_BAD_BLOCK 0xFFFF0000 /* ChunkCache is used for short read/write operations.*/ -typedef struct { - struct yaffs_ObjectStruct *object; - int chunkId; - int lastUse; +struct yaffs_cache { + struct yaffs_obj *object; + int chunk_id; + int last_use; int dirty; - int nBytes; /* Only valid if the cache is dirty */ + int n_bytes; /* Only valid if the cache is dirty */ int locked; /* Can't push out or flush while locked. */ - __u8 *data; -} yaffs_ChunkCache; - - + u8 *data; +}; /* Tags structures in RAM * NB This uses bitfield. Bitfields should not straddle a u32 boundary otherwise @@ -130,112 +123,112 @@ typedef struct { */ #ifndef CONFIG_YAFFS_NO_YAFFS1 -typedef struct { - unsigned chunkId:20; - unsigned serialNumber:2; - unsigned byteCountLSB:10; - unsigned objectId:18; +struct yaffs_tags { + unsigned chunk_id:20; + unsigned serial_number:2; + unsigned n_bytes_lsb:10; + unsigned obj_id:18; unsigned ecc:12; - unsigned byteCountMSB:2; -} yaffs_Tags; + unsigned n_bytes_msb:2; +}; -typedef union { - yaffs_Tags asTags; - __u8 asBytes[8]; -} yaffs_TagsUnion; +union yaffs_tags_union { + struct yaffs_tags as_tags; + u8 as_bytes[8]; +}; #endif /* Stuff used for extended tags in YAFFS2 */ -typedef enum { +enum yaffs_ecc_result { YAFFS_ECC_RESULT_UNKNOWN, YAFFS_ECC_RESULT_NO_ERROR, YAFFS_ECC_RESULT_FIXED, YAFFS_ECC_RESULT_UNFIXED -} yaffs_ECCResult; +}; -typedef enum { +enum yaffs_obj_type { YAFFS_OBJECT_TYPE_UNKNOWN, YAFFS_OBJECT_TYPE_FILE, YAFFS_OBJECT_TYPE_SYMLINK, YAFFS_OBJECT_TYPE_DIRECTORY, YAFFS_OBJECT_TYPE_HARDLINK, YAFFS_OBJECT_TYPE_SPECIAL -} yaffs_ObjectType; +}; #define YAFFS_OBJECT_TYPE_MAX YAFFS_OBJECT_TYPE_SPECIAL -typedef struct { +struct yaffs_ext_tags { - unsigned validMarker0; - unsigned chunkUsed; /* Status of the chunk: used or unused */ - unsigned objectId; /* If 0 then this is not part of an object (unused) */ - unsigned chunkId; /* If 0 then this is a header, else a data chunk */ - unsigned byteCount; /* Only valid for data chunks */ + unsigned validity0; + unsigned chunk_used; /* Status of the chunk: used or unused */ + unsigned obj_id; /* If 0 then this is not part of an object (unused) */ + unsigned chunk_id; /* If 0 then this is a header, else a data chunk */ + unsigned n_bytes; /* Only valid for data chunks */ /* The following stuff only has meaning when we read */ - yaffs_ECCResult eccResult; - unsigned blockBad; + enum yaffs_ecc_result ecc_result; + unsigned block_bad; /* YAFFS 1 stuff */ - unsigned chunkDeleted; /* The chunk is marked deleted */ - unsigned serialNumber; /* Yaffs1 2-bit serial number */ + unsigned is_deleted; /* The chunk is marked deleted */ + unsigned serial_number; /* Yaffs1 2-bit serial number */ /* YAFFS2 stuff */ - unsigned sequenceNumber; /* The sequence number of this block */ + unsigned seq_number; /* The sequence number of this block */ /* Extra info if this is an object header (YAFFS2 only) */ - unsigned extraHeaderInfoAvailable; /* There is extra info available if this is not zero */ - unsigned extraParentObjectId; /* The parent object */ - unsigned extraIsShrinkHeader; /* Is it a shrink header? */ - unsigned extraShadows; /* Does this shadow another object? */ + unsigned extra_available; /* There is extra info available if this is not zero */ + unsigned extra_parent_id; /* The parent object */ + unsigned extra_is_shrink; /* Is it a shrink header? */ + unsigned extra_shadows; /* Does this shadow another object? */ - yaffs_ObjectType extraObjectType; /* What object type? */ + enum yaffs_obj_type extra_obj_type; /* What object type? */ - unsigned extraFileLength; /* Length if it is a file */ - unsigned extraEquivalentObjectId; /* Equivalent object Id if it is a hard link */ + unsigned extra_length; /* Length if it is a file */ + unsigned extra_equiv_id; /* Equivalent object Id if it is a hard link */ - unsigned validMarker1; + unsigned validity1; -} yaffs_ExtendedTags; +}; /* Spare structure for YAFFS1 */ -typedef struct { - __u8 tagByte0; - __u8 tagByte1; - __u8 tagByte2; - __u8 tagByte3; - __u8 pageStatus; /* set to 0 to delete the chunk */ - __u8 blockStatus; - __u8 tagByte4; - __u8 tagByte5; - __u8 ecc1[3]; - __u8 tagByte6; - __u8 tagByte7; - __u8 ecc2[3]; -} yaffs_Spare; +struct yaffs_spare { + u8 tb0; + u8 tb1; + u8 tb2; + u8 tb3; + u8 page_status; /* set to 0 to delete the chunk */ + u8 block_status; + u8 tb4; + u8 tb5; + u8 ecc1[3]; + u8 tb6; + u8 tb7; + u8 ecc2[3]; +}; /*Special structure for passing through to mtd */ -struct yaffs_NANDSpare { - yaffs_Spare spare; +struct yaffs_nand_spare { + struct yaffs_spare spare; int eccres1; int eccres2; }; /* Block data in RAM */ -typedef enum { +enum yaffs_block_state { YAFFS_BLOCK_STATE_UNKNOWN = 0, YAFFS_BLOCK_STATE_SCANNING, - /* Being scanned */ + /* Being scanned */ YAFFS_BLOCK_STATE_NEEDS_SCANNING, /* The block might have something on it (ie it is allocating or full, perhaps empty) * but it needs to be scanned to determine its true state. - * This state is only valid during yaffs_Scan. + * This state is only valid during scanning. * NB We tolerate empty because the pre-scanner might be incapable of deciding * However, if this state is returned on a YAFFS2 device, then we expect a sequence number */ @@ -248,13 +241,13 @@ typedef enum { * At least one page holds valid data. * This is the one currently being used for page * allocation. Should never be more than one of these. - * If a block is only partially allocated at mount it is treated as full. + * If a block is only partially allocated at mount it is treated as full. */ YAFFS_BLOCK_STATE_FULL, /* All the pages in this block have been allocated. - * If a block was only partially allocated when mounted we treat - * it as fully allocated. + * If a block was only partially allocated when mounted we treat + * it as fully allocated. */ YAFFS_BLOCK_STATE_DIRTY, @@ -269,94 +262,81 @@ typedef enum { /* This block is being garbage collected */ YAFFS_BLOCK_STATE_DEAD - /* This block has failed and is not in use */ -} yaffs_BlockState; + /* This block has failed and is not in use */ +}; #define YAFFS_NUMBER_OF_BLOCK_STATES (YAFFS_BLOCK_STATE_DEAD + 1) +struct yaffs_block_info { -typedef struct { - - int softDeletions:10; /* number of soft deleted pages */ - int pagesInUse:10; /* number of pages in use */ - unsigned blockState:4; /* One of the above block states. NB use unsigned because enum is sometimes an int */ - __u32 needsRetiring:1; /* Data has failed on this block, need to get valid data off */ - /* and retire the block. */ - __u32 skipErasedCheck:1; /* If this is set we can skip the erased check on this block */ - __u32 gcPrioritise:1; /* An ECC check or blank check has failed on this block. + int soft_del_pages:10; /* number of soft deleted pages */ + int pages_in_use:10; /* number of pages in use */ + unsigned block_state:4; /* One of the above block states. NB use unsigned because enum is sometimes an int */ + u32 needs_retiring:1; /* Data has failed on this block, need to get valid data off */ + /* and retire the block. */ + u32 skip_erased_check:1; /* If this is set we can skip the erased check on this block */ + u32 gc_prioritise:1; /* An ECC check or blank check has failed on this block. It should be prioritised for GC */ - __u32 chunkErrorStrikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */ + u32 chunk_error_strikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */ #ifdef CONFIG_YAFFS_YAFFS2 - __u32 hasShrinkHeader:1; /* This block has at least one shrink object header */ - __u32 sequenceNumber; /* block sequence number for yaffs2 */ + u32 has_shrink_hdr:1; /* This block has at least one shrink object header */ + u32 seq_number; /* block sequence number for yaffs2 */ #endif -} yaffs_BlockInfo; +}; /* -------------------------- Object structure -------------------------------*/ /* This is the object structure as stored on NAND */ -typedef struct { - yaffs_ObjectType type; +struct yaffs_obj_hdr { + enum yaffs_obj_type type; /* Apply to everything */ - int parentObjectId; - __u16 sum__NoLongerUsed; /* checksum of name. No longer used */ + int parent_obj_id; + u16 sum_no_longer_used; /* checksum of name. No longer used */ YCHAR name[YAFFS_MAX_NAME_LENGTH + 1]; /* The following apply to directories, files, symlinks - not hard links */ - __u32 yst_mode; /* protection */ + u32 yst_mode; /* protection */ -#ifdef CONFIG_YAFFS_WINCE - __u32 notForWinCE[5]; -#else - __u32 yst_uid; - __u32 yst_gid; - __u32 yst_atime; - __u32 yst_mtime; - __u32 yst_ctime; -#endif + u32 yst_uid; + u32 yst_gid; + u32 yst_atime; + u32 yst_mtime; + u32 yst_ctime; /* File size applies to files only */ - int fileSize; + int file_size; /* Equivalent object id applies to hard links only. */ - int equivalentObjectId; + int equiv_id; /* Alias is for symlinks only. */ YCHAR alias[YAFFS_MAX_ALIAS_LENGTH + 1]; - __u32 yst_rdev; /* device stuff for block and char devices (major/min) */ + u32 yst_rdev; /* device stuff for block and char devices (major/min) */ -#ifdef CONFIG_YAFFS_WINCE - __u32 win_ctime[2]; - __u32 win_atime[2]; - __u32 win_mtime[2]; -#else - __u32 roomToGrow[6]; + u32 win_ctime[2]; + u32 win_atime[2]; + u32 win_mtime[2]; -#endif - __u32 inbandShadowsObject; - __u32 inbandIsShrink; + u32 inband_shadowed_obj_id; + u32 inband_is_shrink; - __u32 reservedSpace[2]; - int shadowsObject; /* This object header shadows the specified object if > 0 */ + u32 reserved[2]; + int shadows_obj; /* This object header shadows the specified object if > 0 */ - /* isShrink applies to object headers written when we shrink the file (ie resize) */ - __u32 isShrink; - -} yaffs_ObjectHeader; - -/*--------------------------- Tnode -------------------------- */ - -union yaffs_Tnode_union { - union yaffs_Tnode_union *internal[YAFFS_NTNODES_INTERNAL]; + /* is_shrink applies to object headers written when we shrink the file (ie resize) */ + u32 is_shrink; }; -typedef union yaffs_Tnode_union yaffs_Tnode; +/*--------------------------- Tnode -------------------------- */ +struct yaffs_tnode { + struct yaffs_tnode *internal[YAFFS_NTNODES_INTERNAL]; +}; /*------------------------ Object -----------------------------*/ /* An object can be one of: @@ -366,604 +346,569 @@ typedef union yaffs_Tnode_union yaffs_Tnode; * - a hard link */ -typedef struct { - __u32 fileSize; - __u32 scannedFileSize; - __u32 shrinkSize; - int topLevel; - yaffs_Tnode *top; -} yaffs_FileStructure; +struct yaffs_file_var { + u32 file_size; + u32 scanned_size; + u32 shrink_size; + int top_level; + struct yaffs_tnode *top; +}; -typedef struct { - struct ylist_head children; /* list of child links */ - struct ylist_head dirty; /* Entry for list of dirty directories */ -} yaffs_DirectoryStructure; +struct yaffs_dir_var { + struct list_head children; /* list of child links */ + struct list_head dirty; /* Entry for list of dirty directories */ +}; -typedef struct { +struct yaffs_symlink_var { YCHAR *alias; -} yaffs_SymLinkStructure; +}; -typedef struct { - struct yaffs_ObjectStruct *equivalentObject; - __u32 equivalentObjectId; -} yaffs_HardLinkStructure; +struct yaffs_hardlink_var { + struct yaffs_obj *equiv_obj; + u32 equiv_id; +}; -typedef union { - yaffs_FileStructure fileVariant; - yaffs_DirectoryStructure directoryVariant; - yaffs_SymLinkStructure symLinkVariant; - yaffs_HardLinkStructure hardLinkVariant; -} yaffs_ObjectVariant; +union yaffs_obj_var { + struct yaffs_file_var file_variant; + struct yaffs_dir_var dir_variant; + struct yaffs_symlink_var symlink_variant; + struct yaffs_hardlink_var hardlink_variant; +}; - - -struct yaffs_ObjectStruct { - __u8 deleted:1; /* This should only apply to unlinked files. */ - __u8 softDeleted:1; /* it has also been soft deleted */ - __u8 unlinked:1; /* An unlinked file. The file should be in the unlinked directory.*/ - __u8 fake:1; /* A fake object has no presence on NAND. */ - __u8 renameAllowed:1; /* Some objects are not allowed to be renamed. */ - __u8 unlinkAllowed:1; - __u8 dirty:1; /* the object needs to be written to flash */ - __u8 valid:1; /* When the file system is being loaded up, this +struct yaffs_obj { + u8 deleted:1; /* This should only apply to unlinked files. */ + u8 soft_del:1; /* it has also been soft deleted */ + u8 unlinked:1; /* An unlinked file. The file should be in the unlinked directory. */ + u8 fake:1; /* A fake object has no presence on NAND. */ + u8 rename_allowed:1; /* Some objects are not allowed to be renamed. */ + u8 unlink_allowed:1; + u8 dirty:1; /* the object needs to be written to flash */ + u8 valid:1; /* When the file system is being loaded up, this * object might be created before the data * is available (ie. file data records appear before the header). */ - __u8 lazyLoaded:1; /* This object has been lazy loaded and is missing some detail */ + u8 lazy_loaded:1; /* This object has been lazy loaded and is missing some detail */ - __u8 deferedFree:1; /* For Linux kernel. Object is removed from NAND, but is + u8 defered_free:1; /* For Linux kernel. Object is removed from NAND, but is * still in the inode cache. Free of object is defered. * until the inode is released. */ - __u8 beingCreated:1; /* This object is still being created so skip some checks. */ - __u8 isShadowed:1; /* This object is shadowed on the way to being renamed. */ + u8 being_created:1; /* This object is still being created so skip some checks. */ + u8 is_shadowed:1; /* This object is shadowed on the way to being renamed. */ - __u8 xattrKnown:1; /* We know if this has object has xattribs or not. */ - __u8 hasXattr:1; /* This object has xattribs. Valid if xattrKnown. */ + u8 xattr_known:1; /* We know if this has object has xattribs or not. */ + u8 has_xattr:1; /* This object has xattribs. Valid if xattr_known. */ - __u8 serial; /* serial number of chunk in NAND. Cached here */ - __u16 sum; /* sum of the name to speed searching */ + u8 serial; /* serial number of chunk in NAND. Cached here */ + u16 sum; /* sum of the name to speed searching */ - struct yaffs_DeviceStruct *myDev; /* The device I'm on */ + struct yaffs_dev *my_dev; /* The device I'm on */ - struct ylist_head hashLink; /* list of objects in this hash bucket */ + struct list_head hash_link; /* list of objects in this hash bucket */ - struct ylist_head hardLinks; /* all the equivalent hard linked objects */ + struct list_head hard_links; /* all the equivalent hard linked objects */ /* directory structure stuff */ /* also used for linking up the free list */ - struct yaffs_ObjectStruct *parent; - struct ylist_head siblings; + struct yaffs_obj *parent; + struct list_head siblings; /* Where's my object header in NAND? */ - int hdrChunk; + int hdr_chunk; - int nDataChunks; /* Number of data chunks attached to the file. */ + int n_data_chunks; /* Number of data chunks attached to the file. */ - __u32 objectId; /* the object id value */ + u32 obj_id; /* the object id value */ - __u32 yst_mode; + u32 yst_mode; #ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM - YCHAR shortName[YAFFS_SHORT_NAME_LENGTH + 1]; + YCHAR short_name[YAFFS_SHORT_NAME_LENGTH + 1]; #endif #ifdef CONFIG_YAFFS_WINCE - __u32 win_ctime[2]; - __u32 win_mtime[2]; - __u32 win_atime[2]; + u32 win_ctime[2]; + u32 win_mtime[2]; + u32 win_atime[2]; #else - __u32 yst_uid; - __u32 yst_gid; - __u32 yst_atime; - __u32 yst_mtime; - __u32 yst_ctime; + u32 yst_uid; + u32 yst_gid; + u32 yst_atime; + u32 yst_mtime; + u32 yst_ctime; #endif - __u32 yst_rdev; + u32 yst_rdev; - void *myInode; + void *my_inode; - yaffs_ObjectType variantType; + enum yaffs_obj_type variant_type; - yaffs_ObjectVariant variant; + union yaffs_obj_var variant; }; -typedef struct yaffs_ObjectStruct yaffs_Object; - -typedef struct { - struct ylist_head list; +struct yaffs_obj_bucket { + struct list_head list; int count; -} yaffs_ObjectBucket; +}; - -/* yaffs_CheckpointObject holds the definition of an object as dumped +/* yaffs_checkpt_obj holds the definition of an object as dumped * by checkpointing. */ -typedef struct { - int structType; - __u32 objectId; - __u32 parentId; - int hdrChunk; - yaffs_ObjectType variantType:3; - __u8 deleted:1; - __u8 softDeleted:1; - __u8 unlinked:1; - __u8 fake:1; - __u8 renameAllowed:1; - __u8 unlinkAllowed:1; - __u8 serial; - - int nDataChunks; - __u32 fileSizeOrEquivalentObjectId; -} yaffs_CheckpointObject; +struct yaffs_checkpt_obj { + int struct_type; + u32 obj_id; + u32 parent_id; + int hdr_chunk; + enum yaffs_obj_type variant_type:3; + u8 deleted:1; + u8 soft_del:1; + u8 unlinked:1; + u8 fake:1; + u8 rename_allowed:1; + u8 unlink_allowed:1; + u8 serial; + int n_data_chunks; + u32 size_or_equiv_obj; +}; /*--------------------- Temporary buffers ---------------- * * These are chunk-sized working buffers. Each device has a few */ -typedef struct { - __u8 *buffer; - int line; /* track from whence this buffer was allocated */ - int maxLine; -} yaffs_TempBuffer; +struct yaffs_buffer { + u8 *buffer; + int line; /* track from whence this buffer was allocated */ + int max_line; +}; /*----------------- Device ---------------------------------*/ - -struct yaffs_DeviceParamStruct { +struct yaffs_param { const YCHAR *name; /* - * Entry parameters set up way early. Yaffs sets up the rest. - * The structure should be zeroed out before use so that unused - * and defualt values are zero. - */ + * Entry parameters set up way early. Yaffs sets up the rest. + * The structure should be zeroed out before use so that unused + * and defualt values are zero. + */ - int inbandTags; /* Use unband tags */ - __u32 totalBytesPerChunk; /* Should be >= 512, does not need to be a power of 2 */ - int nChunksPerBlock; /* does not need to be a power of 2 */ - int spareBytesPerChunk; /* spare area size */ - int startBlock; /* Start block we're allowed to use */ - int endBlock; /* End block we're allowed to use */ - int nReservedBlocks; /* We want this tuneable so that we can reduce */ - /* reserved blocks on NOR and RAM. */ + int inband_tags; /* Use unband tags */ + u32 total_bytes_per_chunk; /* Should be >= 512, does not need to be a power of 2 */ + int chunks_per_block; /* does not need to be a power of 2 */ + int spare_bytes_per_chunk; /* spare area size */ + int start_block; /* Start block we're allowed to use */ + int end_block; /* End block we're allowed to use */ + int n_reserved_blocks; /* We want this tuneable so that we can reduce */ + /* reserved blocks on NOR and RAM. */ - - int nShortOpCaches; /* If <= 0, then short op caching is disabled, else + int n_caches; /* If <= 0, then short op caching is disabled, else * the number of short op caches (don't use too many). - * 10 to 20 is a good bet. + * 10 to 20 is a good bet. */ - int useNANDECC; /* Flag to decide whether or not to use NANDECC on data (yaffs1) */ - int noTagsECC; /* Flag to decide whether or not to do ECC on packed tags (yaffs2) */ + int use_nand_ecc; /* Flag to decide whether or not to use NANDECC on data (yaffs1) */ + int no_tags_ecc; /* Flag to decide whether or not to do ECC on packed tags (yaffs2) */ - int isYaffs2; /* Use yaffs2 mode on this device */ + int is_yaffs2; /* Use yaffs2 mode on this device */ - int emptyLostAndFound; /* Auto-empty lost+found directory on mount */ + int empty_lost_n_found; /* Auto-empty lost+found directory on mount */ - int refreshPeriod; /* How often we should check to do a block refresh */ + int refresh_period; /* How often we should check to do a block refresh */ /* Checkpoint control. Can be set before or after initialisation */ - __u8 skipCheckpointRead; - __u8 skipCheckpointWrite; + u8 skip_checkpt_rd; + u8 skip_checkpt_wr; - int enableXattr; /* Enable xattribs */ + int enable_xattr; /* Enable xattribs */ - /* NAND access functions (Must be set before calling YAFFS)*/ + /* NAND access functions (Must be set before calling YAFFS) */ - int (*writeChunkToNAND) (struct yaffs_DeviceStruct *dev, - int chunkInNAND, const __u8 *data, - const yaffs_Spare *spare); - int (*readChunkFromNAND) (struct yaffs_DeviceStruct *dev, - int chunkInNAND, __u8 *data, - yaffs_Spare *spare); - int (*eraseBlockInNAND) (struct yaffs_DeviceStruct *dev, - int blockInNAND); - int (*initialiseNAND) (struct yaffs_DeviceStruct *dev); - int (*deinitialiseNAND) (struct yaffs_DeviceStruct *dev); + int (*write_chunk_fn) (struct yaffs_dev * dev, + int nand_chunk, const u8 * data, + const struct yaffs_spare * spare); + int (*read_chunk_fn) (struct yaffs_dev * dev, + int nand_chunk, u8 * data, + struct yaffs_spare * spare); + int (*erase_fn) (struct yaffs_dev * dev, int flash_block); + int (*initialise_flash_fn) (struct yaffs_dev * dev); + int (*deinitialise_flash_fn) (struct yaffs_dev * dev); #ifdef CONFIG_YAFFS_YAFFS2 - int (*writeChunkWithTagsToNAND) (struct yaffs_DeviceStruct *dev, - int chunkInNAND, const __u8 *data, - const yaffs_ExtendedTags *tags); - int (*readChunkWithTagsFromNAND) (struct yaffs_DeviceStruct *dev, - int chunkInNAND, __u8 *data, - yaffs_ExtendedTags *tags); - int (*markNANDBlockBad) (struct yaffs_DeviceStruct *dev, int blockNo); - int (*queryNANDBlock) (struct yaffs_DeviceStruct *dev, int blockNo, - yaffs_BlockState *state, __u32 *sequenceNumber); + int (*write_chunk_tags_fn) (struct yaffs_dev * dev, + int nand_chunk, const u8 * data, + const struct yaffs_ext_tags * tags); + int (*read_chunk_tags_fn) (struct yaffs_dev * dev, + int nand_chunk, u8 * data, + struct yaffs_ext_tags * tags); + int (*bad_block_fn) (struct yaffs_dev * dev, int block_no); + int (*query_block_fn) (struct yaffs_dev * dev, int block_no, + enum yaffs_block_state * state, + u32 * seq_number); #endif - /* The removeObjectCallback function must be supplied by OS flavours that + /* The remove_obj_fn function must be supplied by OS flavours that * need it. - * yaffs direct uses it to implement the faster readdir. - * Linux uses it to protect the directory during unlocking. + * yaffs direct uses it to implement the faster readdir. + * Linux uses it to protect the directory during unlocking. */ - void (*removeObjectCallback)(struct yaffs_ObjectStruct *obj); + void (*remove_obj_fn) (struct yaffs_obj * obj); /* Callback to mark the superblock dirty */ - void (*markSuperBlockDirty)(struct yaffs_DeviceStruct *dev); - - /* Callback to control garbage collection. */ - unsigned (*gcControl)(struct yaffs_DeviceStruct *dev); + void (*sb_dirty_fn) (struct yaffs_dev * dev); - /* Debug control flags. Don't use unless you know what you're doing */ - int useHeaderFileSize; /* Flag to determine if we should use file sizes from the header */ - int disableLazyLoad; /* Disable lazy loading on this device */ - int wideTnodesDisabled; /* Set to disable wide tnodes */ - int disableSoftDelete; /* yaffs 1 only: Set to disable the use of softdeletion. */ - - int deferDirectoryUpdate; /* Set to defer directory updates */ + /* Callback to control garbage collection. */ + unsigned (*gc_control) (struct yaffs_dev * dev); + + /* Debug control flags. Don't use unless you know what you're doing */ + int use_header_file_size; /* Flag to determine if we should use file sizes from the header */ + int disable_lazy_load; /* Disable lazy loading on this device */ + int wide_tnodes_disabled; /* Set to disable wide tnodes */ + int disable_soft_del; /* yaffs 1 only: Set to disable the use of softdeletion. */ + + int defered_dir_update; /* Set to defer directory updates */ #ifdef CONFIG_YAFFS_AUTO_UNICODE - int autoUnicode; + int auto_unicode; #endif - int alwaysCheckErased; /* Force chunk erased check always on */ + int always_check_erased; /* Force chunk erased check always on */ }; -typedef struct yaffs_DeviceParamStruct yaffs_DeviceParam; +struct yaffs_dev { + struct yaffs_param param; -struct yaffs_DeviceStruct { - struct yaffs_DeviceParamStruct param; + /* Context storage. Holds extra OS specific data for this device */ - /* Context storage. Holds extra OS specific data for this device */ + void *os_context; + void *driver_context; - void *osContext; - void *driverContext; - - struct ylist_head devList; + struct list_head dev_list; /* Runtime parameters. Set up by YAFFS. */ - int nDataBytesPerChunk; + int data_bytes_per_chunk; - /* Non-wide tnode stuff */ - __u16 chunkGroupBits; /* Number of bits that need to be resolved if - * the tnodes are not wide enough. - */ - __u16 chunkGroupSize; /* == 2^^chunkGroupBits */ + /* Non-wide tnode stuff */ + u16 chunk_grp_bits; /* Number of bits that need to be resolved if + * the tnodes are not wide enough. + */ + u16 chunk_grp_size; /* == 2^^chunk_grp_bits */ /* Stuff to support wide tnodes */ - __u32 tnodeWidth; - __u32 tnodeMask; - __u32 tnodeSize; + u32 tnode_width; + u32 tnode_mask; + u32 tnode_size; /* Stuff for figuring out file offset to chunk conversions */ - __u32 chunkShift; /* Shift value */ - __u32 chunkDiv; /* Divisor after shifting: 1 for power-of-2 sizes */ - __u32 chunkMask; /* Mask to use for power-of-2 case */ - - - - int isMounted; - int readOnly; - int isCheckpointed; + u32 chunk_shift; /* Shift value */ + u32 chunk_div; /* Divisor after shifting: 1 for power-of-2 sizes */ + u32 chunk_mask; /* Mask to use for power-of-2 case */ + int is_mounted; + int read_only; + int is_checkpointed; /* Stuff to support block offsetting to support start block zero */ - int internalStartBlock; - int internalEndBlock; - int blockOffset; - int chunkOffset; - + int internal_start_block; + int internal_end_block; + int block_offset; + int chunk_offset; /* Runtime checkpointing stuff */ - int checkpointPageSequence; /* running sequence number of checkpoint pages */ - int checkpointByteCount; - int checkpointByteOffset; - __u8 *checkpointBuffer; - int checkpointOpenForWrite; - int blocksInCheckpoint; - int checkpointCurrentChunk; - int checkpointCurrentBlock; - int checkpointNextBlock; - int *checkpointBlockList; - int checkpointMaxBlocks; - __u32 checkpointSum; - __u32 checkpointXor; + int checkpt_page_seq; /* running sequence number of checkpoint pages */ + int checkpt_byte_count; + int checkpt_byte_offs; + u8 *checkpt_buffer; + int checkpt_open_write; + int blocks_in_checkpt; + int checkpt_cur_chunk; + int checkpt_cur_block; + int checkpt_next_block; + int *checkpt_block_list; + int checkpt_max_blocks; + u32 checkpt_sum; + u32 checkpt_xor; - int nCheckpointBlocksRequired; /* Number of blocks needed to store current checkpoint set */ + int checkpoint_blocks_required; /* Number of blocks needed to store current checkpoint set */ /* Block Info */ - yaffs_BlockInfo *blockInfo; - __u8 *chunkBits; /* bitmap of chunks in use */ - unsigned blockInfoAlt:1; /* was allocated using alternative strategy */ - unsigned chunkBitsAlt:1; /* was allocated using alternative strategy */ - int chunkBitmapStride; /* Number of bytes of chunkBits per block. - * Must be consistent with nChunksPerBlock. + struct yaffs_block_info *block_info; + u8 *chunk_bits; /* bitmap of chunks in use */ + unsigned block_info_alt:1; /* was allocated using alternative strategy */ + unsigned chunk_bits_alt:1; /* was allocated using alternative strategy */ + int chunk_bit_stride; /* Number of bytes of chunk_bits per block. + * Must be consistent with chunks_per_block. */ - int nErasedBlocks; - int allocationBlock; /* Current block being allocated off */ - __u32 allocationPage; - int allocationBlockFinder; /* Used to search for next allocation block */ + int n_erased_blocks; + int alloc_block; /* Current block being allocated off */ + u32 alloc_page; + int alloc_block_finder; /* Used to search for next allocation block */ /* Object and Tnode memory management */ void *allocator; - int nObjects; - int nTnodes; + int n_obj; + int n_tnodes; - int nHardLinks; + int n_hardlinks; - yaffs_ObjectBucket objectBucket[YAFFS_NOBJECT_BUCKETS]; - __u32 bucketFinder; + struct yaffs_obj_bucket obj_bucket[YAFFS_NOBJECT_BUCKETS]; + u32 bucket_finder; - int nFreeChunks; + int n_free_chunks; /* Garbage collection control */ - __u32 *gcCleanupList; /* objects to delete at the end of a GC. */ - __u32 nCleanups; + u32 *gc_cleanup_list; /* objects to delete at the end of a GC. */ + u32 n_clean_ups; - unsigned hasPendingPrioritisedGCs; /* We think this device might have pending prioritised gcs */ - unsigned gcDisable; - unsigned gcBlockFinder; - unsigned gcDirtiest; - unsigned gcPagesInUse; - unsigned gcNotDone; - unsigned gcBlock; - unsigned gcChunk; - unsigned gcSkip; + unsigned has_pending_prioritised_gc; /* We think this device might have pending prioritised gcs */ + unsigned gc_disable; + unsigned gc_block_finder; + unsigned gc_dirtiest; + unsigned gc_pages_in_use; + unsigned gc_not_done; + unsigned gc_block; + unsigned gc_chunk; + unsigned gc_skip; /* Special directories */ - yaffs_Object *rootDir; - yaffs_Object *lostNFoundDir; + struct yaffs_obj *root_dir; + struct yaffs_obj *lost_n_found; /* Buffer areas for storing data to recover from write failures TODO - * __u8 bufferedData[YAFFS_CHUNKS_PER_BLOCK][YAFFS_BYTES_PER_CHUNK]; - * yaffs_Spare bufferedSpare[YAFFS_CHUNKS_PER_BLOCK]; + * u8 buffered_data[YAFFS_CHUNKS_PER_BLOCK][YAFFS_BYTES_PER_CHUNK]; + * struct yaffs_spare buffered_spare[YAFFS_CHUNKS_PER_BLOCK]; */ - int bufferedBlock; /* Which block is buffered here? */ - int doingBufferedBlockRewrite; + int buffered_block; /* Which block is buffered here? */ + int doing_buffered_block_rewrite; - yaffs_ChunkCache *srCache; - int srLastUse; + struct yaffs_cache *cache; + int cache_last_use; - /* Stuff for background deletion and unlinked files.*/ - yaffs_Object *unlinkedDir; /* Directory where unlinked and deleted files live. */ - yaffs_Object *deletedDir; /* Directory where deleted objects are sent to disappear. */ - yaffs_Object *unlinkedDeletion; /* Current file being background deleted.*/ - int nDeletedFiles; /* Count of files awaiting deletion;*/ - int nUnlinkedFiles; /* Count of unlinked files. */ - int nBackgroundDeletions; /* Count of background deletions. */ + /* Stuff for background deletion and unlinked files. */ + struct yaffs_obj *unlinked_dir; /* Directory where unlinked and deleted files live. */ + struct yaffs_obj *del_dir; /* Directory where deleted objects are sent to disappear. */ + struct yaffs_obj *unlinked_deletion; /* Current file being background deleted. */ + int n_deleted_files; /* Count of files awaiting deletion; */ + int n_unlinked_files; /* Count of unlinked files. */ + int n_bg_deletions; /* Count of background deletions. */ /* Temporary buffer management */ - yaffs_TempBuffer tempBuffer[YAFFS_N_TEMP_BUFFERS]; - int maxTemp; - int tempInUse; - int unmanagedTempAllocations; - int unmanagedTempDeallocations; + struct yaffs_buffer temp_buffer[YAFFS_N_TEMP_BUFFERS]; + int max_temp; + int temp_in_use; + int unmanaged_buffer_allocs; + int unmanaged_buffer_deallocs; /* yaffs2 runtime stuff */ - unsigned sequenceNumber; /* Sequence number of currently allocating block */ - unsigned oldestDirtySequence; - unsigned oldestDirtyBlock; + unsigned seq_number; /* Sequence number of currently allocating block */ + unsigned oldest_dirty_seq; + unsigned oldest_dirty_block; /* Block refreshing */ - int refreshSkip; /* A skip down counter. Refresh happens when this gets to zero. */ + int refresh_skip; /* A skip down counter. Refresh happens when this gets to zero. */ /* Dirty directory handling */ - struct ylist_head dirtyDirectories; /* List of dirty directories */ - + struct list_head dirty_dirs; /* List of dirty directories */ /* Statistcs */ - __u32 nPageWrites; - __u32 nPageReads; - __u32 nBlockErasures; - __u32 nErasureFailures; - __u32 nGCCopies; - __u32 allGCs; - __u32 passiveGCs; - __u32 oldestDirtyGCs; - __u32 nGCBlocks; - __u32 backgroundGCs; - __u32 nRetriedWrites; - __u32 nRetiredBlocks; - __u32 eccFixed; - __u32 eccUnfixed; - __u32 tagsEccFixed; - __u32 tagsEccUnfixed; - __u32 nDeletions; - __u32 nUnmarkedDeletions; - __u32 refreshCount; - __u32 cacheHits; + u32 n_page_writes; + u32 n_page_reads; + u32 n_erasures; + u32 n_erase_failures; + u32 n_gc_copies; + u32 all_gcs; + u32 passive_gc_count; + u32 oldest_dirty_gc_count; + u32 n_gc_blocks; + u32 bg_gcs; + u32 n_retired_writes; + u32 n_retired_blocks; + u32 n_ecc_fixed; + u32 n_ecc_unfixed; + u32 n_tags_ecc_fixed; + u32 n_tags_ecc_unfixed; + u32 n_deletions; + u32 n_unmarked_deletions; + u32 refresh_count; + u32 cache_hits; }; -typedef struct yaffs_DeviceStruct yaffs_Device; - -/* The static layout of block usage etc is stored in the super block header */ -typedef struct { - int StructType; - int version; - int checkpointStartBlock; - int checkpointEndBlock; - int startBlock; - int endBlock; - int rfu[100]; -} yaffs_SuperBlockHeader; - /* The CheckpointDevice structure holds the device information that changes at runtime and * must be preserved over unmount/mount cycles. */ -typedef struct { - int structType; - int nErasedBlocks; - int allocationBlock; /* Current block being allocated off */ - __u32 allocationPage; - int nFreeChunks; +struct yaffs_checkpt_dev { + int struct_type; + int n_erased_blocks; + int alloc_block; /* Current block being allocated off */ + u32 alloc_page; + int n_free_chunks; - int nDeletedFiles; /* Count of files awaiting deletion;*/ - int nUnlinkedFiles; /* Count of unlinked files. */ - int nBackgroundDeletions; /* Count of background deletions. */ + int n_deleted_files; /* Count of files awaiting deletion; */ + int n_unlinked_files; /* Count of unlinked files. */ + int n_bg_deletions; /* Count of background deletions. */ /* yaffs2 runtime stuff */ - unsigned sequenceNumber; /* Sequence number of currently allocating block */ + unsigned seq_number; /* Sequence number of currently allocating block */ -} yaffs_CheckpointDevice; +}; +struct yaffs_checkpt_validity { + int struct_type; + u32 magic; + u32 version; + u32 head; +}; -typedef struct { - int structType; - __u32 magic; - __u32 version; - __u32 head; -} yaffs_CheckpointValidity; - - -struct yaffs_ShadowFixerStruct { - int objectId; - int shadowedId; - struct yaffs_ShadowFixerStruct *next; +struct yaffs_shadow_fixer { + int obj_id; + int shadowed_id; + struct yaffs_shadow_fixer *next; }; /* Structure for doing xattr modifications */ -typedef struct { - int set; /* If 0 then this is a deletion */ +struct yaffs_xattr_mod { + int set; /* If 0 then this is a deletion */ const YCHAR *name; const void *data; int size; int flags; int result; -}yaffs_XAttrMod; - +}; /*----------------------- YAFFS Functions -----------------------*/ -int yaffs_GutsInitialise(yaffs_Device *dev); -void yaffs_Deinitialise(yaffs_Device *dev); +int yaffs_guts_initialise(struct yaffs_dev *dev); +void yaffs_deinitialise(struct yaffs_dev *dev); -int yaffs_GetNumberOfFreeChunks(yaffs_Device *dev); +int yaffs_get_n_free_chunks(struct yaffs_dev *dev); -int yaffs_RenameObject(yaffs_Object *oldDir, const YCHAR *oldName, - yaffs_Object *newDir, const YCHAR *newName); +int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR * old_name, + struct yaffs_obj *new_dir, const YCHAR * new_name); -int yaffs_Unlink(yaffs_Object *dir, const YCHAR *name); -int yaffs_DeleteObject(yaffs_Object *obj); +int yaffs_unlinker(struct yaffs_obj *dir, const YCHAR * name); +int yaffs_del_obj(struct yaffs_obj *obj); -int yaffs_GetObjectName(yaffs_Object *obj, YCHAR *name, int buffSize); -int yaffs_GetObjectFileLength(yaffs_Object *obj); -int yaffs_GetObjectInode(yaffs_Object *obj); -unsigned yaffs_GetObjectType(yaffs_Object *obj); -int yaffs_GetObjectLinkCount(yaffs_Object *obj); - -int yaffs_SetAttributes(yaffs_Object *obj, struct iattr *attr); -int yaffs_GetAttributes(yaffs_Object *obj, struct iattr *attr); +int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR * name, int buffer_size); +int yaffs_get_obj_length(struct yaffs_obj *obj); +int yaffs_get_obj_inode(struct yaffs_obj *obj); +unsigned yaffs_get_obj_type(struct yaffs_obj *obj); +int yaffs_get_obj_link_count(struct yaffs_obj *obj); /* File operations */ -int yaffs_ReadDataFromFile(yaffs_Object *obj, __u8 *buffer, loff_t offset, - int nBytes); -int yaffs_WriteDataToFile(yaffs_Object *obj, const __u8 *buffer, loff_t offset, - int nBytes, int writeThrough); -int yaffs_ResizeFile(yaffs_Object *obj, loff_t newSize); +int yaffs_file_rd(struct yaffs_obj *obj, u8 * buffer, loff_t offset, + int n_bytes); +int yaffs_wr_file(struct yaffs_obj *obj, const u8 * buffer, loff_t offset, + int n_bytes, int write_trhrough); +int yaffs_resize_file(struct yaffs_obj *obj, loff_t new_size); -yaffs_Object *yaffs_MknodFile(yaffs_Object *parent, const YCHAR *name, - __u32 mode, __u32 uid, __u32 gid); +struct yaffs_obj *yaffs_create_file(struct yaffs_obj *parent, + const YCHAR * name, u32 mode, u32 uid, + u32 gid); -int yaffs_FlushFile(yaffs_Object *obj, int updateTime, int dataSync); +int yaffs_flush_file(struct yaffs_obj *obj, int update_time, int data_sync); /* Flushing and checkpointing */ -void yaffs_FlushEntireDeviceCache(yaffs_Device *dev); +void yaffs_flush_whole_cache(struct yaffs_dev *dev); -int yaffs_CheckpointSave(yaffs_Device *dev); -int yaffs_CheckpointRestore(yaffs_Device *dev); +int yaffs_checkpoint_save(struct yaffs_dev *dev); +int yaffs_checkpoint_restore(struct yaffs_dev *dev); /* Directory operations */ -yaffs_Object *yaffs_MknodDirectory(yaffs_Object *parent, const YCHAR *name, - __u32 mode, __u32 uid, __u32 gid); -yaffs_Object *yaffs_FindObjectByName(yaffs_Object *theDir, const YCHAR *name); -int yaffs_ApplyToDirectoryChildren(yaffs_Object *theDir, - int (*fn) (yaffs_Object *)); - -yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device *dev, __u32 number); +struct yaffs_obj *yaffs_create_dir(struct yaffs_obj *parent, const YCHAR * name, + u32 mode, u32 uid, u32 gid); +struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *the_dir, + const YCHAR * name); +struct yaffs_obj *yaffs_find_by_number(struct yaffs_dev *dev, u32 number); /* Link operations */ -yaffs_Object *yaffs_Link(yaffs_Object *parent, const YCHAR *name, - yaffs_Object *equivalentObject); +struct yaffs_obj *yaffs_link_obj(struct yaffs_obj *parent, const YCHAR * name, + struct yaffs_obj *equiv_obj); -yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object *obj); +struct yaffs_obj *yaffs_get_equivalent_obj(struct yaffs_obj *obj); /* Symlink operations */ -yaffs_Object *yaffs_MknodSymLink(yaffs_Object *parent, const YCHAR *name, - __u32 mode, __u32 uid, __u32 gid, - const YCHAR *alias); -YCHAR *yaffs_GetSymlinkAlias(yaffs_Object *obj); +struct yaffs_obj *yaffs_create_symlink(struct yaffs_obj *parent, + const YCHAR * name, u32 mode, u32 uid, + u32 gid, const YCHAR * alias); +YCHAR *yaffs_get_symlink_alias(struct yaffs_obj *obj); /* Special inodes (fifos, sockets and devices) */ -yaffs_Object *yaffs_MknodSpecial(yaffs_Object *parent, const YCHAR *name, - __u32 mode, __u32 uid, __u32 gid, __u32 rdev); +struct yaffs_obj *yaffs_create_special(struct yaffs_obj *parent, + const YCHAR * name, u32 mode, u32 uid, + u32 gid, u32 rdev); - -int yaffs_SetXAttribute(yaffs_Object *obj, const YCHAR *name, const void * value, int size, int flags); -int yaffs_GetXAttribute(yaffs_Object *obj, const YCHAR *name, void *value, int size); -int yaffs_ListXAttributes(yaffs_Object *obj, char *buffer, int size); -int yaffs_RemoveXAttribute(yaffs_Object *obj, const YCHAR *name); +int yaffs_set_xattrib(struct yaffs_obj *obj, const YCHAR * name, + const void *value, int size, int flags); +int yaffs_get_xattrib(struct yaffs_obj *obj, const YCHAR * name, void *value, + int size); +int yaffs_list_xattrib(struct yaffs_obj *obj, char *buffer, int size); +int yaffs_remove_xattrib(struct yaffs_obj *obj, const YCHAR * name); /* Special directories */ -yaffs_Object *yaffs_Root(yaffs_Device *dev); -yaffs_Object *yaffs_LostNFound(yaffs_Device *dev); +struct yaffs_obj *yaffs_root(struct yaffs_dev *dev); +struct yaffs_obj *yaffs_lost_n_found(struct yaffs_dev *dev); -#ifdef CONFIG_YAFFS_WINCE -/* CONFIG_YAFFS_WINCE special stuff */ -void yfsd_WinFileTimeNow(__u32 target[2]); -#endif +void yaffs_handle_defered_free(struct yaffs_obj *obj); -void yaffs_HandleDeferedFree(yaffs_Object *obj); +void yaffs_update_dirty_dirs(struct yaffs_dev *dev); -void yaffs_UpdateDirtyDirectories(yaffs_Device *dev); - -int yaffs_BackgroundGarbageCollect(yaffs_Device *dev, unsigned urgency); +int yaffs_bg_gc(struct yaffs_dev *dev, unsigned urgency); /* Debug dump */ -int yaffs_DumpObject(yaffs_Object *obj); +int yaffs_dump_obj(struct yaffs_obj *obj); -void yaffs_GutsTest(yaffs_Device *dev); +void yaffs_guts_test(struct yaffs_dev *dev); /* A few useful functions to be used within the core files*/ -void yaffs_DeleteChunk(yaffs_Device *dev, int chunkId, int markNAND, int lyn); -int yaffs_CheckFF(__u8 *buffer, int nBytes); -void yaffs_HandleChunkError(yaffs_Device *dev, yaffs_BlockInfo *bi); +void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash, + int lyn); +int yaffs_check_ff(u8 * buffer, int n_bytes); +void yaffs_handle_chunk_error(struct yaffs_dev *dev, + struct yaffs_block_info *bi); -__u8 *yaffs_GetTempBuffer(yaffs_Device *dev, int lineNo); -void yaffs_ReleaseTempBuffer(yaffs_Device *dev, __u8 *buffer, int lineNo); +u8 *yaffs_get_temp_buffer(struct yaffs_dev *dev, int line_no); +void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 * buffer, int line_no); -yaffs_Object *yaffs_FindOrCreateObjectByNumber(yaffs_Device *dev, - int number, - yaffs_ObjectType type); -int yaffs_PutChunkIntoFile(yaffs_Object *in, int chunkInInode, - int chunkInNAND, int inScan); -void yaffs_SetObjectName(yaffs_Object *obj, const YCHAR *name); -void yaffs_SetObjectNameFromOH(yaffs_Object *obj, const yaffs_ObjectHeader *oh); -void yaffs_AddObjectToDirectory(yaffs_Object *directory, - yaffs_Object *obj); -YCHAR *yaffs_CloneString(const YCHAR *str); -void yaffs_HardlinkFixup(yaffs_Device *dev, yaffs_Object *hardList); -void yaffs_BlockBecameDirty(yaffs_Device *dev, int blockNo); -int yaffs_UpdateObjectHeader(yaffs_Object *in, const YCHAR *name, - int force, int isShrink, int shadows, - yaffs_XAttrMod *xop); -void yaffs_HandleShadowedObject(yaffs_Device *dev, int objId, - int backwardScanning); -int yaffs_CheckSpaceForAllocation(yaffs_Device *dev, int nChunks); -yaffs_Tnode *yaffs_GetTnode(yaffs_Device *dev); -yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device *dev, - yaffs_FileStructure *fStruct, - __u32 chunkId, - yaffs_Tnode *passedTn); +struct yaffs_obj *yaffs_find_or_create_by_number(struct yaffs_dev *dev, + int number, + enum yaffs_obj_type type); +int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk, + int nand_chunk, int in_scan); +void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR * name); +void yaffs_set_obj_name_from_oh(struct yaffs_obj *obj, + const struct yaffs_obj_hdr *oh); +void yaffs_add_obj_to_dir(struct yaffs_obj *directory, struct yaffs_obj *obj); +YCHAR *yaffs_clone_str(const YCHAR * str); +void yaffs_link_fixup(struct yaffs_dev *dev, struct yaffs_obj *hard_list); +void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no); +int yaffs_update_oh(struct yaffs_obj *in, const YCHAR * name, + int force, int is_shrink, int shadows, + struct yaffs_xattr_mod *xop); +void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id, + int backward_scanning); +int yaffs_check_alloc_available(struct yaffs_dev *dev, int n_chunks); +struct yaffs_tnode *yaffs_get_tnode(struct yaffs_dev *dev); +struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev, + struct yaffs_file_var *file_struct, + u32 chunk_id, + struct yaffs_tnode *passed_tn); -int yaffs_DoWriteDataToFile(yaffs_Object *in, const __u8 *buffer, loff_t offset, - int nBytes, int writeThrough); -void yaffs_ResizeDown( yaffs_Object *obj, loff_t newSize); -void yaffs_SkipRestOfBlock(yaffs_Device *dev); +int yaffs_do_file_wr(struct yaffs_obj *in, const u8 * buffer, loff_t offset, + int n_bytes, int write_trhrough); +void yaffs_resize_file_down(struct yaffs_obj *obj, loff_t new_size); +void yaffs_skip_rest_of_block(struct yaffs_dev *dev); -int yaffs_CountFreeChunks(yaffs_Device *dev); +int yaffs_count_free_chunks(struct yaffs_dev *dev); -yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device *dev, - yaffs_FileStructure *fStruct, - __u32 chunkId); +struct yaffs_tnode *yaffs_find_tnode_0(struct yaffs_dev *dev, + struct yaffs_file_var *file_struct, + u32 chunk_id); -__u32 yaffs_GetChunkGroupBase(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos); +u32 yaffs_get_group_base(struct yaffs_dev *dev, struct yaffs_tnode *tn, + unsigned pos); #endif diff --git a/fs/yaffs2/yaffs_linux.h b/fs/yaffs2/yaffs_linux.h index ce059fd2..3b508cbc 100644 --- a/fs/yaffs2/yaffs_linux.h +++ b/fs/yaffs2/yaffs_linux.h @@ -16,28 +16,26 @@ #ifndef __YAFFS_LINUX_H__ #define __YAFFS_LINUX_H__ -#include "devextras.h" #include "yportenv.h" -struct yaffs_LinuxContext { - struct ylist_head contextList; /* List of these we have mounted */ - struct yaffs_DeviceStruct *dev; - struct super_block * superBlock; - struct task_struct *bgThread; /* Background thread for this device */ - int bgRunning; - struct semaphore grossLock; /* Gross locking semaphore */ - __u8 *spareBuffer; /* For mtdif2 use. Don't know the size of the buffer +struct yaffs_linux_context { + struct list_head context_list; /* List of these we have mounted */ + struct yaffs_dev *dev; + struct super_block *super; + struct task_struct *bg_thread; /* Background thread for this device */ + int bg_running; + struct mutex gross_lock; /* Gross locking mutex*/ + u8 *spare_buffer; /* For mtdif2 use. Don't know the size of the buffer * at compile time so we have to allocate it. */ - struct ylist_head searchContexts; - void (*putSuperFunc)(struct super_block *sb); + struct list_head search_contexts; + void (*put_super_fn) (struct super_block * sb); - struct task_struct *readdirProcess; + struct task_struct *readdir_process; unsigned mount_id; }; -#define yaffs_DeviceToLC(dev) ((struct yaffs_LinuxContext *)((dev)->osContext)) -#define yaffs_DeviceToMtd(dev) ((struct mtd_info *)((dev)->driverContext)) +#define yaffs_dev_to_lc(dev) ((struct yaffs_linux_context *)((dev)->os_context)) +#define yaffs_dev_to_mtd(dev) ((struct mtd_info *)((dev)->driver_context)) #endif - diff --git a/fs/yaffs2/yaffs_linux_allocator.c b/fs/yaffs2/yaffs_linux_allocator.c deleted file mode 100644 index d4205fa2..00000000 --- a/fs/yaffs2/yaffs_linux_allocator.c +++ /dev/null @@ -1,200 +0,0 @@ -/* - * YAFFS: Yet another Flash File System . A NAND-flash specific file system. - * - * Copyright (C) 2002-2010 Aleph One Ltd. - * for Toby Churchill Ltd and Brightstar Engineering - * - * Created by Charles Manning - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License version 2.1 as - * published by the Free Software Foundation. - * - * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. - * - * Note: Tis code is currently unused. Being checked in in case it becomes useful. - */ - - -#include "yaffs_allocator.h" -#include "yaffs_guts.h" -#include "yaffs_trace.h" -#include "yportenv.h" -#include "yaffs_linux.h" -/* - * Start out with the same allocator as yaffs direct. - * Todo: Change to Linux slab allocator. - */ - - - -#define NAMELEN 20 -struct yaffs_AllocatorStruct { - char tnode_name[NAMELEN+1]; - char object_name[NAMELEN+1]; - struct kmem_cache *tnode_cache; - struct kmem_cache *object_cache; -}; - -typedef struct yaffs_AllocatorStruct yaffs_Allocator; - -int mount_id; - -void yaffs_DeinitialiseRawTnodesAndObjects(yaffs_Device *dev) -{ - yaffs_Allocator *allocator = (yaffs_Allocator *)dev->allocator; - - T(YAFFS_TRACE_ALLOCATE,(TSTR("Deinitialising yaffs allocator\n"))); - - if(allocator){ - if(allocator->tnode_cache){ - kmem_cache_destroy(allocator->tnode_cache); - allocator->tnode_cache = NULL; - } else { - T(YAFFS_TRACE_ALWAYS, - (TSTR("NULL tnode cache\n"))); - YBUG(); - } - - if(allocator->object_cache){ - kmem_cache_destroy(allocator->object_cache); - allocator->object_cache = NULL; - } else { - T(YAFFS_TRACE_ALWAYS, - (TSTR("NULL object cache\n"))); - YBUG(); - } - - YFREE(allocator); - - } else { - T(YAFFS_TRACE_ALWAYS, - (TSTR("Deinitialising NULL allocator\n"))); - YBUG(); - } - dev->allocator = NULL; -} - - -static void fake_ctor0(void *data){data = data;} -static void fake_ctor1(void *data){data = data;} -static void fake_ctor2(void *data){data = data;} -static void fake_ctor3(void *data){data = data;} -static void fake_ctor4(void *data){data = data;} -static void fake_ctor5(void *data){data = data;} -static void fake_ctor6(void *data){data = data;} -static void fake_ctor7(void *data){data = data;} -static void fake_ctor8(void *data){data = data;} -static void fake_ctor9(void *data){data = data;} - -static void (*fake_ctor_list[10]) (void *) = { - fake_ctor0, - fake_ctor1, - fake_ctor2, - fake_ctor3, - fake_ctor4, - fake_ctor5, - fake_ctor6, - fake_ctor7, - fake_ctor8, - fake_ctor9, -}; - -void yaffs_InitialiseRawTnodesAndObjects(yaffs_Device *dev) -{ - yaffs_Allocator *allocator; - unsigned mount_id = yaffs_DeviceToLC(dev)->mount_id; - - T(YAFFS_TRACE_ALLOCATE,(TSTR("Initialising yaffs allocator\n"))); - - if(dev->allocator) - YBUG(); - else if(mount_id >= 10){ - T(YAFFS_TRACE_ALWAYS,(TSTR("Bad mount_id %u\n"),mount_id)); - } else { - allocator = YMALLOC(sizeof(yaffs_Allocator)); - memset(allocator,0,sizeof(yaffs_Allocator)); - dev->allocator = allocator; - - if(!dev->allocator){ - T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs allocator creation failed\n"))); - YBUG(); - return; - - } - - sprintf(allocator->tnode_name,"yaffs_t_%u",mount_id); - sprintf(allocator->object_name,"yaffs_o_%u",mount_id); - - allocator->tnode_cache = - kmem_cache_create(allocator->tnode_name, - dev->tnodeSize, - 0, 0, - fake_ctor_list[mount_id]); - if(allocator->tnode_cache) - T(YAFFS_TRACE_ALLOCATE, - (TSTR("tnode cache \"%s\" %p\n"), - allocator->tnode_name,allocator->tnode_cache)); - else { - T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs cache creation failed\n"))); - YBUG(); - } - - - allocator->object_cache = - kmem_cache_create(allocator->object_name, - sizeof(yaffs_Object), - 0, 0, - fake_ctor_list[mount_id]); - - if(allocator->object_cache) - T(YAFFS_TRACE_ALLOCATE, - (TSTR("object cache \"%s\" %p\n"), - allocator->object_name,allocator->object_cache)); - - else { - T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs cache creation failed\n"))); - YBUG(); - } - } -} - - -yaffs_Tnode *yaffs_AllocateRawTnode(yaffs_Device *dev) -{ - yaffs_Allocator *allocator = dev->allocator; - if(!allocator || !allocator->tnode_cache){ - YBUG(); - return NULL; - } - return kmem_cache_alloc(allocator->tnode_cache, GFP_NOFS); -} - -void yaffs_FreeRawTnode(yaffs_Device *dev, yaffs_Tnode *tn) -{ - yaffs_Allocator *allocator = dev->allocator; - kmem_cache_free(allocator->tnode_cache,tn); -} - -yaffs_Object *yaffs_AllocateRawObject(yaffs_Device *dev) -{ - yaffs_Allocator *allocator = dev->allocator; - if(!allocator){ - YBUG(); - return NULL; - } - if(!allocator->object_cache){ - YBUG(); - return NULL; - } - return kmem_cache_alloc(allocator->object_cache, GFP_NOFS); -} - -void yaffs_FreeRawObject(yaffs_Device *dev, yaffs_Object *obj) -{ - yaffs_Allocator *allocator = dev->allocator; - kmem_cache_free(allocator->object_cache,obj); -} diff --git a/fs/yaffs2/yaffs_list.h b/fs/yaffs2/yaffs_list.h deleted file mode 100644 index 09d80b85..00000000 --- a/fs/yaffs2/yaffs_list.h +++ /dev/null @@ -1,127 +0,0 @@ -/* - * YAFFS: Yet another Flash File System . A NAND-flash specific file system. - * - * Copyright (C) 2002-2010 Aleph One Ltd. - * for Toby Churchill Ltd and Brightstar Engineering - * - * Created by Charles Manning - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License version 2.1 as - * published by the Free Software Foundation. - * - * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. - */ - -/* - * This file is just holds extra declarations of macros that would normally - * be providesd in the Linux kernel. These macros have been written from - * scratch but are functionally equivalent to the Linux ones. - * - */ - -#ifndef __YAFFS_LIST_H__ -#define __YAFFS_LIST_H__ - - -#include "yportenv.h" - -/* - * This is a simple doubly linked list implementation that matches the - * way the Linux kernel doubly linked list implementation works. - */ - -struct ylist_head { - struct ylist_head *next; /* next in chain */ - struct ylist_head *prev; /* previous in chain */ -}; - - -/* Initialise a static list */ -#define YLIST_HEAD(name) \ -struct ylist_head name = { &(name), &(name)} - - - -/* Initialise a list head to an empty list */ -#define YINIT_LIST_HEAD(p) \ -do { \ - (p)->next = (p);\ - (p)->prev = (p); \ -} while (0) - - -/* Add an element to a list */ -static Y_INLINE void ylist_add(struct ylist_head *newEntry, - struct ylist_head *list) -{ - struct ylist_head *listNext = list->next; - - list->next = newEntry; - newEntry->prev = list; - newEntry->next = listNext; - listNext->prev = newEntry; - -} - -static Y_INLINE void ylist_add_tail(struct ylist_head *newEntry, - struct ylist_head *list) -{ - struct ylist_head *listPrev = list->prev; - - list->prev = newEntry; - newEntry->next = list; - newEntry->prev = listPrev; - listPrev->next = newEntry; - -} - - -/* Take an element out of its current list, with or without - * reinitialising the links.of the entry*/ -static Y_INLINE void ylist_del(struct ylist_head *entry) -{ - struct ylist_head *listNext = entry->next; - struct ylist_head *listPrev = entry->prev; - - listNext->prev = listPrev; - listPrev->next = listNext; - -} - -static Y_INLINE void ylist_del_init(struct ylist_head *entry) -{ - ylist_del(entry); - entry->next = entry->prev = entry; -} - - -/* Test if the list is empty */ -static Y_INLINE int ylist_empty(struct ylist_head *entry) -{ - return (entry->next == entry); -} - - -/* ylist_entry takes a pointer to a list entry and offsets it to that - * we can find a pointer to the object it is embedded in. - */ - - -#define ylist_entry(entry, type, member) \ - ((type *)((char *)(entry)-(unsigned long)(&((type *)NULL)->member))) - - -/* ylist_for_each and list_for_each_safe iterate over lists. - * ylist_for_each_safe uses temporary storage to make the list delete safe - */ - -#define ylist_for_each(itervar, list) \ - for (itervar = (list)->next; itervar != (list); itervar = itervar->next) - -#define ylist_for_each_safe(itervar, saveVar, list) \ - for (itervar = (list)->next, saveVar = (list)->next->next; \ - itervar != (list); itervar = saveVar, saveVar = saveVar->next) - - -#endif diff --git a/fs/yaffs2/yaffs_mtdif.c b/fs/yaffs2/yaffs_mtdif.c index e073a5ef..7cf53b3d 100644 --- a/fs/yaffs2/yaffs_mtdif.c +++ b/fs/yaffs2/yaffs_mtdif.c @@ -13,7 +13,6 @@ #include "yportenv.h" - #include "yaffs_mtdif.h" #include "linux/mtd/mtd.h" @@ -23,19 +22,19 @@ #include "yaffs_linux.h" -int nandmtd_EraseBlockInNAND(yaffs_Device *dev, int blockNumber) +int nandmtd_erase_block(struct yaffs_dev *dev, int block_no) { - struct mtd_info *mtd = yaffs_DeviceToMtd(dev); - __u32 addr = - ((loff_t) blockNumber) * dev->param.totalBytesPerChunk - * dev->param.nChunksPerBlock; + struct mtd_info *mtd = yaffs_dev_to_mtd(dev); + u32 addr = + ((loff_t) block_no) * dev->param.total_bytes_per_chunk + * dev->param.chunks_per_block; struct erase_info ei; - + int retval = 0; ei.mtd = mtd; ei.addr = addr; - ei.len = dev->param.totalBytesPerChunk * dev->param.nChunksPerBlock; + ei.len = dev->param.total_bytes_per_chunk * dev->param.chunks_per_block; ei.time = 1000; ei.retries = 2; ei.callback = NULL; @@ -49,8 +48,7 @@ int nandmtd_EraseBlockInNAND(yaffs_Device *dev, int blockNumber) return YAFFS_FAIL; } -int nandmtd_InitialiseNAND(yaffs_Device *dev) +int nandmtd_initialise(struct yaffs_dev *dev) { return YAFFS_OK; } - diff --git a/fs/yaffs2/yaffs_mtdif.h b/fs/yaffs2/yaffs_mtdif.h index fad9d287..66650741 100644 --- a/fs/yaffs2/yaffs_mtdif.h +++ b/fs/yaffs2/yaffs_mtdif.h @@ -18,10 +18,6 @@ #include "yaffs_guts.h" -#if (MTD_VERSION_CODE < MTD_VERSION(2, 6, 18)) -extern struct nand_oobinfo yaffs_oobinfo; -extern struct nand_oobinfo yaffs_noeccinfo; -#endif -int nandmtd_EraseBlockInNAND(yaffs_Device *dev, int blockNumber); -int nandmtd_InitialiseNAND(yaffs_Device *dev); +int nandmtd_erase_block(struct yaffs_dev *dev, int block_no); +int nandmtd_initialise(struct yaffs_dev *dev); #endif diff --git a/fs/yaffs2/yaffs_mtdif1.c b/fs/yaffs2/yaffs_mtdif1.c index b14a2549..c3ea8c9b 100644 --- a/fs/yaffs2/yaffs_mtdif1.c +++ b/fs/yaffs2/yaffs_mtdif1.c @@ -1,10 +1,11 @@ /* * YAFFS: Yet another FFS. A NAND-flash specific file system. - * yaffs_mtdif1.c NAND mtd interface functions for small-page NAND. * * Copyright (C) 2002-2010 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * + * Created by Charles Manning + * * 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. @@ -18,16 +19,16 @@ * * These functions are invoked via function pointers in yaffs_nand.c. * This replaces functionality provided by functions in yaffs_mtdif.c - * and the yaffs_TagsCompatability functions in yaffs_tagscompat.c that are + * and the yaffs_tags compatability functions in yaffs_tagscompat.c that are * called in yaffs_mtdif.c when the function pointers are NULL. - * We assume the MTD layer is performing ECC (useNANDECC is true). + * We assume the MTD layer is performing ECC (use_nand_ecc is true). */ #include "yportenv.h" #include "yaffs_trace.h" #include "yaffs_guts.h" #include "yaffs_packedtags1.h" -#include "yaffs_tagscompat.h" /* for yaffs_CalcTagsECC */ +#include "yaffs_tagscompat.h" /* for yaffs_calc_tags_ecc */ #include "yaffs_linux.h" #include "linux/kernel.h" @@ -51,19 +52,19 @@ * adjust 'oobfree' to match your existing Yaffs data. * * This nand_ecclayout scatters/gathers to/from the old-yaffs layout with the - * pageStatus byte (at NAND spare offset 4) scattered/gathered from/to + * page_status byte (at NAND spare offset 4) scattered/gathered from/to * the 9th byte. * * Old-style on-NAND format: T0,T1,T2,T3,P,B,T4,T5,E0,E1,E2,T6,T7,E3,E4,E5 - * We have/need PackedTags1 plus pageStatus: T0,T1,T2,T3,T4,T5,T6,T7,P - * where Tn are the tag bytes, En are MTD's ECC bytes, P is the pageStatus + * We have/need packed_tags1 plus page_status: T0,T1,T2,T3,T4,T5,T6,T7,P + * where Tn are the tag bytes, En are MTD's ECC bytes, P is the page_status * byte and B is the small-page bad-block indicator byte. */ static struct nand_ecclayout nand_oob_16 = { .eccbytes = 6, - .eccpos = { 8, 9, 10, 13, 14, 15 }, + .eccpos = {8, 9, 10, 13, 14, 15}, .oobavail = 9, - .oobfree = { { 0, 4 }, { 6, 2 }, { 11, 2 }, { 4, 1 } } + .oobfree = {{0, 4}, {6, 2}, {11, 2}, {4, 1}} }; #endif @@ -73,12 +74,12 @@ static struct nand_ecclayout nand_oob_16 = { * compact (packed) form for storage in NAND. A mini-ECC runs over the * contents of the tags meta-data; used to valid the tags when read. * - * - Pack ExtendedTags to PackedTags1 form - * - Compute mini-ECC for PackedTags1 + * - Pack ExtendedTags to packed_tags1 form + * - Compute mini-ECC for packed_tags1 * - Write data and packed tags to NAND. * - * Note: Due to the use of the PackedTags1 meta-data which does not include - * a full sequence number (as found in the larger PackedTags2 form) it is + * Note: Due to the use of the packed_tags1 meta-data which does not include + * a full sequence number (as found in the larger packed_tags2 form) it is * necessary for Yaffs to re-write a chunk/page (just once) to mark it as * discarded and dirty. This is not ideal: newer NAND parts are supposed * to be written just once. When Yaffs performs this operation, this @@ -88,67 +89,68 @@ static struct nand_ecclayout nand_oob_16 = { * Any underlying MTD error results in YAFFS_FAIL. * Returns YAFFS_OK or YAFFS_FAIL. */ -int nandmtd1_WriteChunkWithTagsToNAND(yaffs_Device *dev, - int chunkInNAND, const __u8 *data, const yaffs_ExtendedTags *etags) +int nandmtd1_write_chunk_tags(struct yaffs_dev *dev, + int nand_chunk, const u8 * data, + const struct yaffs_ext_tags *etags) { - struct mtd_info *mtd = yaffs_DeviceToMtd(dev); - int chunkBytes = dev->nDataBytesPerChunk; - loff_t addr = ((loff_t)chunkInNAND) * chunkBytes; + struct mtd_info *mtd = yaffs_dev_to_mtd(dev); + int chunk_bytes = dev->data_bytes_per_chunk; + loff_t addr = ((loff_t) nand_chunk) * chunk_bytes; struct mtd_oob_ops ops; - yaffs_PackedTags1 pt1; + struct yaffs_packed_tags1 pt1; int retval; - /* we assume that PackedTags1 and yaffs_Tags are compatible */ - compile_time_assertion(sizeof(yaffs_PackedTags1) == 12); - compile_time_assertion(sizeof(yaffs_Tags) == 8); + /* we assume that packed_tags1 and struct yaffs_tags are compatible */ + compile_time_assertion(sizeof(struct yaffs_packed_tags1) == 12); + compile_time_assertion(sizeof(struct yaffs_tags) == 8); - yaffs_PackTags1(&pt1, etags); - yaffs_CalcTagsECC((yaffs_Tags *)&pt1); + yaffs_pack_tags1(&pt1, etags); + yaffs_calc_tags_ecc((struct yaffs_tags *)&pt1); /* When deleting a chunk, the upper layer provides only skeletal - * etags, one with chunkDeleted set. However, we need to update the + * etags, one with is_deleted set. However, we need to update the * tags, not erase them completely. So we use the NAND write property * that only zeroed-bits stick and set tag bytes to all-ones and * zero just the (not) deleted bit. */ #ifndef CONFIG_YAFFS_9BYTE_TAGS - if (etags->chunkDeleted) { + if (etags->is_deleted) { memset(&pt1, 0xff, 8); /* clear delete status bit to indicate deleted */ pt1.deleted = 0; } #else - ((__u8 *)&pt1)[8] = 0xff; - if (etags->chunkDeleted) { + ((u8 *) & pt1)[8] = 0xff; + if (etags->is_deleted) { memset(&pt1, 0xff, 8); - /* zero pageStatus byte to indicate deleted */ - ((__u8 *)&pt1)[8] = 0; + /* zero page_status byte to indicate deleted */ + ((u8 *) & pt1)[8] = 0; } #endif memset(&ops, 0, sizeof(ops)); ops.mode = MTD_OOB_AUTO; - ops.len = (data) ? chunkBytes : 0; + ops.len = (data) ? chunk_bytes : 0; ops.ooblen = YTAG1_SIZE; - ops.datbuf = (__u8 *)data; - ops.oobbuf = (__u8 *)&pt1; + ops.datbuf = (u8 *) data; + ops.oobbuf = (u8 *) & pt1; retval = mtd->write_oob(mtd, addr, &ops); if (retval) { T(YAFFS_TRACE_MTD, - (TSTR("write_oob failed, chunk %d, mtd error %d"TENDSTR), - chunkInNAND, retval)); + (TSTR("write_oob failed, chunk %d, mtd error %d" TENDSTR), + nand_chunk, retval)); } return retval ? YAFFS_FAIL : YAFFS_OK; } -/* Return with empty ExtendedTags but add eccResult. +/* Return with empty ExtendedTags but add ecc_result. */ -static int rettags(yaffs_ExtendedTags *etags, int eccResult, int retval) +static int rettags(struct yaffs_ext_tags *etags, int ecc_result, int retval) { if (etags) { memset(etags, 0, sizeof(*etags)); - etags->eccResult = eccResult; + etags->ecc_result = ecc_result; } return retval; } @@ -156,34 +158,35 @@ static int rettags(yaffs_ExtendedTags *etags, int eccResult, int retval) /* Read a chunk (page) from NAND. * * Caller expects ExtendedTags data to be usable even on error; that is, - * all members except eccResult and blockBad are zeroed. + * all members except ecc_result and block_bad are zeroed. * * - Check ECC results for data (if applicable) * - Check for blank/erased block (return empty ExtendedTags if blank) - * - Check the PackedTags1 mini-ECC (correct if necessary/possible) - * - Convert PackedTags1 to ExtendedTags - * - Update eccResult and blockBad members to refect state. + * - Check the packed_tags1 mini-ECC (correct if necessary/possible) + * - Convert packed_tags1 to ExtendedTags + * - Update ecc_result and block_bad members to refect state. * * Returns YAFFS_OK or YAFFS_FAIL. */ -int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device *dev, - int chunkInNAND, __u8 *data, yaffs_ExtendedTags *etags) +int nandmtd1_read_chunk_tags(struct yaffs_dev *dev, + int nand_chunk, u8 * data, + struct yaffs_ext_tags *etags) { - struct mtd_info *mtd = yaffs_DeviceToMtd(dev); - int chunkBytes = dev->nDataBytesPerChunk; - loff_t addr = ((loff_t)chunkInNAND) * chunkBytes; + struct mtd_info *mtd = yaffs_dev_to_mtd(dev); + int chunk_bytes = dev->data_bytes_per_chunk; + loff_t addr = ((loff_t) nand_chunk) * chunk_bytes; int eccres = YAFFS_ECC_RESULT_NO_ERROR; struct mtd_oob_ops ops; - yaffs_PackedTags1 pt1; + struct yaffs_packed_tags1 pt1; int retval; int deleted; memset(&ops, 0, sizeof(ops)); ops.mode = MTD_OOB_AUTO; - ops.len = (data) ? chunkBytes : 0; + ops.len = (data) ? chunk_bytes : 0; ops.ooblen = YTAG1_SIZE; ops.datbuf = data; - ops.oobbuf = (__u8 *)&pt1; + ops.oobbuf = (u8 *) & pt1; #if (MTD_VERSION_CODE < MTD_VERSION(2, 6, 20)) /* In MTD 2.6.18 to 2.6.19 nand_base.c:nand_do_read_oob() has a bug; @@ -197,8 +200,8 @@ int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device *dev, retval = mtd->read_oob(mtd, addr, &ops); if (retval) { T(YAFFS_TRACE_MTD, - (TSTR("read_oob failed, chunk %d, mtd error %d"TENDSTR), - chunkInNAND, retval)); + (TSTR("read_oob failed, chunk %d, mtd error %d" TENDSTR), + nand_chunk, retval)); } switch (retval) { @@ -209,26 +212,25 @@ int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device *dev, case -EUCLEAN: /* MTD's ECC fixed the data */ eccres = YAFFS_ECC_RESULT_FIXED; - dev->eccFixed++; + dev->n_ecc_fixed++; break; case -EBADMSG: /* MTD's ECC could not fix the data */ - dev->eccUnfixed++; + dev->n_ecc_unfixed++; /* fall into... */ default: rettags(etags, YAFFS_ECC_RESULT_UNFIXED, 0); - etags->blockBad = (mtd->block_isbad)(mtd, addr); + etags->block_bad = (mtd->block_isbad) (mtd, addr); return YAFFS_FAIL; } /* Check for a blank/erased chunk. */ - if (yaffs_CheckFF((__u8 *)&pt1, 8)) { - /* when blank, upper layers want eccResult to be <= NO_ERROR */ + if (yaffs_check_ff((u8 *) & pt1, 8)) { + /* when blank, upper layers want ecc_result to be <= NO_ERROR */ return rettags(etags, YAFFS_ECC_RESULT_NO_ERROR, YAFFS_OK); } - #ifndef CONFIG_YAFFS_9BYTE_TAGS /* Read deleted status (bit) then return it to it's non-deleted * state before performing tags mini-ECC check. pt1.deleted is @@ -237,37 +239,37 @@ int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device *dev, deleted = !pt1.deleted; pt1.deleted = 1; #else - deleted = (yaffs_CountBits(((__u8 *)&pt1)[8]) < 7); + deleted = (yaffs_count_bits(((u8 *) & pt1)[8]) < 7); #endif /* Check the packed tags mini-ECC and correct if necessary/possible. */ - retval = yaffs_CheckECCOnTags((yaffs_Tags *)&pt1); + retval = yaffs_check_tags_ecc((struct yaffs_tags *)&pt1); switch (retval) { case 0: /* no tags error, use MTD result */ break; case 1: /* recovered tags-ECC error */ - dev->tagsEccFixed++; + dev->n_tags_ecc_fixed++; if (eccres == YAFFS_ECC_RESULT_NO_ERROR) eccres = YAFFS_ECC_RESULT_FIXED; break; default: /* unrecovered tags-ECC error */ - dev->tagsEccUnfixed++; + dev->n_tags_ecc_unfixed++; return rettags(etags, YAFFS_ECC_RESULT_UNFIXED, YAFFS_FAIL); } /* Unpack the tags to extended form and set ECC result. - * [set shouldBeFF just to keep yaffs_UnpackTags1 happy] + * [set should_be_ff just to keep yaffs_unpack_tags1 happy] */ - pt1.shouldBeFF = 0xFFFFFFFF; - yaffs_UnpackTags1(etags, &pt1); - etags->eccResult = eccres; + pt1.should_be_ff = 0xFFFFFFFF; + yaffs_unpack_tags1(etags, &pt1); + etags->ecc_result = eccres; /* Set deleted state */ - etags->chunkDeleted = deleted; + etags->is_deleted = deleted; return YAFFS_OK; } @@ -278,15 +280,16 @@ int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device *dev, * * Returns YAFFS_OK or YAFFS_FAIL. */ -int nandmtd1_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo) +int nandmtd1_mark_block_bad(struct yaffs_dev *dev, int block_no) { - struct mtd_info *mtd = yaffs_DeviceToMtd(dev); - int blocksize = dev->param.nChunksPerBlock * dev->nDataBytesPerChunk; + struct mtd_info *mtd = yaffs_dev_to_mtd(dev); + int blocksize = dev->param.chunks_per_block * dev->data_bytes_per_chunk; int retval; - T(YAFFS_TRACE_BAD_BLOCKS,(TSTR("marking block %d bad"TENDSTR), blockNo)); + T(YAFFS_TRACE_BAD_BLOCKS, + (TSTR("marking block %d bad" TENDSTR), block_no)); - retval = mtd->block_markbad(mtd, (loff_t)blocksize * blockNo); + retval = mtd->block_markbad(mtd, (loff_t) blocksize * block_no); return (retval) ? YAFFS_FAIL : YAFFS_OK; } @@ -294,7 +297,7 @@ int nandmtd1_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo) * * Returns YAFFS_OK or YAFFS_FAIL. */ -static int nandmtd1_TestPrerequists(struct mtd_info *mtd) +static int nandmtd1_test_prerequists(struct mtd_info *mtd) { /* 2.6.18 has mtd->ecclayout->oobavail */ /* 2.6.21 has mtd->ecclayout->oobavail and mtd->oobavail */ @@ -302,8 +305,9 @@ static int nandmtd1_TestPrerequists(struct mtd_info *mtd) if (oobavail < YTAG1_SIZE) { T(YAFFS_TRACE_ERROR, - (TSTR("mtd device has only %d bytes for tags, need %d"TENDSTR), - oobavail, YTAG1_SIZE)); + (TSTR + ("mtd device has only %d bytes for tags, need %d" TENDSTR), + oobavail, YTAG1_SIZE)); return YAFFS_FAIL; } return YAFFS_OK; @@ -318,13 +322,13 @@ static int nandmtd1_TestPrerequists(struct mtd_info *mtd) * * Always returns YAFFS_OK. */ -int nandmtd1_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, - yaffs_BlockState *pState, __u32 *pSequenceNumber) +int nandmtd1_query_block(struct yaffs_dev *dev, int block_no, + enum yaffs_block_state *state_ptr, u32 * seq_ptr) { - struct mtd_info *mtd = yaffs_DeviceToMtd(dev); - int chunkNo = blockNo * dev->param.nChunksPerBlock; - loff_t addr = (loff_t)chunkNo * dev->nDataBytesPerChunk; - yaffs_ExtendedTags etags; + struct mtd_info *mtd = yaffs_dev_to_mtd(dev); + int chunk_num = block_no * dev->param.chunks_per_block; + loff_t addr = (loff_t) chunk_num * dev->data_bytes_per_chunk; + struct yaffs_ext_tags etags; int state = YAFFS_BLOCK_STATE_DEAD; int seqnum = 0; int retval; @@ -332,30 +336,30 @@ int nandmtd1_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, /* We don't yet have a good place to test for MTD config prerequists. * Do it here as we are called during the initial scan. */ - if (nandmtd1_TestPrerequists(mtd) != YAFFS_OK) + if (nandmtd1_test_prerequists(mtd) != YAFFS_OK) return YAFFS_FAIL; - retval = nandmtd1_ReadChunkWithTagsFromNAND(dev, chunkNo, NULL, &etags); - etags.blockBad = (mtd->block_isbad)(mtd, addr); - if (etags.blockBad) { + retval = nandmtd1_read_chunk_tags(dev, chunk_num, NULL, &etags); + etags.block_bad = (mtd->block_isbad) (mtd, addr); + if (etags.block_bad) { T(YAFFS_TRACE_BAD_BLOCKS, - (TSTR("block %d is marked bad"TENDSTR), blockNo)); + (TSTR("block %d is marked bad" TENDSTR), block_no)); state = YAFFS_BLOCK_STATE_DEAD; - } else if (etags.eccResult != YAFFS_ECC_RESULT_NO_ERROR) { + } else if (etags.ecc_result != YAFFS_ECC_RESULT_NO_ERROR) { /* bad tags, need to look more closely */ state = YAFFS_BLOCK_STATE_NEEDS_SCANNING; - } else if (etags.chunkUsed) { + } else if (etags.chunk_used) { state = YAFFS_BLOCK_STATE_NEEDS_SCANNING; - seqnum = etags.sequenceNumber; + seqnum = etags.seq_number; } else { state = YAFFS_BLOCK_STATE_EMPTY; } - *pState = state; - *pSequenceNumber = seqnum; + *state_ptr = state; + *seq_ptr = seqnum; /* query always succeeds */ return YAFFS_OK; } -#endif /*MTD_VERSION*/ +#endif /*MTD_VERSION */ diff --git a/fs/yaffs2/yaffs_mtdif1.h b/fs/yaffs2/yaffs_mtdif1.h index 0e6a56fb..07ce4524 100644 --- a/fs/yaffs2/yaffs_mtdif1.h +++ b/fs/yaffs2/yaffs_mtdif1.h @@ -14,15 +14,16 @@ #ifndef __YAFFS_MTDIF1_H__ #define __YAFFS_MTDIF1_H__ -int nandmtd1_WriteChunkWithTagsToNAND(yaffs_Device *dev, int chunkInNAND, - const __u8 *data, const yaffs_ExtendedTags *tags); +int nandmtd1_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk, + const u8 * data, + const struct yaffs_ext_tags *tags); -int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND, - __u8 *data, yaffs_ExtendedTags *tags); +int nandmtd1_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk, + u8 * data, struct yaffs_ext_tags *tags); -int nandmtd1_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo); +int nandmtd1_mark_block_bad(struct yaffs_dev *dev, int block_no); -int nandmtd1_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, - yaffs_BlockState *state, __u32 *sequenceNumber); +int nandmtd1_query_block(struct yaffs_dev *dev, int block_no, + enum yaffs_block_state *state, u32 * seq_number); #endif diff --git a/fs/yaffs2/yaffs_mtdif2.c b/fs/yaffs2/yaffs_mtdif2.c index 2b0a601f..555f937c 100644 --- a/fs/yaffs2/yaffs_mtdif2.c +++ b/fs/yaffs2/yaffs_mtdif2.c @@ -27,14 +27,14 @@ #include "yaffs_linux.h" /* NB For use with inband tags.... - * We assume that the data buffer is of size totalBytersPerChunk so that we can also + * We assume that the data buffer is of size total_bytes_per_chunk so that we can also * use it to load the tags. */ -int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device *dev, int chunkInNAND, - const __u8 *data, - const yaffs_ExtendedTags *tags) +int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk, + const u8 * data, + const struct yaffs_ext_tags *tags) { - struct mtd_info *mtd = yaffs_DeviceToMtd(dev); + struct mtd_info *mtd = yaffs_dev_to_mtd(dev); #if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17)) struct mtd_oob_ops ops; #else @@ -44,18 +44,19 @@ int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device *dev, int chunkInNAND, loff_t addr; - yaffs_PackedTags2 pt; + struct yaffs_packed_tags2 pt; - int packed_tags_size = dev->param.noTagsECC ? sizeof(pt.t) : sizeof(pt); - void * packed_tags_ptr = dev->param.noTagsECC ? (void *) &pt.t : (void *)&pt; + int packed_tags_size = + dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt); + void *packed_tags_ptr = + dev->param.no_tags_ecc ? (void *)&pt.t : (void *)&pt; T(YAFFS_TRACE_MTD, (TSTR - ("nandmtd2_WriteChunkWithTagsToNAND chunk %d data %p tags %p" - TENDSTR), chunkInNAND, data, tags)); + ("nandmtd2_write_chunk_tags chunk %d data %p tags %p" + TENDSTR), nand_chunk, data, tags)); - - addr = ((loff_t) chunkInNAND) * dev->param.totalBytesPerChunk; + addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk; /* For yaffs2 writing there must be both data and tags. * If we're using inband tags, then the tags are stuffed into @@ -63,31 +64,34 @@ int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device *dev, int chunkInNAND, */ if (!data || !tags) BUG(); - else if (dev->param.inbandTags) { - yaffs_PackedTags2TagsPart *pt2tp; - pt2tp = (yaffs_PackedTags2TagsPart *)(data + dev->nDataBytesPerChunk); - yaffs_PackTags2TagsPart(pt2tp, tags); + else if (dev->param.inband_tags) { + struct yaffs_packed_tags2_tags_only *pt2tp; + pt2tp = + (struct yaffs_packed_tags2_tags_only *)(data + + dev-> + data_bytes_per_chunk); + yaffs_pack_tags2_tags_only(pt2tp, tags); } else - yaffs_PackTags2(&pt, tags, !dev->param.noTagsECC); + yaffs_pack_tags2(&pt, tags, !dev->param.no_tags_ecc); #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) ops.mode = MTD_OOB_AUTO; - ops.ooblen = (dev->param.inbandTags) ? 0 : packed_tags_size; - ops.len = dev->param.totalBytesPerChunk; + ops.ooblen = (dev->param.inband_tags) ? 0 : packed_tags_size; + ops.len = dev->param.total_bytes_per_chunk; ops.ooboffs = 0; - ops.datbuf = (__u8 *)data; - ops.oobbuf = (dev->param.inbandTags) ? NULL : packed_tags_ptr; + ops.datbuf = (u8 *) data; + ops.oobbuf = (dev->param.inband_tags) ? NULL : packed_tags_ptr; retval = mtd->write_oob(mtd, addr, &ops); #else - if (!dev->param.inbandTags) { + if (!dev->param.inband_tags) { retval = - mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk, - &dummy, data, (__u8 *) packed_tags_ptr, NULL); + mtd->write_ecc(mtd, addr, dev->data_bytes_per_chunk, + &dummy, data, (u8 *) packed_tags_ptr, NULL); } else { retval = - mtd->write(mtd, addr, dev->param.totalBytesPerChunk, &dummy, - data); + mtd->write(mtd, addr, dev->param.total_bytes_per_chunk, + &dummy, data); } #endif @@ -97,95 +101,99 @@ int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device *dev, int chunkInNAND, return YAFFS_FAIL; } -int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND, - __u8 *data, yaffs_ExtendedTags *tags) +int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk, + u8 * data, struct yaffs_ext_tags *tags) { - struct mtd_info *mtd = yaffs_DeviceToMtd(dev); + struct mtd_info *mtd = yaffs_dev_to_mtd(dev); #if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17)) struct mtd_oob_ops ops; #endif size_t dummy; int retval = 0; - int localData = 0; + int local_data = 0; - loff_t addr = ((loff_t) chunkInNAND) * dev->param.totalBytesPerChunk; + loff_t addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk; - yaffs_PackedTags2 pt; + struct yaffs_packed_tags2 pt; - int packed_tags_size = dev->param.noTagsECC ? sizeof(pt.t) : sizeof(pt); - void * packed_tags_ptr = dev->param.noTagsECC ? (void *) &pt.t: (void *)&pt; + int packed_tags_size = + dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt); + void *packed_tags_ptr = + dev->param.no_tags_ecc ? (void *)&pt.t : (void *)&pt; T(YAFFS_TRACE_MTD, (TSTR - ("nandmtd2_ReadChunkWithTagsFromNAND chunk %d data %p tags %p" - TENDSTR), chunkInNAND, data, tags)); + ("nandmtd2_read_chunk_tags chunk %d data %p tags %p" + TENDSTR), nand_chunk, data, tags)); - if (dev->param.inbandTags) { + if (dev->param.inband_tags) { if (!data) { - localData = 1; - data = yaffs_GetTempBuffer(dev, __LINE__); + local_data = 1; + data = yaffs_get_temp_buffer(dev, __LINE__); } - } - #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) - if (dev->param.inbandTags || (data && !tags)) - retval = mtd->read(mtd, addr, dev->param.totalBytesPerChunk, - &dummy, data); + if (dev->param.inband_tags || (data && !tags)) + retval = mtd->read(mtd, addr, dev->param.total_bytes_per_chunk, + &dummy, data); else if (tags) { ops.mode = MTD_OOB_AUTO; ops.ooblen = packed_tags_size; - ops.len = data ? dev->nDataBytesPerChunk : packed_tags_size; + ops.len = data ? dev->data_bytes_per_chunk : packed_tags_size; ops.ooboffs = 0; ops.datbuf = data; - ops.oobbuf = yaffs_DeviceToLC(dev)->spareBuffer; + ops.oobbuf = yaffs_dev_to_lc(dev)->spare_buffer; retval = mtd->read_oob(mtd, addr, &ops); } #else - if (!dev->param.inbandTags && data && tags) { + if (!dev->param.inband_tags && data && tags) { - retval = mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk, - &dummy, data, dev->spareBuffer, - NULL); + retval = mtd->read_ecc(mtd, addr, dev->data_bytes_per_chunk, + &dummy, data, dev->spare_buffer, NULL); } else { if (data) retval = - mtd->read(mtd, addr, dev->nDataBytesPerChunk, &dummy, - data); - if (!dev->param.inbandTags && tags) + mtd->read(mtd, addr, dev->data_bytes_per_chunk, + &dummy, data); + if (!dev->param.inband_tags && tags) retval = mtd->read_oob(mtd, addr, mtd->oobsize, &dummy, - dev->spareBuffer); + dev->spare_buffer); } #endif - - if (dev->param.inbandTags) { + if (dev->param.inband_tags) { if (tags) { - yaffs_PackedTags2TagsPart *pt2tp; - pt2tp = (yaffs_PackedTags2TagsPart *)&data[dev->nDataBytesPerChunk]; - yaffs_UnpackTags2TagsPart(tags, pt2tp); + struct yaffs_packed_tags2_tags_only *pt2tp; + pt2tp = + (struct yaffs_packed_tags2_tags_only *)&data[dev-> + data_bytes_per_chunk]; + yaffs_unpack_tags2_tags_only(tags, pt2tp); } } else { if (tags) { - memcpy(packed_tags_ptr, yaffs_DeviceToLC(dev)->spareBuffer, packed_tags_size); - yaffs_UnpackTags2(tags, &pt, !dev->param.noTagsECC); + memcpy(packed_tags_ptr, + yaffs_dev_to_lc(dev)->spare_buffer, + packed_tags_size); + yaffs_unpack_tags2(tags, &pt, !dev->param.no_tags_ecc); } } - if (localData) - yaffs_ReleaseTempBuffer(dev, data, __LINE__); + if (local_data) + yaffs_release_temp_buffer(dev, data, __LINE__); - if (tags && retval == -EBADMSG && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR) { - tags->eccResult = YAFFS_ECC_RESULT_UNFIXED; - dev->eccUnfixed++; + if (tags && retval == -EBADMSG + && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) { + tags->ecc_result = YAFFS_ECC_RESULT_UNFIXED; + dev->n_ecc_unfixed++; } - if(tags && retval == -EUCLEAN && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR) { - tags->eccResult = YAFFS_ECC_RESULT_FIXED; - dev->eccFixed++; + if (tags && retval == -EUCLEAN + && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) { + tags->ecc_result = YAFFS_ECC_RESULT_FIXED; + dev->n_ecc_fixed++; } if (retval == 0) return YAFFS_OK; @@ -193,17 +201,17 @@ int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND, return YAFFS_FAIL; } -int nandmtd2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo) +int nandmtd2_mark_block_bad(struct yaffs_dev *dev, int block_no) { - struct mtd_info *mtd = yaffs_DeviceToMtd(dev); + struct mtd_info *mtd = yaffs_dev_to_mtd(dev); int retval; T(YAFFS_TRACE_MTD, - (TSTR("nandmtd2_MarkNANDBlockBad %d" TENDSTR), blockNo)); + (TSTR("nandmtd2_mark_block_bad %d" TENDSTR), block_no)); retval = mtd->block_markbad(mtd, - blockNo * dev->param.nChunksPerBlock * - dev->param.totalBytesPerChunk); + block_no * dev->param.chunks_per_block * + dev->param.total_bytes_per_chunk); if (retval == 0) return YAFFS_OK; @@ -212,46 +220,41 @@ int nandmtd2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo) } -int nandmtd2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, - yaffs_BlockState *state, __u32 *sequenceNumber) +int nandmtd2_query_block(struct yaffs_dev *dev, int block_no, + enum yaffs_block_state *state, u32 * seq_number) { - struct mtd_info *mtd = yaffs_DeviceToMtd(dev); + struct mtd_info *mtd = yaffs_dev_to_mtd(dev); int retval; - T(YAFFS_TRACE_MTD, - (TSTR("nandmtd2_QueryNANDBlock %d" TENDSTR), blockNo)); + T(YAFFS_TRACE_MTD, (TSTR("nandmtd2_query_block %d" TENDSTR), block_no)); retval = mtd->block_isbad(mtd, - blockNo * dev->param.nChunksPerBlock * - dev->param.totalBytesPerChunk); + block_no * dev->param.chunks_per_block * + dev->param.total_bytes_per_chunk); if (retval) { T(YAFFS_TRACE_MTD, (TSTR("block is bad" TENDSTR))); *state = YAFFS_BLOCK_STATE_DEAD; - *sequenceNumber = 0; + *seq_number = 0; } else { - yaffs_ExtendedTags t; - nandmtd2_ReadChunkWithTagsFromNAND(dev, - blockNo * - dev->param.nChunksPerBlock, NULL, - &t); + struct yaffs_ext_tags t; + nandmtd2_read_chunk_tags(dev, block_no * + dev->param.chunks_per_block, NULL, &t); - if (t.chunkUsed) { - *sequenceNumber = t.sequenceNumber; + if (t.chunk_used) { + *seq_number = t.seq_number; *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING; } else { - *sequenceNumber = 0; + *seq_number = 0; *state = YAFFS_BLOCK_STATE_EMPTY; } } T(YAFFS_TRACE_MTD, - (TSTR("block is bad seq %d state %d" TENDSTR), *sequenceNumber, - *state)); + (TSTR("block is bad seq %d state %d" TENDSTR), *seq_number, *state)); if (retval == 0) return YAFFS_OK; else return YAFFS_FAIL; } - diff --git a/fs/yaffs2/yaffs_mtdif2.h b/fs/yaffs2/yaffs_mtdif2.h index 5691267e..d8211261 100644 --- a/fs/yaffs2/yaffs_mtdif2.h +++ b/fs/yaffs2/yaffs_mtdif2.h @@ -17,13 +17,13 @@ #define __YAFFS_MTDIF2_H__ #include "yaffs_guts.h" -int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device *dev, int chunkInNAND, - const __u8 *data, - const yaffs_ExtendedTags *tags); -int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND, - __u8 *data, yaffs_ExtendedTags *tags); -int nandmtd2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo); -int nandmtd2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, - yaffs_BlockState *state, __u32 *sequenceNumber); +int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk, + const u8 * data, + const struct yaffs_ext_tags *tags); +int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk, + u8 * data, struct yaffs_ext_tags *tags); +int nandmtd2_mark_block_bad(struct yaffs_dev *dev, int block_no); +int nandmtd2_query_block(struct yaffs_dev *dev, int block_no, + enum yaffs_block_state *state, u32 * seq_number); #endif diff --git a/fs/yaffs2/yaffs_nameval.c b/fs/yaffs2/yaffs_nameval.c index a4ed2973..d7cb72aa 100644 --- a/fs/yaffs2/yaffs_nameval.c +++ b/fs/yaffs2/yaffs_nameval.c @@ -25,118 +25,120 @@ * This code has not been tested with unicode yet. */ - #include "yaffs_nameval.h" #include "yportenv.h" - -static int nval_find(const char *xb, int xb_size, const YCHAR *name, - int *exist_size) + +static int nval_find(const char *xb, int xb_size, const YCHAR * name, + int *exist_size) { - int pos=0; + int pos = 0; int size; - memcpy(&size,xb,sizeof(int)); - while(size > 0 && (size < xb_size) && (pos + size < xb_size)){ - if(yaffs_strncmp((YCHAR *)(xb+pos+sizeof(int)),name,size) == 0){ - if(exist_size) + memcpy(&size, xb, sizeof(int)); + while (size > 0 && (size < xb_size) && (pos + size < xb_size)) { + if (yaffs_strncmp + ((YCHAR *) (xb + pos + sizeof(int)), name, size) == 0) { + if (exist_size) *exist_size = size; return pos; } pos += size; - if(pos < xb_size -sizeof(int)) - memcpy(&size,xb + pos,sizeof(int)); + if (pos < xb_size - sizeof(int)) + memcpy(&size, xb + pos, sizeof(int)); else size = 0; } - if(exist_size) + if (exist_size) *exist_size = 0; return -1; } static int nval_used(const char *xb, int xb_size) { - int pos=0; + int pos = 0; int size; - memcpy(&size,xb + pos,sizeof(int)); - while(size > 0 && (size < xb_size) && (pos + size < xb_size)){ + memcpy(&size, xb + pos, sizeof(int)); + while (size > 0 && (size < xb_size) && (pos + size < xb_size)) { pos += size; - if(pos < xb_size -sizeof(int)) - memcpy(&size,xb + pos,sizeof(int)); + if (pos < xb_size - sizeof(int)) + memcpy(&size, xb + pos, sizeof(int)); else size = 0; } return pos; } -int nval_del(char *xb, int xb_size, const YCHAR *name) +int nval_del(char *xb, int xb_size, const YCHAR * name) { - int pos = nval_find(xb, xb_size, name, NULL); + int pos = nval_find(xb, xb_size, name, NULL); int size; - - if(pos >= 0 && pos < xb_size){ + + if (pos >= 0 && pos < xb_size) { /* Find size, shift rest over this record, then zero out the rest of buffer */ - memcpy(&size,xb+pos,sizeof(int)); + memcpy(&size, xb + pos, sizeof(int)); memcpy(xb + pos, xb + pos + size, xb_size - (pos + size)); - memset(xb + (xb_size - size),0,size); + memset(xb + (xb_size - size), 0, size); return 0; } else return -ENODATA; } -int nval_set(char *xb, int xb_size, const YCHAR *name, const char *buf, int bsize, int flags) +int nval_set(char *xb, int xb_size, const YCHAR * name, const char *buf, + int bsize, int flags) { int pos; - int namelen = yaffs_strnlen(name,xb_size); + int namelen = yaffs_strnlen(name, xb_size); int reclen; int size_exist = 0; int space; int start; - pos = nval_find(xb,xb_size,name, &size_exist); + pos = nval_find(xb, xb_size, name, &size_exist); - if(flags & XATTR_CREATE && pos >= 0) + if (flags & XATTR_CREATE && pos >= 0) return -EEXIST; - if(flags & XATTR_REPLACE && pos < 0) + if (flags & XATTR_REPLACE && pos < 0) return -ENODATA; - start = nval_used(xb,xb_size); + start = nval_used(xb, xb_size); space = xb_size - start + size_exist; reclen = (sizeof(int) + namelen + 1 + bsize); - if(reclen > space) + if (reclen > space) return -ENOSPC; - if(pos >= 0){ - nval_del(xb,xb_size,name); + if (pos >= 0) { + nval_del(xb, xb_size, name); start = nval_used(xb, xb_size); } pos = start; - memcpy(xb + pos,&reclen,sizeof(int)); - pos +=sizeof(int); - yaffs_strncpy((YCHAR *)(xb + pos), name, reclen); - pos+= (namelen+1); - memcpy(xb + pos,buf,bsize); + memcpy(xb + pos, &reclen, sizeof(int)); + pos += sizeof(int); + yaffs_strncpy((YCHAR *) (xb + pos), name, reclen); + pos += (namelen + 1); + memcpy(xb + pos, buf, bsize); return 0; } -int nval_get(const char *xb, int xb_size, const YCHAR *name, char *buf, int bsize) +int nval_get(const char *xb, int xb_size, const YCHAR * name, char *buf, + int bsize) { - int pos = nval_find(xb,xb_size,name,NULL); + int pos = nval_find(xb, xb_size, name, NULL); int size; - - if(pos >= 0 && pos< xb_size){ - - memcpy(&size,xb +pos,sizeof(int)); - pos+=sizeof(int); /* advance past record length */ + + if (pos >= 0 && pos < xb_size) { + + memcpy(&size, xb + pos, sizeof(int)); + pos += sizeof(int); /* advance past record length */ size -= sizeof(int); /* Advance over name string */ - while(xb[pos] && size > 0 && pos < xb_size){ + while (xb[pos] && size > 0 && pos < xb_size) { pos++; size--; } @@ -144,13 +146,13 @@ int nval_get(const char *xb, int xb_size, const YCHAR *name, char *buf, int bsiz pos++; size--; - if(size <= bsize){ - memcpy(buf,xb + pos,size); + if (size <= bsize) { + memcpy(buf, xb + pos, size); return size; } - + } - if(pos >= 0) + if (pos >= 0) return -ERANGE; else return -ENODATA; @@ -164,33 +166,33 @@ int nval_list(const char *xb, int xb_size, char *buf, int bsize) int ncopied = 0; int filled = 0; - memcpy(&size,xb + pos,sizeof(int)); - while(size > sizeof(int) && size <= xb_size && (pos + size) < xb_size && !filled){ - pos+= sizeof(int); - size-=sizeof(int); - name_len = yaffs_strnlen((YCHAR *)(xb + pos), size); - if(ncopied + name_len + 1 < bsize){ - memcpy(buf,xb+pos,name_len * sizeof(YCHAR)); - buf+= name_len; + memcpy(&size, xb + pos, sizeof(int)); + while (size > sizeof(int) && size <= xb_size && (pos + size) < xb_size + && !filled) { + pos += sizeof(int); + size -= sizeof(int); + name_len = yaffs_strnlen((YCHAR *) (xb + pos), size); + if (ncopied + name_len + 1 < bsize) { + memcpy(buf, xb + pos, name_len * sizeof(YCHAR)); + buf += name_len; *buf = '\0'; buf++; - if(sizeof(YCHAR) > 1){ + if (sizeof(YCHAR) > 1) { *buf = '\0'; buf++; } - ncopied += (name_len+1); + ncopied += (name_len + 1); } else filled = 1; - pos+=size; - if(pos < xb_size -sizeof(int)) - memcpy(&size,xb + pos,sizeof(int)); + pos += size; + if (pos < xb_size - sizeof(int)) + memcpy(&size, xb + pos, sizeof(int)); else size = 0; } return ncopied; } - int nval_hasvalues(const char *xb, int xb_size) { return nval_used(xb, xb_size) > 0; diff --git a/fs/yaffs2/yaffs_nameval.h b/fs/yaffs2/yaffs_nameval.h index 4255f3b0..2bb02b62 100644 --- a/fs/yaffs2/yaffs_nameval.h +++ b/fs/yaffs2/yaffs_nameval.h @@ -12,14 +12,17 @@ * * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. */ + #ifndef __NAMEVAL_H__ #define __NAMEVAL_H__ #include "yportenv.h" -int nval_del(char *xb, int xb_size, const YCHAR *name); -int nval_set(char *xb, int xb_size, const YCHAR *name, const char *buf, int bsize, int flags); -int nval_get(const char *xb, int xb_size, const YCHAR *name, char *buf, int bsize); +int nval_del(char *xb, int xb_size, const YCHAR * name); +int nval_set(char *xb, int xb_size, const YCHAR * name, const char *buf, + int bsize, int flags); +int nval_get(const char *xb, int xb_size, const YCHAR * name, char *buf, + int bsize); int nval_list(const char *xb, int xb_size, char *buf, int bsize); int nval_hasvalues(const char *xb, int xb_size); #endif diff --git a/fs/yaffs2/yaffs_nand.c b/fs/yaffs2/yaffs_nand.c index 6964ad18..84ab0f02 100644 --- a/fs/yaffs2/yaffs_nand.c +++ b/fs/yaffs2/yaffs_nand.c @@ -17,124 +17,112 @@ #include "yaffs_getblockinfo.h" -int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND, - __u8 *buffer, - yaffs_ExtendedTags *tags) +int yaffs_rd_chunk_tags_nand(struct yaffs_dev *dev, int nand_chunk, + u8 * buffer, struct yaffs_ext_tags *tags) { int result; - yaffs_ExtendedTags localTags; + struct yaffs_ext_tags local_tags; - int realignedChunkInNAND = chunkInNAND - dev->chunkOffset; + int realigned_chunk = nand_chunk - dev->chunk_offset; - dev->nPageReads++; + dev->n_page_reads++; /* If there are no tags provided, use local tags to get prioritised gc working */ if (!tags) - tags = &localTags; + tags = &local_tags; - if (dev->param.readChunkWithTagsFromNAND) - result = dev->param.readChunkWithTagsFromNAND(dev, realignedChunkInNAND, buffer, - tags); + if (dev->param.read_chunk_tags_fn) + result = + dev->param.read_chunk_tags_fn(dev, realigned_chunk, buffer, + tags); else - result = yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(dev, - realignedChunkInNAND, - buffer, - tags); - if (tags && - tags->eccResult > YAFFS_ECC_RESULT_NO_ERROR) { + result = yaffs_tags_compat_rd(dev, + realigned_chunk, buffer, tags); + if (tags && tags->ecc_result > YAFFS_ECC_RESULT_NO_ERROR) { - yaffs_BlockInfo *bi; - bi = yaffs_GetBlockInfo(dev, chunkInNAND/dev->param.nChunksPerBlock); - yaffs_HandleChunkError(dev, bi); + struct yaffs_block_info *bi; + bi = yaffs_get_block_info(dev, + nand_chunk / + dev->param.chunks_per_block); + yaffs_handle_chunk_error(dev, bi); } return result; } -int yaffs_WriteChunkWithTagsToNAND(yaffs_Device *dev, - int chunkInNAND, - const __u8 *buffer, - yaffs_ExtendedTags *tags) +int yaffs_wr_chunk_tags_nand(struct yaffs_dev *dev, + int nand_chunk, + const u8 * buffer, struct yaffs_ext_tags *tags) { - dev->nPageWrites++; - - chunkInNAND -= dev->chunkOffset; + dev->n_page_writes++; + nand_chunk -= dev->chunk_offset; if (tags) { - tags->sequenceNumber = dev->sequenceNumber; - tags->chunkUsed = 1; - if (!yaffs_ValidateTags(tags)) { + tags->seq_number = dev->seq_number; + tags->chunk_used = 1; + if (!yaffs_validate_tags(tags)) { T(YAFFS_TRACE_ERROR, (TSTR("Writing uninitialised tags" TENDSTR))); YBUG(); } T(YAFFS_TRACE_WRITE, - (TSTR("Writing chunk %d tags %d %d" TENDSTR), chunkInNAND, - tags->objectId, tags->chunkId)); + (TSTR("Writing chunk %d tags %d %d" TENDSTR), nand_chunk, + tags->obj_id, tags->chunk_id)); } else { T(YAFFS_TRACE_ERROR, (TSTR("Writing with no tags" TENDSTR))); YBUG(); } - if (dev->param.writeChunkWithTagsToNAND) - return dev->param.writeChunkWithTagsToNAND(dev, chunkInNAND, buffer, - tags); + if (dev->param.write_chunk_tags_fn) + return dev->param.write_chunk_tags_fn(dev, nand_chunk, buffer, + tags); else - return yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(dev, - chunkInNAND, - buffer, - tags); + return yaffs_tags_compat_wr(dev, nand_chunk, buffer, tags); } -int yaffs_MarkBlockBad(yaffs_Device *dev, int blockNo) +int yaffs_mark_bad(struct yaffs_dev *dev, int block_no) { - blockNo -= dev->blockOffset; + block_no -= dev->block_offset; - - if (dev->param.markNANDBlockBad) - return dev->param.markNANDBlockBad(dev, blockNo); + if (dev->param.bad_block_fn) + return dev->param.bad_block_fn(dev, block_no); else - return yaffs_TagsCompatabilityMarkNANDBlockBad(dev, blockNo); + return yaffs_tags_compat_mark_bad(dev, block_no); } -int yaffs_QueryInitialBlockState(yaffs_Device *dev, - int blockNo, - yaffs_BlockState *state, - __u32 *sequenceNumber) +int yaffs_query_init_block_state(struct yaffs_dev *dev, + int block_no, + enum yaffs_block_state *state, + u32 * seq_number) { - blockNo -= dev->blockOffset; + block_no -= dev->block_offset; - if (dev->param.queryNANDBlock) - return dev->param.queryNANDBlock(dev, blockNo, state, sequenceNumber); + if (dev->param.query_block_fn) + return dev->param.query_block_fn(dev, block_no, state, + seq_number); else - return yaffs_TagsCompatabilityQueryNANDBlock(dev, blockNo, - state, - sequenceNumber); + return yaffs_tags_compat_query_block(dev, block_no, + state, seq_number); } - -int yaffs_EraseBlockInNAND(struct yaffs_DeviceStruct *dev, - int blockInNAND) +int yaffs_erase_block(struct yaffs_dev *dev, int flash_block) { int result; - blockInNAND -= dev->blockOffset; + flash_block -= dev->block_offset; - dev->nBlockErasures++; + dev->n_erasures++; - result = dev->param.eraseBlockInNAND(dev, blockInNAND); + result = dev->param.erase_fn(dev, flash_block); return result; } -int yaffs_InitialiseNAND(struct yaffs_DeviceStruct *dev) +int yaffs_init_nand(struct yaffs_dev *dev) { - if(dev->param.initialiseNAND) - return dev->param.initialiseNAND(dev); + if (dev->param.initialise_flash_fn) + return dev->param.initialise_flash_fn(dev); return YAFFS_OK; } - - - diff --git a/fs/yaffs2/yaffs_nand.h b/fs/yaffs2/yaffs_nand.h index 62a46659..543f1987 100644 --- a/fs/yaffs2/yaffs_nand.h +++ b/fs/yaffs2/yaffs_nand.h @@ -17,28 +17,22 @@ #define __YAFFS_NAND_H__ #include "yaffs_guts.h" +int yaffs_rd_chunk_tags_nand(struct yaffs_dev *dev, int nand_chunk, + u8 * buffer, struct yaffs_ext_tags *tags); +int yaffs_wr_chunk_tags_nand(struct yaffs_dev *dev, + int nand_chunk, + const u8 * buffer, struct yaffs_ext_tags *tags); -int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND, - __u8 *buffer, - yaffs_ExtendedTags *tags); +int yaffs_mark_bad(struct yaffs_dev *dev, int block_no); -int yaffs_WriteChunkWithTagsToNAND(yaffs_Device *dev, - int chunkInNAND, - const __u8 *buffer, - yaffs_ExtendedTags *tags); +int yaffs_query_init_block_state(struct yaffs_dev *dev, + int block_no, + enum yaffs_block_state *state, + unsigned *seq_number); -int yaffs_MarkBlockBad(yaffs_Device *dev, int blockNo); +int yaffs_erase_block(struct yaffs_dev *dev, int flash_block); -int yaffs_QueryInitialBlockState(yaffs_Device *dev, - int blockNo, - yaffs_BlockState *state, - unsigned *sequenceNumber); - -int yaffs_EraseBlockInNAND(struct yaffs_DeviceStruct *dev, - int blockInNAND); - -int yaffs_InitialiseNAND(struct yaffs_DeviceStruct *dev); +int yaffs_init_nand(struct yaffs_dev *dev); #endif - diff --git a/fs/yaffs2/yaffs_nandemul2k.h b/fs/yaffs2/yaffs_nandemul2k.h deleted file mode 100644 index 2f4ce97b..00000000 --- a/fs/yaffs2/yaffs_nandemul2k.h +++ /dev/null @@ -1,39 +0,0 @@ -/* - * YAFFS: Yet another Flash File System . A NAND-flash specific file system. - * - * Copyright (C) 2002-2010 Aleph One Ltd. - * for Toby Churchill Ltd and Brightstar Engineering - * - * Created by Charles Manning - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License version 2.1 as - * published by the Free Software Foundation. - * - * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. - */ - -/* Interface to emulated NAND functions (2k page size) */ - -#ifndef __YAFFS_NANDEMUL2K_H__ -#define __YAFFS_NANDEMUL2K_H__ - -#include "yaffs_guts.h" - -int nandemul2k_WriteChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev, - int chunkInNAND, const __u8 *data, - const yaffs_ExtendedTags *tags); -int nandemul2k_ReadChunkWithTagsFromNAND(struct yaffs_DeviceStruct *dev, - int chunkInNAND, __u8 *data, - yaffs_ExtendedTags *tags); -int nandemul2k_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo); -int nandemul2k_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, - yaffs_BlockState *state, __u32 *sequenceNumber); -int nandemul2k_EraseBlockInNAND(struct yaffs_DeviceStruct *dev, - int blockInNAND); -int nandemul2k_InitialiseNAND(struct yaffs_DeviceStruct *dev); -int nandemul2k_GetBytesPerChunk(void); -int nandemul2k_GetChunksPerBlock(void); -int nandemul2k_GetNumberOfBlocks(void); - -#endif diff --git a/fs/yaffs2/yaffs_packedtags1.c b/fs/yaffs2/yaffs_packedtags1.c index b2160c08..a77f0954 100644 --- a/fs/yaffs2/yaffs_packedtags1.c +++ b/fs/yaffs2/yaffs_packedtags1.c @@ -14,37 +14,40 @@ #include "yaffs_packedtags1.h" #include "yportenv.h" -void yaffs_PackTags1(yaffs_PackedTags1 *pt, const yaffs_ExtendedTags *t) +void yaffs_pack_tags1(struct yaffs_packed_tags1 *pt, + const struct yaffs_ext_tags *t) { - pt->chunkId = t->chunkId; - pt->serialNumber = t->serialNumber; - pt->byteCount = t->byteCount; - pt->objectId = t->objectId; + pt->chunk_id = t->chunk_id; + pt->serial_number = t->serial_number; + pt->n_bytes = t->n_bytes; + pt->obj_id = t->obj_id; pt->ecc = 0; - pt->deleted = (t->chunkDeleted) ? 0 : 1; - pt->unusedStuff = 0; - pt->shouldBeFF = 0xFFFFFFFF; + pt->deleted = (t->is_deleted) ? 0 : 1; + pt->unused_stuff = 0; + pt->should_be_ff = 0xFFFFFFFF; } -void yaffs_UnpackTags1(yaffs_ExtendedTags *t, const yaffs_PackedTags1 *pt) +void yaffs_unpack_tags1(struct yaffs_ext_tags *t, + const struct yaffs_packed_tags1 *pt) { - static const __u8 allFF[] = + static const u8 all_ff[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, -0xff }; + 0xff + }; - if (memcmp(allFF, pt, sizeof(yaffs_PackedTags1))) { - t->blockBad = 0; - if (pt->shouldBeFF != 0xFFFFFFFF) - t->blockBad = 1; - t->chunkUsed = 1; - t->objectId = pt->objectId; - t->chunkId = pt->chunkId; - t->byteCount = pt->byteCount; - t->eccResult = YAFFS_ECC_RESULT_NO_ERROR; - t->chunkDeleted = (pt->deleted) ? 0 : 1; - t->serialNumber = pt->serialNumber; + if (memcmp(all_ff, pt, sizeof(struct yaffs_packed_tags1))) { + t->block_bad = 0; + if (pt->should_be_ff != 0xFFFFFFFF) + t->block_bad = 1; + t->chunk_used = 1; + t->obj_id = pt->obj_id; + t->chunk_id = pt->chunk_id; + t->n_bytes = pt->n_bytes; + t->ecc_result = YAFFS_ECC_RESULT_NO_ERROR; + t->is_deleted = (pt->deleted) ? 0 : 1; + t->serial_number = pt->serial_number; } else { - memset(t, 0, sizeof(yaffs_ExtendedTags)); + memset(t, 0, sizeof(struct yaffs_ext_tags)); } } diff --git a/fs/yaffs2/yaffs_packedtags1.h b/fs/yaffs2/yaffs_packedtags1.h index b9cf1a8b..d6861ff5 100644 --- a/fs/yaffs2/yaffs_packedtags1.h +++ b/fs/yaffs2/yaffs_packedtags1.h @@ -20,18 +20,20 @@ #include "yaffs_guts.h" -typedef struct { - unsigned chunkId:20; - unsigned serialNumber:2; - unsigned byteCount:10; - unsigned objectId:18; +struct yaffs_packed_tags1 { + unsigned chunk_id:20; + unsigned serial_number:2; + unsigned n_bytes:10; + unsigned obj_id:18; unsigned ecc:12; unsigned deleted:1; - unsigned unusedStuff:1; - unsigned shouldBeFF; + unsigned unused_stuff:1; + unsigned should_be_ff; -} yaffs_PackedTags1; +}; -void yaffs_PackTags1(yaffs_PackedTags1 *pt, const yaffs_ExtendedTags *t); -void yaffs_UnpackTags1(yaffs_ExtendedTags *t, const yaffs_PackedTags1 *pt); +void yaffs_pack_tags1(struct yaffs_packed_tags1 *pt, + const struct yaffs_ext_tags *t); +void yaffs_unpack_tags1(struct yaffs_ext_tags *t, + const struct yaffs_packed_tags1 *pt); #endif diff --git a/fs/yaffs2/yaffs_packedtags2.c b/fs/yaffs2/yaffs_packedtags2.c index f8ae94cc..6c12aed2 100644 --- a/fs/yaffs2/yaffs_packedtags2.c +++ b/fs/yaffs2/yaffs_packedtags2.c @@ -25,7 +25,7 @@ * This is defined by having the EXTRA_HEADER_INFO_FLAG set. */ -/* Extra flags applied to chunkId */ +/* Extra flags applied to chunk_id */ #define EXTRA_HEADER_INFO_FLAG 0x80000000 #define EXTRA_SHRINK_FLAG 0x40000000 @@ -38,161 +38,160 @@ #define EXTRA_OBJECT_TYPE_SHIFT (28) #define EXTRA_OBJECT_TYPE_MASK ((0x0F) << EXTRA_OBJECT_TYPE_SHIFT) - -static void yaffs_DumpPackedTags2TagsPart(const yaffs_PackedTags2TagsPart *ptt) +static void yaffs_dump_packed_tags2_tags_only(const struct + yaffs_packed_tags2_tags_only *ptt) { T(YAFFS_TRACE_MTD, (TSTR("packed tags obj %d chunk %d byte %d seq %d" TENDSTR), - ptt->objectId, ptt->chunkId, ptt->byteCount, - ptt->sequenceNumber)); -} -static void yaffs_DumpPackedTags2(const yaffs_PackedTags2 *pt) -{ - yaffs_DumpPackedTags2TagsPart(&pt->t); + ptt->obj_id, ptt->chunk_id, ptt->n_bytes, ptt->seq_number)); } -static void yaffs_DumpTags2(const yaffs_ExtendedTags *t) +static void yaffs_dump_packed_tags2(const struct yaffs_packed_tags2 *pt) +{ + yaffs_dump_packed_tags2_tags_only(&pt->t); +} + +static void yaffs_dump_tags2(const struct yaffs_ext_tags *t) { T(YAFFS_TRACE_MTD, (TSTR ("ext.tags eccres %d blkbad %d chused %d obj %d chunk%d byte %d del %d ser %d seq %d" - TENDSTR), t->eccResult, t->blockBad, t->chunkUsed, t->objectId, - t->chunkId, t->byteCount, t->chunkDeleted, t->serialNumber, - t->sequenceNumber)); + TENDSTR), t->ecc_result, t->block_bad, t->chunk_used, t->obj_id, + t->chunk_id, t->n_bytes, t->is_deleted, t->serial_number, + t->seq_number)); } -void yaffs_PackTags2TagsPart(yaffs_PackedTags2TagsPart *ptt, - const yaffs_ExtendedTags *t) +void yaffs_pack_tags2_tags_only(struct yaffs_packed_tags2_tags_only *ptt, + const struct yaffs_ext_tags *t) { - ptt->chunkId = t->chunkId; - ptt->sequenceNumber = t->sequenceNumber; - ptt->byteCount = t->byteCount; - ptt->objectId = t->objectId; + ptt->chunk_id = t->chunk_id; + ptt->seq_number = t->seq_number; + ptt->n_bytes = t->n_bytes; + ptt->obj_id = t->obj_id; - if (t->chunkId == 0 && t->extraHeaderInfoAvailable) { + if (t->chunk_id == 0 && t->extra_available) { /* Store the extra header info instead */ - /* We save the parent object in the chunkId */ - ptt->chunkId = EXTRA_HEADER_INFO_FLAG - | t->extraParentObjectId; - if (t->extraIsShrinkHeader) - ptt->chunkId |= EXTRA_SHRINK_FLAG; - if (t->extraShadows) - ptt->chunkId |= EXTRA_SHADOWS_FLAG; + /* We save the parent object in the chunk_id */ + ptt->chunk_id = EXTRA_HEADER_INFO_FLAG | t->extra_parent_id; + if (t->extra_is_shrink) + ptt->chunk_id |= EXTRA_SHRINK_FLAG; + if (t->extra_shadows) + ptt->chunk_id |= EXTRA_SHADOWS_FLAG; - ptt->objectId &= ~EXTRA_OBJECT_TYPE_MASK; - ptt->objectId |= - (t->extraObjectType << EXTRA_OBJECT_TYPE_SHIFT); + ptt->obj_id &= ~EXTRA_OBJECT_TYPE_MASK; + ptt->obj_id |= (t->extra_obj_type << EXTRA_OBJECT_TYPE_SHIFT); - if (t->extraObjectType == YAFFS_OBJECT_TYPE_HARDLINK) - ptt->byteCount = t->extraEquivalentObjectId; - else if (t->extraObjectType == YAFFS_OBJECT_TYPE_FILE) - ptt->byteCount = t->extraFileLength; + if (t->extra_obj_type == YAFFS_OBJECT_TYPE_HARDLINK) + ptt->n_bytes = t->extra_equiv_id; + else if (t->extra_obj_type == YAFFS_OBJECT_TYPE_FILE) + ptt->n_bytes = t->extra_length; else - ptt->byteCount = 0; + ptt->n_bytes = 0; } - yaffs_DumpPackedTags2TagsPart(ptt); - yaffs_DumpTags2(t); + yaffs_dump_packed_tags2_tags_only(ptt); + yaffs_dump_tags2(t); } - -void yaffs_PackTags2(yaffs_PackedTags2 *pt, const yaffs_ExtendedTags *t, int tagsECC) +void yaffs_pack_tags2(struct yaffs_packed_tags2 *pt, + const struct yaffs_ext_tags *t, int tags_ecc) { - yaffs_PackTags2TagsPart(&pt->t, t); + yaffs_pack_tags2_tags_only(&pt->t, t); - if(tagsECC) - yaffs_ECCCalculateOther((unsigned char *)&pt->t, - sizeof(yaffs_PackedTags2TagsPart), - &pt->ecc); + if (tags_ecc) + yaffs_ecc_calc_other((unsigned char *)&pt->t, + sizeof(struct + yaffs_packed_tags2_tags_only), + &pt->ecc); } - -void yaffs_UnpackTags2TagsPart(yaffs_ExtendedTags *t, - yaffs_PackedTags2TagsPart *ptt) +void yaffs_unpack_tags2_tags_only(struct yaffs_ext_tags *t, + struct yaffs_packed_tags2_tags_only *ptt) { - memset(t, 0, sizeof(yaffs_ExtendedTags)); + memset(t, 0, sizeof(struct yaffs_ext_tags)); - yaffs_InitialiseTags(t); + yaffs_init_tags(t); - if (ptt->sequenceNumber != 0xFFFFFFFF) { - t->blockBad = 0; - t->chunkUsed = 1; - t->objectId = ptt->objectId; - t->chunkId = ptt->chunkId; - t->byteCount = ptt->byteCount; - t->chunkDeleted = 0; - t->serialNumber = 0; - t->sequenceNumber = ptt->sequenceNumber; + if (ptt->seq_number != 0xFFFFFFFF) { + t->block_bad = 0; + t->chunk_used = 1; + t->obj_id = ptt->obj_id; + t->chunk_id = ptt->chunk_id; + t->n_bytes = ptt->n_bytes; + t->is_deleted = 0; + t->serial_number = 0; + t->seq_number = ptt->seq_number; /* Do extra header info stuff */ - if (ptt->chunkId & EXTRA_HEADER_INFO_FLAG) { - t->chunkId = 0; - t->byteCount = 0; + if (ptt->chunk_id & EXTRA_HEADER_INFO_FLAG) { + t->chunk_id = 0; + t->n_bytes = 0; - t->extraHeaderInfoAvailable = 1; - t->extraParentObjectId = - ptt->chunkId & (~(ALL_EXTRA_FLAGS)); - t->extraIsShrinkHeader = - (ptt->chunkId & EXTRA_SHRINK_FLAG) ? 1 : 0; - t->extraShadows = - (ptt->chunkId & EXTRA_SHADOWS_FLAG) ? 1 : 0; - t->extraObjectType = - ptt->objectId >> EXTRA_OBJECT_TYPE_SHIFT; - t->objectId &= ~EXTRA_OBJECT_TYPE_MASK; + t->extra_available = 1; + t->extra_parent_id = + ptt->chunk_id & (~(ALL_EXTRA_FLAGS)); + t->extra_is_shrink = + (ptt->chunk_id & EXTRA_SHRINK_FLAG) ? 1 : 0; + t->extra_shadows = + (ptt->chunk_id & EXTRA_SHADOWS_FLAG) ? 1 : 0; + t->extra_obj_type = + ptt->obj_id >> EXTRA_OBJECT_TYPE_SHIFT; + t->obj_id &= ~EXTRA_OBJECT_TYPE_MASK; - if (t->extraObjectType == YAFFS_OBJECT_TYPE_HARDLINK) - t->extraEquivalentObjectId = ptt->byteCount; + if (t->extra_obj_type == YAFFS_OBJECT_TYPE_HARDLINK) + t->extra_equiv_id = ptt->n_bytes; else - t->extraFileLength = ptt->byteCount; + t->extra_length = ptt->n_bytes; } } - yaffs_DumpPackedTags2TagsPart(ptt); - yaffs_DumpTags2(t); + yaffs_dump_packed_tags2_tags_only(ptt); + yaffs_dump_tags2(t); } - -void yaffs_UnpackTags2(yaffs_ExtendedTags *t, yaffs_PackedTags2 *pt, int tagsECC) +void yaffs_unpack_tags2(struct yaffs_ext_tags *t, struct yaffs_packed_tags2 *pt, + int tags_ecc) { - yaffs_ECCResult eccResult = YAFFS_ECC_RESULT_NO_ERROR; + enum yaffs_ecc_result ecc_result = YAFFS_ECC_RESULT_NO_ERROR; - if (pt->t.sequenceNumber != 0xFFFFFFFF && - tagsECC){ + if (pt->t.seq_number != 0xFFFFFFFF && tags_ecc) { /* Chunk is in use and we need to do ECC */ - - yaffs_ECCOther ecc; + + struct yaffs_ecc_other ecc; int result; - yaffs_ECCCalculateOther((unsigned char *)&pt->t, - sizeof(yaffs_PackedTags2TagsPart), - &ecc); - result = yaffs_ECCCorrectOther((unsigned char *)&pt->t, - sizeof(yaffs_PackedTags2TagsPart), - &pt->ecc, &ecc); + yaffs_ecc_calc_other((unsigned char *)&pt->t, + sizeof(struct + yaffs_packed_tags2_tags_only), + &ecc); + result = + yaffs_ecc_correct_other((unsigned char *)&pt->t, + sizeof(struct + yaffs_packed_tags2_tags_only), + &pt->ecc, &ecc); switch (result) { - case 0: - eccResult = YAFFS_ECC_RESULT_NO_ERROR; - break; - case 1: - eccResult = YAFFS_ECC_RESULT_FIXED; - break; - case -1: - eccResult = YAFFS_ECC_RESULT_UNFIXED; - break; - default: - eccResult = YAFFS_ECC_RESULT_UNKNOWN; + case 0: + ecc_result = YAFFS_ECC_RESULT_NO_ERROR; + break; + case 1: + ecc_result = YAFFS_ECC_RESULT_FIXED; + break; + case -1: + ecc_result = YAFFS_ECC_RESULT_UNFIXED; + break; + default: + ecc_result = YAFFS_ECC_RESULT_UNKNOWN; } } - yaffs_UnpackTags2TagsPart(t, &pt->t); + yaffs_unpack_tags2_tags_only(t, &pt->t); - t->eccResult = eccResult; + t->ecc_result = ecc_result; - yaffs_DumpPackedTags2(pt); - yaffs_DumpTags2(t); + yaffs_dump_packed_tags2(pt); + yaffs_dump_tags2(t); } - diff --git a/fs/yaffs2/yaffs_packedtags2.h b/fs/yaffs2/yaffs_packedtags2.h index c132a98c..f3296697 100644 --- a/fs/yaffs2/yaffs_packedtags2.h +++ b/fs/yaffs2/yaffs_packedtags2.h @@ -21,23 +21,27 @@ #include "yaffs_guts.h" #include "yaffs_ecc.h" -typedef struct { - unsigned sequenceNumber; - unsigned objectId; - unsigned chunkId; - unsigned byteCount; -} yaffs_PackedTags2TagsPart; +struct yaffs_packed_tags2_tags_only { + unsigned seq_number; + unsigned obj_id; + unsigned chunk_id; + unsigned n_bytes; +}; -typedef struct { - yaffs_PackedTags2TagsPart t; - yaffs_ECCOther ecc; -} yaffs_PackedTags2; +struct yaffs_packed_tags2 { + struct yaffs_packed_tags2_tags_only t; + struct yaffs_ecc_other ecc; +}; /* Full packed tags with ECC, used for oob tags */ -void yaffs_PackTags2(yaffs_PackedTags2 *pt, const yaffs_ExtendedTags *t, int tagsECC); -void yaffs_UnpackTags2(yaffs_ExtendedTags *t, yaffs_PackedTags2 *pt, int tagsECC); +void yaffs_pack_tags2(struct yaffs_packed_tags2 *pt, + const struct yaffs_ext_tags *t, int tags_ecc); +void yaffs_unpack_tags2(struct yaffs_ext_tags *t, struct yaffs_packed_tags2 *pt, + int tags_ecc); /* Only the tags part (no ECC for use with inband tags */ -void yaffs_PackTags2TagsPart(yaffs_PackedTags2TagsPart *pt, const yaffs_ExtendedTags *t); -void yaffs_UnpackTags2TagsPart(yaffs_ExtendedTags *t, yaffs_PackedTags2TagsPart *pt); +void yaffs_pack_tags2_tags_only(struct yaffs_packed_tags2_tags_only *pt, + const struct yaffs_ext_tags *t); +void yaffs_unpack_tags2_tags_only(struct yaffs_ext_tags *t, + struct yaffs_packed_tags2_tags_only *pt); #endif diff --git a/fs/yaffs2/yaffs_qsort.c b/fs/yaffs2/yaffs_qsort.c deleted file mode 100644 index 187519fb..00000000 --- a/fs/yaffs2/yaffs_qsort.c +++ /dev/null @@ -1,163 +0,0 @@ -/* - * Copyright (c) 1992, 1993 - * The Regents of the University of California. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * 3. Neither the name of the University nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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. - */ - -#include "yportenv.h" -/* #include */ - -/* - * Qsort routine from Bentley & McIlroy's "Engineering a Sort Function". - */ -#define swapcode(TYPE, parmi, parmj, n) do { \ - long i = (n) / sizeof (TYPE); \ - register TYPE *pi = (TYPE *) (parmi); \ - register TYPE *pj = (TYPE *) (parmj); \ - do { \ - register TYPE t = *pi; \ - *pi++ = *pj; \ - *pj++ = t; \ - } while (--i > 0); \ -} while (0) - -#define SWAPINIT(a, es) swaptype = ((char *)a - (char *)0) % sizeof(long) || \ - es % sizeof(long) ? 2 : es == sizeof(long) ? 0 : 1; - -static __inline void -swapfunc(char *a, char *b, int n, int swaptype) -{ - if (swaptype <= 1) - swapcode(long, a, b, n); - else - swapcode(char, a, b, n); -} - -#define yswap(a, b) do { \ - if (swaptype == 0) { \ - long t = *(long *)(a); \ - *(long *)(a) = *(long *)(b); \ - *(long *)(b) = t; \ - } else \ - swapfunc(a, b, es, swaptype); \ -} while (0) - -#define vecswap(a, b, n) if ((n) > 0) swapfunc(a, b, n, swaptype) - -static __inline char * -med3(char *a, char *b, char *c, int (*cmp)(const void *, const void *)) -{ - return cmp(a, b) < 0 ? - (cmp(b, c) < 0 ? b : (cmp(a, c) < 0 ? c : a)) - : (cmp(b, c) > 0 ? b : (cmp(a, c) < 0 ? a : c)); -} - -#ifndef min -#define min(a, b) (((a) < (b)) ? (a) : (b)) -#endif - -void -yaffs_qsort(void *aa, size_t n, size_t es, - int (*cmp)(const void *, const void *)) -{ - char *pa, *pb, *pc, *pd, *pl, *pm, *pn; - int d, r, swaptype, swap_cnt; - register char *a = aa; - -loop: SWAPINIT(a, es); - swap_cnt = 0; - if (n < 7) { - for (pm = (char *)a + es; pm < (char *) a + n * es; pm += es) - for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0; - pl -= es) - yswap(pl, pl - es); - return; - } - pm = (char *)a + (n / 2) * es; - if (n > 7) { - pl = (char *)a; - pn = (char *)a + (n - 1) * es; - if (n > 40) { - d = (n / 8) * es; - pl = med3(pl, pl + d, pl + 2 * d, cmp); - pm = med3(pm - d, pm, pm + d, cmp); - pn = med3(pn - 2 * d, pn - d, pn, cmp); - } - pm = med3(pl, pm, pn, cmp); - } - yswap(a, pm); - pa = pb = (char *)a + es; - - pc = pd = (char *)a + (n - 1) * es; - for (;;) { - while (pb <= pc && (r = cmp(pb, a)) <= 0) { - if (r == 0) { - swap_cnt = 1; - yswap(pa, pb); - pa += es; - } - pb += es; - } - while (pb <= pc && (r = cmp(pc, a)) >= 0) { - if (r == 0) { - swap_cnt = 1; - yswap(pc, pd); - pd -= es; - } - pc -= es; - } - if (pb > pc) - break; - yswap(pb, pc); - swap_cnt = 1; - pb += es; - pc -= es; - } - if (swap_cnt == 0) { /* Switch to insertion sort */ - for (pm = (char *) a + es; pm < (char *) a + n * es; pm += es) - for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0; - pl -= es) - yswap(pl, pl - es); - return; - } - - pn = (char *)a + n * es; - r = min(pa - (char *)a, pb - pa); - vecswap(a, pb - r, r); - r = min((long)(pd - pc), (long)(pn - pd - es)); - vecswap(pb, pn - r, r); - r = pb - pa; - if (r > es) - yaffs_qsort(a, r / es, es, cmp); - r = pd - pc; - if (r > es) { - /* Iterate rather than recurse to save stack space */ - a = pn - r; - n = r / es; - goto loop; - } -/* yaffs_qsort(pn - r, r / es, es, cmp);*/ -} diff --git a/fs/yaffs2/yaffs_tagscompat.c b/fs/yaffs2/yaffs_tagscompat.c index e9ac51d7..3a9a157e 100644 --- a/fs/yaffs2/yaffs_tagscompat.c +++ b/fs/yaffs2/yaffs_tagscompat.c @@ -17,18 +17,9 @@ #include "yaffs_getblockinfo.h" #include "yaffs_trace.h" -static void yaffs_HandleReadDataError(yaffs_Device *dev, int chunkInNAND); -#ifdef NOTYET -static void yaffs_CheckWrittenBlock(yaffs_Device *dev, int chunkInNAND); -static void yaffs_HandleWriteChunkOk(yaffs_Device *dev, int chunkInNAND, - const __u8 *data, - const yaffs_Spare *spare); -static void yaffs_HandleUpdateChunk(yaffs_Device *dev, int chunkInNAND, - const yaffs_Spare *spare); -static void yaffs_HandleWriteChunkError(yaffs_Device *dev, int chunkInNAND); -#endif +static void yaffs_handle_rd_data_error(struct yaffs_dev *dev, int nand_chunk); -static const char yaffs_countBitsTable[256] = { +static const char yaffs_count_bits_table[256] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, @@ -47,26 +38,26 @@ static const char yaffs_countBitsTable[256] = { 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8 }; -int yaffs_CountBits(__u8 x) +int yaffs_count_bits(u8 x) { - int retVal; - retVal = yaffs_countBitsTable[x]; - return retVal; + int ret_val; + ret_val = yaffs_count_bits_table[x]; + return ret_val; } /********** Tags ECC calculations *********/ -void yaffs_CalcECC(const __u8 *data, yaffs_Spare *spare) +void yaffs_calc_ecc(const u8 * data, struct yaffs_spare *spare) { - yaffs_ECCCalculate(data, spare->ecc1); - yaffs_ECCCalculate(&data[256], spare->ecc2); + yaffs_ecc_cacl(data, spare->ecc1); + yaffs_ecc_cacl(&data[256], spare->ecc2); } -void yaffs_CalcTagsECC(yaffs_Tags *tags) +void yaffs_calc_tags_ecc(struct yaffs_tags *tags) { /* Calculate an ecc */ - unsigned char *b = ((yaffs_TagsUnion *) tags)->asBytes; + unsigned char *b = ((union yaffs_tags_union *)tags)->as_bytes; unsigned i, j; unsigned ecc = 0; unsigned bit = 0; @@ -85,24 +76,24 @@ void yaffs_CalcTagsECC(yaffs_Tags *tags) } -int yaffs_CheckECCOnTags(yaffs_Tags *tags) +int yaffs_check_tags_ecc(struct yaffs_tags *tags) { unsigned ecc = tags->ecc; - yaffs_CalcTagsECC(tags); + yaffs_calc_tags_ecc(tags); ecc ^= tags->ecc; if (ecc && ecc <= 64) { /* TODO: Handle the failure better. Retire? */ - unsigned char *b = ((yaffs_TagsUnion *) tags)->asBytes; + unsigned char *b = ((union yaffs_tags_union *)tags)->as_bytes; ecc--; b[ecc / 8] ^= (1 << (ecc & 7)); /* Now recvalc the ecc */ - yaffs_CalcTagsECC(tags); + yaffs_calc_tags_ecc(tags); return 1; /* recovered error */ } else if (ecc) { @@ -116,227 +107,205 @@ int yaffs_CheckECCOnTags(yaffs_Tags *tags) /********** Tags **********/ -static void yaffs_LoadTagsIntoSpare(yaffs_Spare *sparePtr, - yaffs_Tags *tagsPtr) +static void yaffs_load_tags_to_spare(struct yaffs_spare *spare_ptr, + struct yaffs_tags *tags_ptr) { - yaffs_TagsUnion *tu = (yaffs_TagsUnion *) tagsPtr; + union yaffs_tags_union *tu = (union yaffs_tags_union *)tags_ptr; - yaffs_CalcTagsECC(tagsPtr); + yaffs_calc_tags_ecc(tags_ptr); - sparePtr->tagByte0 = tu->asBytes[0]; - sparePtr->tagByte1 = tu->asBytes[1]; - sparePtr->tagByte2 = tu->asBytes[2]; - sparePtr->tagByte3 = tu->asBytes[3]; - sparePtr->tagByte4 = tu->asBytes[4]; - sparePtr->tagByte5 = tu->asBytes[5]; - sparePtr->tagByte6 = tu->asBytes[6]; - sparePtr->tagByte7 = tu->asBytes[7]; + spare_ptr->tb0 = tu->as_bytes[0]; + spare_ptr->tb1 = tu->as_bytes[1]; + spare_ptr->tb2 = tu->as_bytes[2]; + spare_ptr->tb3 = tu->as_bytes[3]; + spare_ptr->tb4 = tu->as_bytes[4]; + spare_ptr->tb5 = tu->as_bytes[5]; + spare_ptr->tb6 = tu->as_bytes[6]; + spare_ptr->tb7 = tu->as_bytes[7]; } -static void yaffs_GetTagsFromSpare(yaffs_Device *dev, yaffs_Spare *sparePtr, - yaffs_Tags *tagsPtr) +static void yaffs_get_tags_from_spare(struct yaffs_dev *dev, + struct yaffs_spare *spare_ptr, + struct yaffs_tags *tags_ptr) { - yaffs_TagsUnion *tu = (yaffs_TagsUnion *) tagsPtr; + union yaffs_tags_union *tu = (union yaffs_tags_union *)tags_ptr; int result; - tu->asBytes[0] = sparePtr->tagByte0; - tu->asBytes[1] = sparePtr->tagByte1; - tu->asBytes[2] = sparePtr->tagByte2; - tu->asBytes[3] = sparePtr->tagByte3; - tu->asBytes[4] = sparePtr->tagByte4; - tu->asBytes[5] = sparePtr->tagByte5; - tu->asBytes[6] = sparePtr->tagByte6; - tu->asBytes[7] = sparePtr->tagByte7; + tu->as_bytes[0] = spare_ptr->tb0; + tu->as_bytes[1] = spare_ptr->tb1; + tu->as_bytes[2] = spare_ptr->tb2; + tu->as_bytes[3] = spare_ptr->tb3; + tu->as_bytes[4] = spare_ptr->tb4; + tu->as_bytes[5] = spare_ptr->tb5; + tu->as_bytes[6] = spare_ptr->tb6; + tu->as_bytes[7] = spare_ptr->tb7; - result = yaffs_CheckECCOnTags(tagsPtr); + result = yaffs_check_tags_ecc(tags_ptr); if (result > 0) - dev->tagsEccFixed++; + dev->n_tags_ecc_fixed++; else if (result < 0) - dev->tagsEccUnfixed++; + dev->n_tags_ecc_unfixed++; } -static void yaffs_SpareInitialise(yaffs_Spare *spare) +static void yaffs_spare_init(struct yaffs_spare *spare) { - memset(spare, 0xFF, sizeof(yaffs_Spare)); + memset(spare, 0xFF, sizeof(struct yaffs_spare)); } -static int yaffs_WriteChunkToNAND(struct yaffs_DeviceStruct *dev, - int chunkInNAND, const __u8 *data, - yaffs_Spare *spare) +static int yaffs_wr_nand(struct yaffs_dev *dev, + int nand_chunk, const u8 * data, + struct yaffs_spare *spare) { - if (chunkInNAND < dev->param.startBlock * dev->param.nChunksPerBlock) { + if (nand_chunk < dev->param.start_block * dev->param.chunks_per_block) { T(YAFFS_TRACE_ERROR, (TSTR("**>> yaffs chunk %d is not valid" TENDSTR), - chunkInNAND)); + nand_chunk)); return YAFFS_FAIL; } - return dev->param.writeChunkToNAND(dev, chunkInNAND, data, spare); + return dev->param.write_chunk_fn(dev, nand_chunk, data, spare); } -static int yaffs_ReadChunkFromNAND(struct yaffs_DeviceStruct *dev, - int chunkInNAND, - __u8 *data, - yaffs_Spare *spare, - yaffs_ECCResult *eccResult, - int doErrorCorrection) +static int yaffs_rd_chunk_nand(struct yaffs_dev *dev, + int nand_chunk, + u8 * data, + struct yaffs_spare *spare, + enum yaffs_ecc_result *ecc_result, + int correct_errors) { - int retVal; - yaffs_Spare localSpare; + int ret_val; + struct yaffs_spare local_spare; if (!spare && data) { /* If we don't have a real spare, then we use a local one. */ /* Need this for the calculation of the ecc */ - spare = &localSpare; + spare = &local_spare; } - if (!dev->param.useNANDECC) { - retVal = dev->param.readChunkFromNAND(dev, chunkInNAND, data, spare); - if (data && doErrorCorrection) { + if (!dev->param.use_nand_ecc) { + ret_val = + dev->param.read_chunk_fn(dev, nand_chunk, data, spare); + if (data && correct_errors) { /* Do ECC correction */ /* Todo handle any errors */ - int eccResult1, eccResult2; - __u8 calcEcc[3]; + int ecc_result1, ecc_result2; + u8 calc_ecc[3]; - yaffs_ECCCalculate(data, calcEcc); - eccResult1 = - yaffs_ECCCorrect(data, spare->ecc1, calcEcc); - yaffs_ECCCalculate(&data[256], calcEcc); - eccResult2 = - yaffs_ECCCorrect(&data[256], spare->ecc2, calcEcc); + yaffs_ecc_cacl(data, calc_ecc); + ecc_result1 = + yaffs_ecc_correct(data, spare->ecc1, calc_ecc); + yaffs_ecc_cacl(&data[256], calc_ecc); + ecc_result2 = + yaffs_ecc_correct(&data[256], spare->ecc2, + calc_ecc); - if (eccResult1 > 0) { + if (ecc_result1 > 0) { T(YAFFS_TRACE_ERROR, (TSTR ("**>>yaffs ecc error fix performed on chunk %d:0" - TENDSTR), chunkInNAND)); - dev->eccFixed++; - } else if (eccResult1 < 0) { + TENDSTR), nand_chunk)); + dev->n_ecc_fixed++; + } else if (ecc_result1 < 0) { T(YAFFS_TRACE_ERROR, (TSTR ("**>>yaffs ecc error unfixed on chunk %d:0" - TENDSTR), chunkInNAND)); - dev->eccUnfixed++; + TENDSTR), nand_chunk)); + dev->n_ecc_unfixed++; } - if (eccResult2 > 0) { + if (ecc_result2 > 0) { T(YAFFS_TRACE_ERROR, (TSTR ("**>>yaffs ecc error fix performed on chunk %d:1" - TENDSTR), chunkInNAND)); - dev->eccFixed++; - } else if (eccResult2 < 0) { + TENDSTR), nand_chunk)); + dev->n_ecc_fixed++; + } else if (ecc_result2 < 0) { T(YAFFS_TRACE_ERROR, (TSTR ("**>>yaffs ecc error unfixed on chunk %d:1" - TENDSTR), chunkInNAND)); - dev->eccUnfixed++; + TENDSTR), nand_chunk)); + dev->n_ecc_unfixed++; } - if (eccResult1 || eccResult2) { + if (ecc_result1 || ecc_result2) { /* We had a data problem on this page */ - yaffs_HandleReadDataError(dev, chunkInNAND); + yaffs_handle_rd_data_error(dev, nand_chunk); } - if (eccResult1 < 0 || eccResult2 < 0) - *eccResult = YAFFS_ECC_RESULT_UNFIXED; - else if (eccResult1 > 0 || eccResult2 > 0) - *eccResult = YAFFS_ECC_RESULT_FIXED; + if (ecc_result1 < 0 || ecc_result2 < 0) + *ecc_result = YAFFS_ECC_RESULT_UNFIXED; + else if (ecc_result1 > 0 || ecc_result2 > 0) + *ecc_result = YAFFS_ECC_RESULT_FIXED; else - *eccResult = YAFFS_ECC_RESULT_NO_ERROR; + *ecc_result = YAFFS_ECC_RESULT_NO_ERROR; } } else { /* Must allocate enough memory for spare+2*sizeof(int) */ /* for ecc results from device. */ - struct yaffs_NANDSpare nspare; + struct yaffs_nand_spare nspare; memset(&nspare, 0, sizeof(nspare)); - retVal = dev->param.readChunkFromNAND(dev, chunkInNAND, data, - (yaffs_Spare *) &nspare); - memcpy(spare, &nspare, sizeof(yaffs_Spare)); - if (data && doErrorCorrection) { + ret_val = dev->param.read_chunk_fn(dev, nand_chunk, data, + (struct yaffs_spare *) + &nspare); + memcpy(spare, &nspare, sizeof(struct yaffs_spare)); + if (data && correct_errors) { if (nspare.eccres1 > 0) { T(YAFFS_TRACE_ERROR, (TSTR ("**>>mtd ecc error fix performed on chunk %d:0" - TENDSTR), chunkInNAND)); + TENDSTR), nand_chunk)); } else if (nspare.eccres1 < 0) { T(YAFFS_TRACE_ERROR, (TSTR ("**>>mtd ecc error unfixed on chunk %d:0" - TENDSTR), chunkInNAND)); + TENDSTR), nand_chunk)); } if (nspare.eccres2 > 0) { T(YAFFS_TRACE_ERROR, (TSTR ("**>>mtd ecc error fix performed on chunk %d:1" - TENDSTR), chunkInNAND)); + TENDSTR), nand_chunk)); } else if (nspare.eccres2 < 0) { T(YAFFS_TRACE_ERROR, (TSTR ("**>>mtd ecc error unfixed on chunk %d:1" - TENDSTR), chunkInNAND)); + TENDSTR), nand_chunk)); } if (nspare.eccres1 || nspare.eccres2) { /* We had a data problem on this page */ - yaffs_HandleReadDataError(dev, chunkInNAND); + yaffs_handle_rd_data_error(dev, nand_chunk); } if (nspare.eccres1 < 0 || nspare.eccres2 < 0) - *eccResult = YAFFS_ECC_RESULT_UNFIXED; + *ecc_result = YAFFS_ECC_RESULT_UNFIXED; else if (nspare.eccres1 > 0 || nspare.eccres2 > 0) - *eccResult = YAFFS_ECC_RESULT_FIXED; + *ecc_result = YAFFS_ECC_RESULT_FIXED; else - *eccResult = YAFFS_ECC_RESULT_NO_ERROR; + *ecc_result = YAFFS_ECC_RESULT_NO_ERROR; } } - return retVal; + return ret_val; } -#ifdef NOTYET -static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev, - int chunkInNAND) -{ - static int init; - static __u8 cmpbuf[YAFFS_BYTES_PER_CHUNK]; - static __u8 data[YAFFS_BYTES_PER_CHUNK]; - /* Might as well always allocate the larger size for */ - /* dev->param.useNANDECC == true; */ - static __u8 spare[sizeof(struct yaffs_NANDSpare)]; - - dev->param.readChunkFromNAND(dev, chunkInNAND, data, (yaffs_Spare *) spare); - - if (!init) { - memset(cmpbuf, 0xff, YAFFS_BYTES_PER_CHUNK); - init = 1; - } - - if (memcmp(cmpbuf, data, YAFFS_BYTES_PER_CHUNK)) - return YAFFS_FAIL; - if (memcmp(cmpbuf, spare, 16)) - return YAFFS_FAIL; - - return YAFFS_OK; - -} -#endif - /* * Functions for robustisizing */ -static void yaffs_HandleReadDataError(yaffs_Device *dev, int chunkInNAND) +static void yaffs_handle_rd_data_error(struct yaffs_dev *dev, int nand_chunk) { - int blockInNAND = chunkInNAND / dev->param.nChunksPerBlock; + int flash_block = nand_chunk / dev->param.chunks_per_block; /* Mark the block for retirement */ - yaffs_GetBlockInfo(dev, blockInNAND + dev->blockOffset)->needsRetiring = 1; + yaffs_get_block_info(dev, + flash_block + dev->block_offset)->needs_retiring = + 1; T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, - (TSTR("**>>Block %d marked for retirement" TENDSTR), blockInNAND)); + (TSTR("**>>Block %d marked for retirement" TENDSTR), flash_block)); /* TODO: * Just do a garbage collection on the affected block @@ -345,138 +314,85 @@ static void yaffs_HandleReadDataError(yaffs_Device *dev, int chunkInNAND) */ } -#ifdef NOTYET -static void yaffs_CheckWrittenBlock(yaffs_Device *dev, int chunkInNAND) +int yaffs_tags_compat_wr(struct yaffs_dev *dev, + int nand_chunk, + const u8 * data, const struct yaffs_ext_tags *ext_tags) { -} + struct yaffs_spare spare; + struct yaffs_tags tags; -static void yaffs_HandleWriteChunkOk(yaffs_Device *dev, int chunkInNAND, - const __u8 *data, - const yaffs_Spare *spare) -{ -} + yaffs_spare_init(&spare); -static void yaffs_HandleUpdateChunk(yaffs_Device *dev, int chunkInNAND, - const yaffs_Spare *spare) -{ -} - -static void yaffs_HandleWriteChunkError(yaffs_Device *dev, int chunkInNAND) -{ - int blockInNAND = chunkInNAND / dev->param.nChunksPerBlock; - - /* Mark the block for retirement */ - yaffs_GetBlockInfo(dev, blockInNAND)->needsRetiring = 1; - /* Delete the chunk */ - yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__); -} - -static int yaffs_VerifyCompare(const __u8 *d0, const __u8 *d1, - const yaffs_Spare *s0, const yaffs_Spare *s1) -{ - - if (memcmp(d0, d1, YAFFS_BYTES_PER_CHUNK) != 0 || - s0->tagByte0 != s1->tagByte0 || - s0->tagByte1 != s1->tagByte1 || - s0->tagByte2 != s1->tagByte2 || - s0->tagByte3 != s1->tagByte3 || - s0->tagByte4 != s1->tagByte4 || - s0->tagByte5 != s1->tagByte5 || - s0->tagByte6 != s1->tagByte6 || - s0->tagByte7 != s1->tagByte7 || - s0->ecc1[0] != s1->ecc1[0] || - s0->ecc1[1] != s1->ecc1[1] || - s0->ecc1[2] != s1->ecc1[2] || - s0->ecc2[0] != s1->ecc2[0] || - s0->ecc2[1] != s1->ecc2[1] || s0->ecc2[2] != s1->ecc2[2]) { - return 0; - } - - return 1; -} -#endif /* NOTYET */ - -int yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(yaffs_Device *dev, - int chunkInNAND, - const __u8 *data, - const yaffs_ExtendedTags *eTags) -{ - yaffs_Spare spare; - yaffs_Tags tags; - - yaffs_SpareInitialise(&spare); - - if (eTags->chunkDeleted) - spare.pageStatus = 0; + if (ext_tags->is_deleted) + spare.page_status = 0; else { - tags.objectId = eTags->objectId; - tags.chunkId = eTags->chunkId; + tags.obj_id = ext_tags->obj_id; + tags.chunk_id = ext_tags->chunk_id; - tags.byteCountLSB = eTags->byteCount & 0x3ff; + tags.n_bytes_lsb = ext_tags->n_bytes & 0x3ff; - if (dev->nDataBytesPerChunk >= 1024) - tags.byteCountMSB = (eTags->byteCount >> 10) & 3; + if (dev->data_bytes_per_chunk >= 1024) + tags.n_bytes_msb = (ext_tags->n_bytes >> 10) & 3; else - tags.byteCountMSB = 3; + tags.n_bytes_msb = 3; + tags.serial_number = ext_tags->serial_number; - tags.serialNumber = eTags->serialNumber; + if (!dev->param.use_nand_ecc && data) + yaffs_calc_ecc(data, &spare); - if (!dev->param.useNANDECC && data) - yaffs_CalcECC(data, &spare); - - yaffs_LoadTagsIntoSpare(&spare, &tags); + yaffs_load_tags_to_spare(&spare, &tags); } - return yaffs_WriteChunkToNAND(dev, chunkInNAND, data, &spare); + return yaffs_wr_nand(dev, nand_chunk, data, &spare); } -int yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(yaffs_Device *dev, - int chunkInNAND, - __u8 *data, - yaffs_ExtendedTags *eTags) +int yaffs_tags_compat_rd(struct yaffs_dev *dev, + int nand_chunk, + u8 * data, struct yaffs_ext_tags *ext_tags) { - yaffs_Spare spare; - yaffs_Tags tags; - yaffs_ECCResult eccResult = YAFFS_ECC_RESULT_UNKNOWN; + struct yaffs_spare spare; + struct yaffs_tags tags; + enum yaffs_ecc_result ecc_result = YAFFS_ECC_RESULT_UNKNOWN; - static yaffs_Spare spareFF; + static struct yaffs_spare spare_ff; static int init; if (!init) { - memset(&spareFF, 0xFF, sizeof(spareFF)); + memset(&spare_ff, 0xFF, sizeof(spare_ff)); init = 1; } - if (yaffs_ReadChunkFromNAND - (dev, chunkInNAND, data, &spare, &eccResult, 1)) { - /* eTags may be NULL */ - if (eTags) { + if (yaffs_rd_chunk_nand(dev, nand_chunk, data, &spare, &ecc_result, 1)) { + /* ext_tags may be NULL */ + if (ext_tags) { int deleted = - (yaffs_CountBits(spare.pageStatus) < 7) ? 1 : 0; + (yaffs_count_bits(spare.page_status) < 7) ? 1 : 0; - eTags->chunkDeleted = deleted; - eTags->eccResult = eccResult; - eTags->blockBad = 0; /* We're reading it */ + ext_tags->is_deleted = deleted; + ext_tags->ecc_result = ecc_result; + ext_tags->block_bad = 0; /* We're reading it */ /* therefore it is not a bad block */ - eTags->chunkUsed = - (memcmp(&spareFF, &spare, sizeof(spareFF)) != + ext_tags->chunk_used = + (memcmp(&spare_ff, &spare, sizeof(spare_ff)) != 0) ? 1 : 0; - if (eTags->chunkUsed) { - yaffs_GetTagsFromSpare(dev, &spare, &tags); + if (ext_tags->chunk_used) { + yaffs_get_tags_from_spare(dev, &spare, &tags); - eTags->objectId = tags.objectId; - eTags->chunkId = tags.chunkId; - eTags->byteCount = tags.byteCountLSB; + ext_tags->obj_id = tags.obj_id; + ext_tags->chunk_id = tags.chunk_id; + ext_tags->n_bytes = tags.n_bytes_lsb; - if (dev->nDataBytesPerChunk >= 1024) - eTags->byteCount |= (((unsigned) tags.byteCountMSB) << 10); + if (dev->data_bytes_per_chunk >= 1024) + ext_tags->n_bytes |= + (((unsigned)tags. + n_bytes_msb) << 10); - eTags->serialNumber = tags.serialNumber; + ext_tags->serial_number = tags.serial_number; } } @@ -486,51 +402,50 @@ int yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(yaffs_Device *dev, } } -int yaffs_TagsCompatabilityMarkNANDBlockBad(struct yaffs_DeviceStruct *dev, - int blockInNAND) +int yaffs_tags_compat_mark_bad(struct yaffs_dev *dev, int flash_block) { - yaffs_Spare spare; + struct yaffs_spare spare; - memset(&spare, 0xff, sizeof(yaffs_Spare)); + memset(&spare, 0xff, sizeof(struct yaffs_spare)); - spare.blockStatus = 'Y'; + spare.block_status = 'Y'; - yaffs_WriteChunkToNAND(dev, blockInNAND * dev->param.nChunksPerBlock, NULL, - &spare); - yaffs_WriteChunkToNAND(dev, blockInNAND * dev->param.nChunksPerBlock + 1, - NULL, &spare); + yaffs_wr_nand(dev, flash_block * dev->param.chunks_per_block, NULL, + &spare); + yaffs_wr_nand(dev, flash_block * dev->param.chunks_per_block + 1, + NULL, &spare); return YAFFS_OK; } -int yaffs_TagsCompatabilityQueryNANDBlock(struct yaffs_DeviceStruct *dev, - int blockNo, - yaffs_BlockState *state, - __u32 *sequenceNumber) +int yaffs_tags_compat_query_block(struct yaffs_dev *dev, + int block_no, + enum yaffs_block_state *state, + u32 * seq_number) { - yaffs_Spare spare0, spare1; - static yaffs_Spare spareFF; + struct yaffs_spare spare0, spare1; + static struct yaffs_spare spare_ff; static int init; - yaffs_ECCResult dummy; + enum yaffs_ecc_result dummy; if (!init) { - memset(&spareFF, 0xFF, sizeof(spareFF)); + memset(&spare_ff, 0xFF, sizeof(spare_ff)); init = 1; } - *sequenceNumber = 0; + *seq_number = 0; - yaffs_ReadChunkFromNAND(dev, blockNo * dev->param.nChunksPerBlock, NULL, - &spare0, &dummy, 1); - yaffs_ReadChunkFromNAND(dev, blockNo * dev->param.nChunksPerBlock + 1, NULL, - &spare1, &dummy, 1); + yaffs_rd_chunk_nand(dev, block_no * dev->param.chunks_per_block, NULL, + &spare0, &dummy, 1); + yaffs_rd_chunk_nand(dev, block_no * dev->param.chunks_per_block + 1, + NULL, &spare1, &dummy, 1); - if (yaffs_CountBits(spare0.blockStatus & spare1.blockStatus) < 7) + if (yaffs_count_bits(spare0.block_status & spare1.block_status) < 7) *state = YAFFS_BLOCK_STATE_DEAD; - else if (memcmp(&spareFF, &spare0, sizeof(spareFF)) == 0) + else if (memcmp(&spare_ff, &spare0, sizeof(spare_ff)) == 0) *state = YAFFS_BLOCK_STATE_EMPTY; else *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING; diff --git a/fs/yaffs2/yaffs_tagscompat.h b/fs/yaffs2/yaffs_tagscompat.h index 8c663db5..8cd35dcd 100644 --- a/fs/yaffs2/yaffs_tagscompat.h +++ b/fs/yaffs2/yaffs_tagscompat.h @@ -17,23 +17,20 @@ #define __YAFFS_TAGSCOMPAT_H__ #include "yaffs_guts.h" -int yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(yaffs_Device *dev, - int chunkInNAND, - const __u8 *data, - const yaffs_ExtendedTags *tags); -int yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(yaffs_Device *dev, - int chunkInNAND, - __u8 *data, - yaffs_ExtendedTags *tags); -int yaffs_TagsCompatabilityMarkNANDBlockBad(struct yaffs_DeviceStruct *dev, - int blockNo); -int yaffs_TagsCompatabilityQueryNANDBlock(struct yaffs_DeviceStruct *dev, - int blockNo, - yaffs_BlockState *state, - __u32 *sequenceNumber); +int yaffs_tags_compat_wr(struct yaffs_dev *dev, + int nand_chunk, + const u8 * data, const struct yaffs_ext_tags *tags); +int yaffs_tags_compat_rd(struct yaffs_dev *dev, + int nand_chunk, + u8 * data, struct yaffs_ext_tags *tags); +int yaffs_tags_compat_mark_bad(struct yaffs_dev *dev, int block_no); +int yaffs_tags_compat_query_block(struct yaffs_dev *dev, + int block_no, + enum yaffs_block_state *state, + u32 * seq_number); -void yaffs_CalcTagsECC(yaffs_Tags *tags); -int yaffs_CheckECCOnTags(yaffs_Tags *tags); -int yaffs_CountBits(__u8 byte); +void yaffs_calc_tags_ecc(struct yaffs_tags *tags); +int yaffs_check_tags_ecc(struct yaffs_tags *tags); +int yaffs_count_bits(u8 byte); #endif diff --git a/fs/yaffs2/yaffs_tagsvalidity.c b/fs/yaffs2/yaffs_tagsvalidity.c index 93ad08c1..4358d79d 100644 --- a/fs/yaffs2/yaffs_tagsvalidity.c +++ b/fs/yaffs2/yaffs_tagsvalidity.c @@ -13,16 +13,15 @@ #include "yaffs_tagsvalidity.h" -void yaffs_InitialiseTags(yaffs_ExtendedTags *tags) +void yaffs_init_tags(struct yaffs_ext_tags *tags) { - memset(tags, 0, sizeof(yaffs_ExtendedTags)); - tags->validMarker0 = 0xAAAAAAAA; - tags->validMarker1 = 0x55555555; + memset(tags, 0, sizeof(struct yaffs_ext_tags)); + tags->validity0 = 0xAAAAAAAA; + tags->validity1 = 0x55555555; } -int yaffs_ValidateTags(yaffs_ExtendedTags *tags) +int yaffs_validate_tags(struct yaffs_ext_tags *tags) { - return (tags->validMarker0 == 0xAAAAAAAA && - tags->validMarker1 == 0x55555555); + return (tags->validity0 == 0xAAAAAAAA && tags->validity1 == 0x55555555); } diff --git a/fs/yaffs2/yaffs_tagsvalidity.h b/fs/yaffs2/yaffs_tagsvalidity.h index 60a1aea6..36a021fc 100644 --- a/fs/yaffs2/yaffs_tagsvalidity.h +++ b/fs/yaffs2/yaffs_tagsvalidity.h @@ -13,12 +13,11 @@ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. */ - #ifndef __YAFFS_TAGS_VALIDITY_H__ #define __YAFFS_TAGS_VALIDITY_H__ #include "yaffs_guts.h" -void yaffs_InitialiseTags(yaffs_ExtendedTags *tags); -int yaffs_ValidateTags(yaffs_ExtendedTags *tags); +void yaffs_init_tags(struct yaffs_ext_tags *tags); +int yaffs_validate_tags(struct yaffs_ext_tags *tags); #endif diff --git a/fs/yaffs2/yaffs_trace.h b/fs/yaffs2/yaffs_trace.h index 8b848edb..90dbefc9 100644 --- a/fs/yaffs2/yaffs_trace.h +++ b/fs/yaffs2/yaffs_trace.h @@ -13,11 +13,10 @@ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. */ - #ifndef __YTRACE_H__ #define __YTRACE_H__ -extern unsigned int yaffs_traceMask; +extern unsigned int yaffs_trace_mask; extern unsigned int yaffs_wr_attempts; /* @@ -54,7 +53,6 @@ extern unsigned int yaffs_wr_attempts; #define YAFFS_TRACE_BUG 0x80000000 #define YAFFS_TRACE_ALWAYS 0xF0000000 - -#define T(mask, p) do { if ((mask) & (yaffs_traceMask | YAFFS_TRACE_ALWAYS)) TOUT(p); } while (0) +#define T(mask, p) do { if ((mask) & (yaffs_trace_mask | YAFFS_TRACE_ALWAYS)) TOUT(p); } while (0) #endif diff --git a/fs/yaffs2/yaffs_verify.c b/fs/yaffs2/yaffs_verify.c index a600aa6b..fee3a1e4 100644 --- a/fs/yaffs2/yaffs_verify.c +++ b/fs/yaffs2/yaffs_verify.c @@ -11,149 +11,159 @@ * published by the Free Software Foundation. */ - #include "yaffs_verify.h" #include "yaffs_trace.h" #include "yaffs_bitmap.h" #include "yaffs_getblockinfo.h" #include "yaffs_nand.h" -int yaffs_SkipVerification(yaffs_Device *dev) +int yaffs_skip_verification(struct yaffs_dev *dev) { - dev=dev; - return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL)); + dev = dev; + return !(yaffs_trace_mask & + (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL)); } -static int yaffs_SkipFullVerification(yaffs_Device *dev) +static int yaffs_skip_full_verification(struct yaffs_dev *dev) { - dev=dev; - return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY_FULL)); + dev = dev; + return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY_FULL)); } -static int yaffs_SkipNANDVerification(yaffs_Device *dev) +static int yaffs_skip_nand_verification(struct yaffs_dev *dev) { - dev=dev; - return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY_NAND)); + dev = dev; + return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY_NAND)); } - -static const char *blockStateName[] = { -"Unknown", -"Needs scanning", -"Scanning", -"Empty", -"Allocating", -"Full", -"Dirty", -"Checkpoint", -"Collecting", -"Dead" +static const char *block_state_name[] = { + "Unknown", + "Needs scanning", + "Scanning", + "Empty", + "Allocating", + "Full", + "Dirty", + "Checkpoint", + "Collecting", + "Dead" }; - -void yaffs_VerifyBlock(yaffs_Device *dev, yaffs_BlockInfo *bi, int n) +void yaffs_verify_blk(struct yaffs_dev *dev, struct yaffs_block_info *bi, int n) { - int actuallyUsed; - int inUse; + int actually_used; + int in_use; - if (yaffs_SkipVerification(dev)) + if (yaffs_skip_verification(dev)) return; /* Report illegal runtime states */ - if (bi->blockState >= YAFFS_NUMBER_OF_BLOCK_STATES) - T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has undefined state %d"TENDSTR), n, bi->blockState)); + if (bi->block_state >= YAFFS_NUMBER_OF_BLOCK_STATES) + T(YAFFS_TRACE_VERIFY, + (TSTR("Block %d has undefined state %d" TENDSTR), n, + bi->block_state)); - switch (bi->blockState) { + switch (bi->block_state) { case YAFFS_BLOCK_STATE_UNKNOWN: case YAFFS_BLOCK_STATE_SCANNING: case YAFFS_BLOCK_STATE_NEEDS_SCANNING: - T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has bad run-state %s"TENDSTR), - n, blockStateName[bi->blockState])); + T(YAFFS_TRACE_VERIFY, + (TSTR("Block %d has bad run-state %s" TENDSTR), n, + block_state_name[bi->block_state])); } /* Check pages in use and soft deletions are legal */ - actuallyUsed = bi->pagesInUse - bi->softDeletions; - - if (bi->pagesInUse < 0 || bi->pagesInUse > dev->param.nChunksPerBlock || - bi->softDeletions < 0 || bi->softDeletions > dev->param.nChunksPerBlock || - actuallyUsed < 0 || actuallyUsed > dev->param.nChunksPerBlock) - T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has illegal values pagesInUsed %d softDeletions %d"TENDSTR), - n, bi->pagesInUse, bi->softDeletions)); + actually_used = bi->pages_in_use - bi->soft_del_pages; + if (bi->pages_in_use < 0 + || bi->pages_in_use > dev->param.chunks_per_block + || bi->soft_del_pages < 0 + || bi->soft_del_pages > dev->param.chunks_per_block + || actually_used < 0 || actually_used > dev->param.chunks_per_block) + T(YAFFS_TRACE_VERIFY, + (TSTR + ("Block %d has illegal values pages_in_used %d soft_del_pages %d" + TENDSTR), n, bi->pages_in_use, bi->soft_del_pages)); /* Check chunk bitmap legal */ - inUse = yaffs_CountChunkBits(dev, n); - if (inUse != bi->pagesInUse) - T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has inconsistent values pagesInUse %d counted chunk bits %d"TENDSTR), - n, bi->pagesInUse, inUse)); + in_use = yaffs_count_chunk_bits(dev, n); + if (in_use != bi->pages_in_use) + T(YAFFS_TRACE_VERIFY, + (TSTR + ("Block %d has inconsistent values pages_in_use %d counted chunk bits %d" + TENDSTR), n, bi->pages_in_use, in_use)); } - - -void yaffs_VerifyCollectedBlock(yaffs_Device *dev, yaffs_BlockInfo *bi, int n) +void yaffs_verify_collected_blk(struct yaffs_dev *dev, + struct yaffs_block_info *bi, int n) { - yaffs_VerifyBlock(dev, bi, n); + yaffs_verify_blk(dev, bi, n); /* After collection the block should be in the erased state */ - if (bi->blockState != YAFFS_BLOCK_STATE_COLLECTING && - bi->blockState != YAFFS_BLOCK_STATE_EMPTY) { - T(YAFFS_TRACE_ERROR, (TSTR("Block %d is in state %d after gc, should be erased"TENDSTR), - n, bi->blockState)); + if (bi->block_state != YAFFS_BLOCK_STATE_COLLECTING && + bi->block_state != YAFFS_BLOCK_STATE_EMPTY) { + T(YAFFS_TRACE_ERROR, + (TSTR + ("Block %d is in state %d after gc, should be erased" + TENDSTR), n, bi->block_state)); } } -void yaffs_VerifyBlocks(yaffs_Device *dev) +void yaffs_verify_blocks(struct yaffs_dev *dev) { int i; - int nBlocksPerState[YAFFS_NUMBER_OF_BLOCK_STATES]; - int nIllegalBlockStates = 0; + int state_count[YAFFS_NUMBER_OF_BLOCK_STATES]; + int illegal_states = 0; - if (yaffs_SkipVerification(dev)) + if (yaffs_skip_verification(dev)) return; - memset(nBlocksPerState, 0, sizeof(nBlocksPerState)); + memset(state_count, 0, sizeof(state_count)); - for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) { - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, i); - yaffs_VerifyBlock(dev, bi, i); + for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) { + struct yaffs_block_info *bi = yaffs_get_block_info(dev, i); + yaffs_verify_blk(dev, bi, i); - if (bi->blockState < YAFFS_NUMBER_OF_BLOCK_STATES) - nBlocksPerState[bi->blockState]++; + if (bi->block_state < YAFFS_NUMBER_OF_BLOCK_STATES) + state_count[bi->block_state]++; else - nIllegalBlockStates++; + illegal_states++; } - T(YAFFS_TRACE_VERIFY, (TSTR(""TENDSTR))); - T(YAFFS_TRACE_VERIFY, (TSTR("Block summary"TENDSTR))); + T(YAFFS_TRACE_VERIFY, (TSTR("" TENDSTR))); + T(YAFFS_TRACE_VERIFY, (TSTR("Block summary" TENDSTR))); - T(YAFFS_TRACE_VERIFY, (TSTR("%d blocks have illegal states"TENDSTR), nIllegalBlockStates)); - if (nBlocksPerState[YAFFS_BLOCK_STATE_ALLOCATING] > 1) - T(YAFFS_TRACE_VERIFY, (TSTR("Too many allocating blocks"TENDSTR))); + T(YAFFS_TRACE_VERIFY, + (TSTR("%d blocks have illegal states" TENDSTR), illegal_states)); + if (state_count[YAFFS_BLOCK_STATE_ALLOCATING] > 1) + T(YAFFS_TRACE_VERIFY, + (TSTR("Too many allocating blocks" TENDSTR))); for (i = 0; i < YAFFS_NUMBER_OF_BLOCK_STATES; i++) T(YAFFS_TRACE_VERIFY, - (TSTR("%s %d blocks"TENDSTR), - blockStateName[i], nBlocksPerState[i])); + (TSTR("%s %d blocks" TENDSTR), + block_state_name[i], state_count[i])); - if (dev->blocksInCheckpoint != nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT]) + if (dev->blocks_in_checkpt != state_count[YAFFS_BLOCK_STATE_CHECKPOINT]) T(YAFFS_TRACE_VERIFY, - (TSTR("Checkpoint block count wrong dev %d count %d"TENDSTR), - dev->blocksInCheckpoint, nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT])); + (TSTR("Checkpoint block count wrong dev %d count %d" TENDSTR), + dev->blocks_in_checkpt, + state_count[YAFFS_BLOCK_STATE_CHECKPOINT])); - if (dev->nErasedBlocks != nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY]) + if (dev->n_erased_blocks != state_count[YAFFS_BLOCK_STATE_EMPTY]) T(YAFFS_TRACE_VERIFY, - (TSTR("Erased block count wrong dev %d count %d"TENDSTR), - dev->nErasedBlocks, nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY])); + (TSTR("Erased block count wrong dev %d count %d" TENDSTR), + dev->n_erased_blocks, state_count[YAFFS_BLOCK_STATE_EMPTY])); - if (nBlocksPerState[YAFFS_BLOCK_STATE_COLLECTING] > 1) + if (state_count[YAFFS_BLOCK_STATE_COLLECTING] > 1) T(YAFFS_TRACE_VERIFY, - (TSTR("Too many collecting blocks %d (max is 1)"TENDSTR), - nBlocksPerState[YAFFS_BLOCK_STATE_COLLECTING])); + (TSTR("Too many collecting blocks %d (max is 1)" TENDSTR), + state_count[YAFFS_BLOCK_STATE_COLLECTING])); - T(YAFFS_TRACE_VERIFY, (TSTR(""TENDSTR))); + T(YAFFS_TRACE_VERIFY, (TSTR("" TENDSTR))); } @@ -161,317 +171,272 @@ void yaffs_VerifyBlocks(yaffs_Device *dev) * Verify the object header. oh must be valid, but obj and tags may be NULL in which * case those tests will not be performed. */ -void yaffs_VerifyObjectHeader(yaffs_Object *obj, yaffs_ObjectHeader *oh, yaffs_ExtendedTags *tags, int parentCheck) +void yaffs_verify_oh(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh, + struct yaffs_ext_tags *tags, int parent_check) { - if (obj && yaffs_SkipVerification(obj->myDev)) + if (obj && yaffs_skip_verification(obj->my_dev)) return; if (!(tags && obj && oh)) { T(YAFFS_TRACE_VERIFY, - (TSTR("Verifying object header tags %p obj %p oh %p"TENDSTR), - tags, obj, oh)); + (TSTR("Verifying object header tags %p obj %p oh %p" TENDSTR), + tags, obj, oh)); return; } if (oh->type <= YAFFS_OBJECT_TYPE_UNKNOWN || - oh->type > YAFFS_OBJECT_TYPE_MAX) + oh->type > YAFFS_OBJECT_TYPE_MAX) T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header type is illegal value 0x%x"TENDSTR), - tags->objectId, oh->type)); + (TSTR("Obj %d header type is illegal value 0x%x" TENDSTR), + tags->obj_id, oh->type)); - if (tags->objectId != obj->objectId) + if (tags->obj_id != obj->obj_id) T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header mismatch objectId %d"TENDSTR), - tags->objectId, obj->objectId)); - + (TSTR("Obj %d header mismatch obj_id %d" TENDSTR), + tags->obj_id, obj->obj_id)); /* - * Check that the object's parent ids match if parentCheck requested. + * Check that the object's parent ids match if parent_check requested. * * Tests do not apply to the root object. */ - if (parentCheck && tags->objectId > 1 && !obj->parent) + if (parent_check && tags->obj_id > 1 && !obj->parent) T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header mismatch parentId %d obj->parent is NULL"TENDSTR), - tags->objectId, oh->parentObjectId)); + (TSTR + ("Obj %d header mismatch parent_id %d obj->parent is NULL" + TENDSTR), tags->obj_id, oh->parent_obj_id)); - if (parentCheck && obj->parent && - oh->parentObjectId != obj->parent->objectId && - (oh->parentObjectId != YAFFS_OBJECTID_UNLINKED || - obj->parent->objectId != YAFFS_OBJECTID_DELETED)) + if (parent_check && obj->parent && + oh->parent_obj_id != obj->parent->obj_id && + (oh->parent_obj_id != YAFFS_OBJECTID_UNLINKED || + obj->parent->obj_id != YAFFS_OBJECTID_DELETED)) T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header mismatch parentId %d parentObjectId %d"TENDSTR), - tags->objectId, oh->parentObjectId, obj->parent->objectId)); + (TSTR + ("Obj %d header mismatch parent_id %d parent_obj_id %d" + TENDSTR), tags->obj_id, oh->parent_obj_id, + obj->parent->obj_id)); - if (tags->objectId > 1 && oh->name[0] == 0) /* Null name */ + if (tags->obj_id > 1 && oh->name[0] == 0) /* Null name */ T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header name is NULL"TENDSTR), - obj->objectId)); + (TSTR("Obj %d header name is NULL" TENDSTR), obj->obj_id)); - if (tags->objectId > 1 && ((__u8)(oh->name[0])) == 0xff) /* Trashed name */ + if (tags->obj_id > 1 && ((u8) (oh->name[0])) == 0xff) /* Trashed name */ T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header name is 0xFF"TENDSTR), - obj->objectId)); + (TSTR("Obj %d header name is 0xFF" TENDSTR), obj->obj_id)); } - -#if 0 -/* Not being used, but don't want to throw away yet */ -int yaffs_VerifyTnodeWorker(yaffs_Object *obj, yaffs_Tnode *tn, - __u32 level, int chunkOffset) +void yaffs_verify_file(struct yaffs_obj *obj) { - int i; - yaffs_Device *dev = obj->myDev; - int ok = 1; - - if (tn) { - if (level > 0) { - - for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++) { - if (tn->internal[i]) { - ok = yaffs_VerifyTnodeWorker(obj, - tn->internal[i], - level - 1, - (chunkOffset<objectId; - - chunkOffset <<= YAFFS_TNODES_LEVEL0_BITS; - - for (i = 0; i < YAFFS_NTNODES_LEVEL0; i++) { - __u32 theChunk = yaffs_GetChunkGroupBase(dev, tn, i); - - if (theChunk > 0) { - /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),tags.objectId,tags.chunkId,theChunk)); */ - yaffs_ReadChunkWithTagsFromNAND(dev, theChunk, NULL, &tags); - if (tags.objectId != objectId || tags.chunkId != chunkOffset) { - T(~0, (TSTR("Object %d chunkId %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR), - objectId, chunkOffset, theChunk, - tags.objectId, tags.chunkId)); - } - } - chunkOffset++; - } - } - } - - return ok; - -} - -#endif - -void yaffs_VerifyFile(yaffs_Object *obj) -{ - int requiredTallness; - int actualTallness; - __u32 lastChunk; - __u32 x; - __u32 i; - yaffs_Device *dev; - yaffs_ExtendedTags tags; - yaffs_Tnode *tn; - __u32 objectId; + int required_depth; + int actual_depth; + u32 last_chunk; + u32 x; + u32 i; + struct yaffs_dev *dev; + struct yaffs_ext_tags tags; + struct yaffs_tnode *tn; + u32 obj_id; if (!obj) return; - if (yaffs_SkipVerification(obj->myDev)) + if (yaffs_skip_verification(obj->my_dev)) return; - dev = obj->myDev; - objectId = obj->objectId; + dev = obj->my_dev; + obj_id = obj->obj_id; /* Check file size is consistent with tnode depth */ - lastChunk = obj->variant.fileVariant.fileSize / dev->nDataBytesPerChunk + 1; - x = lastChunk >> YAFFS_TNODES_LEVEL0_BITS; - requiredTallness = 0; + last_chunk = + obj->variant.file_variant.file_size / dev->data_bytes_per_chunk + 1; + x = last_chunk >> YAFFS_TNODES_LEVEL0_BITS; + required_depth = 0; while (x > 0) { x >>= YAFFS_TNODES_INTERNAL_BITS; - requiredTallness++; + required_depth++; } - actualTallness = obj->variant.fileVariant.topLevel; + actual_depth = obj->variant.file_variant.top_level; /* Check that the chunks in the tnode tree are all correct. * We do this by scanning through the tnode tree and * checking the tags for every chunk match. */ - if (yaffs_SkipNANDVerification(dev)) + if (yaffs_skip_nand_verification(dev)) return; - for (i = 1; i <= lastChunk; i++) { - tn = yaffs_FindLevel0Tnode(dev, &obj->variant.fileVariant, i); + for (i = 1; i <= last_chunk; i++) { + tn = yaffs_find_tnode_0(dev, &obj->variant.file_variant, i); if (tn) { - __u32 theChunk = yaffs_GetChunkGroupBase(dev, tn, i); - if (theChunk > 0) { - /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),objectId,i,theChunk)); */ - yaffs_ReadChunkWithTagsFromNAND(dev, theChunk, NULL, &tags); - if (tags.objectId != objectId || tags.chunkId != i) { - T(~0, (TSTR("Object %d chunkId %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR), - objectId, i, theChunk, - tags.objectId, tags.chunkId)); + u32 the_chunk = yaffs_get_group_base(dev, tn, i); + if (the_chunk > 0) { + /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),obj_id,i,the_chunk)); */ + yaffs_rd_chunk_tags_nand(dev, the_chunk, NULL, + &tags); + if (tags.obj_id != obj_id || tags.chunk_id != i) { + T(~0, + (TSTR + ("Object %d chunk_id %d NAND mismatch chunk %d tags (%d:%d)" + TENDSTR), obj_id, i, the_chunk, + tags.obj_id, tags.chunk_id)); } } } } } - -void yaffs_VerifyHardLink(yaffs_Object *obj) +void yaffs_verify_link(struct yaffs_obj *obj) { - if (obj && yaffs_SkipVerification(obj->myDev)) + if (obj && yaffs_skip_verification(obj->my_dev)) return; /* Verify sane equivalent object */ } -void yaffs_VerifySymlink(yaffs_Object *obj) +void yaffs_verify_symlink(struct yaffs_obj *obj) { - if (obj && yaffs_SkipVerification(obj->myDev)) + if (obj && yaffs_skip_verification(obj->my_dev)) return; /* Verify symlink string */ } -void yaffs_VerifySpecial(yaffs_Object *obj) +void yaffs_verify_special(struct yaffs_obj *obj) { - if (obj && yaffs_SkipVerification(obj->myDev)) + if (obj && yaffs_skip_verification(obj->my_dev)) return; } -void yaffs_VerifyObject(yaffs_Object *obj) +void yaffs_verify_obj(struct yaffs_obj *obj) { - yaffs_Device *dev; + struct yaffs_dev *dev; - __u32 chunkMin; - __u32 chunkMax; + u32 chunk_min; + u32 chunk_max; - __u32 chunkIdOk; - __u32 chunkInRange; - __u32 chunkShouldNotBeDeleted; - __u32 chunkValid; + u32 chunk_id_ok; + u32 chunk_in_range; + u32 chunk_wrongly_deleted; + u32 chunk_valid; if (!obj) return; - if (obj->beingCreated) + if (obj->being_created) return; - dev = obj->myDev; + dev = obj->my_dev; - if (yaffs_SkipVerification(dev)) + if (yaffs_skip_verification(dev)) return; /* Check sane object header chunk */ - chunkMin = dev->internalStartBlock * dev->param.nChunksPerBlock; - chunkMax = (dev->internalEndBlock+1) * dev->param.nChunksPerBlock - 1; + chunk_min = dev->internal_start_block * dev->param.chunks_per_block; + chunk_max = + (dev->internal_end_block + 1) * dev->param.chunks_per_block - 1; - chunkInRange = (((unsigned)(obj->hdrChunk)) >= chunkMin && ((unsigned)(obj->hdrChunk)) <= chunkMax); - chunkIdOk = chunkInRange || (obj->hdrChunk == 0); - chunkValid = chunkInRange && - yaffs_CheckChunkBit(dev, - obj->hdrChunk / dev->param.nChunksPerBlock, - obj->hdrChunk % dev->param.nChunksPerBlock); - chunkShouldNotBeDeleted = chunkInRange && !chunkValid; + chunk_in_range = (((unsigned)(obj->hdr_chunk)) >= chunk_min && + ((unsigned)(obj->hdr_chunk)) <= chunk_max); + chunk_id_ok = chunk_in_range || (obj->hdr_chunk == 0); + chunk_valid = chunk_in_range && + yaffs_check_chunk_bit(dev, + obj->hdr_chunk / dev->param.chunks_per_block, + obj->hdr_chunk % dev->param.chunks_per_block); + chunk_wrongly_deleted = chunk_in_range && !chunk_valid; - if (!obj->fake && - (!chunkIdOk || chunkShouldNotBeDeleted)) { + if (!obj->fake && (!chunk_id_ok || chunk_wrongly_deleted)) { T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d has chunkId %d %s %s"TENDSTR), - obj->objectId, obj->hdrChunk, - chunkIdOk ? "" : ",out of range", - chunkShouldNotBeDeleted ? ",marked as deleted" : "")); + (TSTR("Obj %d has chunk_id %d %s %s" TENDSTR), + obj->obj_id, obj->hdr_chunk, + chunk_id_ok ? "" : ",out of range", + chunk_wrongly_deleted ? ",marked as deleted" : "")); } - if (chunkValid && !yaffs_SkipNANDVerification(dev)) { - yaffs_ExtendedTags tags; - yaffs_ObjectHeader *oh; - __u8 *buffer = yaffs_GetTempBuffer(dev, __LINE__); + if (chunk_valid && !yaffs_skip_nand_verification(dev)) { + struct yaffs_ext_tags tags; + struct yaffs_obj_hdr *oh; + u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__); - oh = (yaffs_ObjectHeader *)buffer; + oh = (struct yaffs_obj_hdr *)buffer; - yaffs_ReadChunkWithTagsFromNAND(dev, obj->hdrChunk, buffer, - &tags); + yaffs_rd_chunk_tags_nand(dev, obj->hdr_chunk, buffer, &tags); - yaffs_VerifyObjectHeader(obj, oh, &tags, 1); + yaffs_verify_oh(obj, oh, &tags, 1); - yaffs_ReleaseTempBuffer(dev, buffer, __LINE__); + yaffs_release_temp_buffer(dev, buffer, __LINE__); } /* Verify it has a parent */ - if (obj && !obj->fake && - (!obj->parent || obj->parent->myDev != dev)) { + if (obj && !obj->fake && (!obj->parent || obj->parent->my_dev != dev)) { T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d has parent pointer %p which does not look like an object"TENDSTR), - obj->objectId, obj->parent)); + (TSTR + ("Obj %d has parent pointer %p which does not look like an object" + TENDSTR), obj->obj_id, obj->parent)); } /* Verify parent is a directory */ - if (obj->parent && obj->parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { + if (obj->parent + && obj->parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d's parent is not a directory (type %d)"TENDSTR), - obj->objectId, obj->parent->variantType)); + (TSTR("Obj %d's parent is not a directory (type %d)" TENDSTR), + obj->obj_id, obj->parent->variant_type)); } - switch (obj->variantType) { + switch (obj->variant_type) { case YAFFS_OBJECT_TYPE_FILE: - yaffs_VerifyFile(obj); + yaffs_verify_file(obj); break; case YAFFS_OBJECT_TYPE_SYMLINK: - yaffs_VerifySymlink(obj); + yaffs_verify_symlink(obj); break; case YAFFS_OBJECT_TYPE_DIRECTORY: - yaffs_VerifyDirectory(obj); + yaffs_verify_dir(obj); break; case YAFFS_OBJECT_TYPE_HARDLINK: - yaffs_VerifyHardLink(obj); + yaffs_verify_link(obj); break; case YAFFS_OBJECT_TYPE_SPECIAL: - yaffs_VerifySpecial(obj); + yaffs_verify_special(obj); break; case YAFFS_OBJECT_TYPE_UNKNOWN: default: T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d has illegaltype %d"TENDSTR), - obj->objectId, obj->variantType)); + (TSTR("Obj %d has illegaltype %d" TENDSTR), + obj->obj_id, obj->variant_type)); break; } } -void yaffs_VerifyObjects(yaffs_Device *dev) +void yaffs_verify_objects(struct yaffs_dev *dev) { - yaffs_Object *obj; + struct yaffs_obj *obj; int i; - struct ylist_head *lh; + struct list_head *lh; - if (yaffs_SkipVerification(dev)) + if (yaffs_skip_verification(dev)) return; /* Iterate through the objects in each hash entry */ - for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { - ylist_for_each(lh, &dev->objectBucket[i].list) { + for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { + list_for_each(lh, &dev->obj_bucket[i].list) { if (lh) { - obj = ylist_entry(lh, yaffs_Object, hashLink); - yaffs_VerifyObject(obj); + obj = + list_entry(lh, struct yaffs_obj, hash_link); + yaffs_verify_obj(obj); } } } } - -void yaffs_VerifyObjectInDirectory(yaffs_Object *obj) +void yaffs_verify_obj_in_dir(struct yaffs_obj *obj) { - struct ylist_head *lh; - yaffs_Object *listObj; + struct list_head *lh; + struct yaffs_obj *list_obj; int count = 0; @@ -481,146 +446,101 @@ void yaffs_VerifyObjectInDirectory(yaffs_Object *obj) return; } - if (yaffs_SkipVerification(obj->myDev)) + if (yaffs_skip_verification(obj->my_dev)) return; if (!obj->parent) { - T(YAFFS_TRACE_ALWAYS, (TSTR("Object does not have parent" TENDSTR))); + T(YAFFS_TRACE_ALWAYS, + (TSTR("Object does not have parent" TENDSTR))); YBUG(); return; } - if (obj->parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { - T(YAFFS_TRACE_ALWAYS, (TSTR("Parent is not directory" TENDSTR))); + if (obj->parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { + T(YAFFS_TRACE_ALWAYS, + (TSTR("Parent is not directory" TENDSTR))); YBUG(); } /* Iterate through the objects in each hash entry */ - ylist_for_each(lh, &obj->parent->variant.directoryVariant.children) { + list_for_each(lh, &obj->parent->variant.dir_variant.children) { if (lh) { - listObj = ylist_entry(lh, yaffs_Object, siblings); - yaffs_VerifyObject(listObj); - if (obj == listObj) + list_obj = list_entry(lh, struct yaffs_obj, siblings); + yaffs_verify_obj(list_obj); + if (obj == list_obj) count++; } - } + } if (count != 1) { - T(YAFFS_TRACE_ALWAYS, (TSTR("Object in directory %d times" TENDSTR), count)); + T(YAFFS_TRACE_ALWAYS, + (TSTR("Object in directory %d times" TENDSTR), count)); YBUG(); } } -void yaffs_VerifyDirectory(yaffs_Object *directory) +void yaffs_verify_dir(struct yaffs_obj *directory) { - struct ylist_head *lh; - yaffs_Object *listObj; + struct list_head *lh; + struct yaffs_obj *list_obj; if (!directory) { YBUG(); return; } - if (yaffs_SkipFullVerification(directory->myDev)) + if (yaffs_skip_full_verification(directory->my_dev)) return; - if (directory->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { - T(YAFFS_TRACE_ALWAYS, (TSTR("Directory has wrong type: %d" TENDSTR), directory->variantType)); + if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { + T(YAFFS_TRACE_ALWAYS, + (TSTR("Directory has wrong type: %d" TENDSTR), + directory->variant_type)); YBUG(); } /* Iterate through the objects in each hash entry */ - ylist_for_each(lh, &directory->variant.directoryVariant.children) { + list_for_each(lh, &directory->variant.dir_variant.children) { if (lh) { - listObj = ylist_entry(lh, yaffs_Object, siblings); - if (listObj->parent != directory) { - T(YAFFS_TRACE_ALWAYS, (TSTR("Object in directory list has wrong parent %p" TENDSTR), listObj->parent)); + list_obj = list_entry(lh, struct yaffs_obj, siblings); + if (list_obj->parent != directory) { + T(YAFFS_TRACE_ALWAYS, + (TSTR + ("Object in directory list has wrong parent %p" + TENDSTR), list_obj->parent)); YBUG(); } - yaffs_VerifyObjectInDirectory(listObj); + yaffs_verify_obj_in_dir(list_obj); } } } -static int yaffs_freeVerificationFailures; +static int yaffs_free_verification_failures; -void yaffs_VerifyFreeChunks(yaffs_Device *dev) +void yaffs_verify_free_chunks(struct yaffs_dev *dev) { int counted; int difference; - if (yaffs_SkipVerification(dev)) + if (yaffs_skip_verification(dev)) return; - counted = yaffs_CountFreeChunks(dev); + counted = yaffs_count_free_chunks(dev); - difference = dev->nFreeChunks - counted; + difference = dev->n_free_chunks - counted; if (difference) { T(YAFFS_TRACE_ALWAYS, (TSTR("Freechunks verification failure %d %d %d" TENDSTR), - dev->nFreeChunks, counted, difference)); - yaffs_freeVerificationFailures++; + dev->n_free_chunks, counted, difference)); + yaffs_free_verification_failures++; } } -int yaffs_VerifyFileSanity(yaffs_Object *in) +int yaffs_verify_file_sane(struct yaffs_obj *in) { -#if 0 - int chunk; - int nChunks; - int fSize; - int failed = 0; - int objId; - yaffs_Tnode *tn; - yaffs_Tags localTags; - yaffs_Tags *tags = &localTags; - int theChunk; - int chunkDeleted; - - if (in->variantType != YAFFS_OBJECT_TYPE_FILE) - return YAFFS_FAIL; - - objId = in->objectId; - fSize = in->variant.fileVariant.fileSize; - nChunks = - (fSize + in->myDev->nDataBytesPerChunk - 1) / in->myDev->nDataBytesPerChunk; - - for (chunk = 1; chunk <= nChunks; chunk++) { - tn = yaffs_FindLevel0Tnode(in->myDev, &in->variant.fileVariant, - chunk); - - if (tn) { - - theChunk = yaffs_GetChunkGroupBase(dev, tn, chunk); - - if (yaffs_CheckChunkBits - (dev, theChunk / dev->param.nChunksPerBlock, - theChunk % dev->param.nChunksPerBlock)) { - - yaffs_ReadChunkTagsFromNAND(in->myDev, theChunk, - tags, - &chunkDeleted); - if (yaffs_TagsMatch - (tags, in->objectId, chunk, chunkDeleted)) { - /* found it; */ - - } - } else { - - failed = 1; - } - - } else { - /* T(("No level 0 found for %d\n", chunk)); */ - } - } - - return failed ? YAFFS_FAIL : YAFFS_OK; -#else - in=in; + in = in; return YAFFS_OK; -#endif } diff --git a/fs/yaffs2/yaffs_verify.h b/fs/yaffs2/yaffs_verify.h index 8a6f7510..cc6f8899 100644 --- a/fs/yaffs2/yaffs_verify.h +++ b/fs/yaffs2/yaffs_verify.h @@ -1,5 +1,5 @@ /* - * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. * * Copyright (C) 2002-2010 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering @@ -7,8 +7,10 @@ * Created by Charles Manning * * 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 + * it under the terms of the GNU Lesser General Public License version 2.1 as * published by the Free Software Foundation. + * + * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. */ #ifndef __YAFFS_VERIFY_H__ @@ -16,24 +18,26 @@ #include "yaffs_guts.h" -void yaffs_VerifyBlock(yaffs_Device *dev, yaffs_BlockInfo *bi, int n); -void yaffs_VerifyCollectedBlock(yaffs_Device *dev, yaffs_BlockInfo *bi, int n); -void yaffs_VerifyBlocks(yaffs_Device *dev); +void yaffs_verify_blk(struct yaffs_dev *dev, struct yaffs_block_info *bi, + int n); +void yaffs_verify_collected_blk(struct yaffs_dev *dev, + struct yaffs_block_info *bi, int n); +void yaffs_verify_blocks(struct yaffs_dev *dev); -void yaffs_VerifyObjectHeader(yaffs_Object *obj, yaffs_ObjectHeader *oh, yaffs_ExtendedTags *tags, int parentCheck); -void yaffs_VerifyFile(yaffs_Object *obj); -void yaffs_VerifyHardLink(yaffs_Object *obj); -void yaffs_VerifySymlink(yaffs_Object *obj); -void yaffs_VerifySpecial(yaffs_Object *obj); -void yaffs_VerifyObject(yaffs_Object *obj); -void yaffs_VerifyObjects(yaffs_Device *dev); -void yaffs_VerifyObjectInDirectory(yaffs_Object *obj); -void yaffs_VerifyDirectory(yaffs_Object *directory); -void yaffs_VerifyFreeChunks(yaffs_Device *dev); +void yaffs_verify_oh(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh, + struct yaffs_ext_tags *tags, int parent_check); +void yaffs_verify_file(struct yaffs_obj *obj); +void yaffs_verify_link(struct yaffs_obj *obj); +void yaffs_verify_symlink(struct yaffs_obj *obj); +void yaffs_verify_special(struct yaffs_obj *obj); +void yaffs_verify_obj(struct yaffs_obj *obj); +void yaffs_verify_objects(struct yaffs_dev *dev); +void yaffs_verify_obj_in_dir(struct yaffs_obj *obj); +void yaffs_verify_dir(struct yaffs_obj *directory); +void yaffs_verify_free_chunks(struct yaffs_dev *dev); -int yaffs_VerifyFileSanity(yaffs_Object *obj); +int yaffs_verify_file_sane(struct yaffs_obj *obj); -int yaffs_SkipVerification(yaffs_Device *dev); +int yaffs_skip_verification(struct yaffs_dev *dev); #endif - diff --git a/fs/yaffs2/yaffs_vfs_glue.c b/fs/yaffs2/yaffs_vfs.c similarity index 56% rename from fs/yaffs2/yaffs_vfs_glue.c rename to fs/yaffs2/yaffs_vfs.c index c61da67d..9e4e31a8 100644 --- a/fs/yaffs2/yaffs_vfs_glue.c +++ b/fs/yaffs2/yaffs_vfs.c @@ -24,11 +24,11 @@ * the VFS. * * Special notes: - * >> 2.4: sb->u.generic_sbp points to the yaffs_Device associated with + * >> 2.4: sb->u.generic_sbp points to the struct yaffs_dev associated with * this superblock - * >> 2.6: sb->s_fs_info points to the yaffs_Device associated with this + * >> 2.6: sb->s_fs_info points to the struct yaffs_dev associated with this * superblock - * >> inode->u.generic_ip points to the associated yaffs_Object. + * >> inode->u.generic_ip points to the associated struct yaffs_obj. */ /* @@ -151,7 +151,7 @@ static uint32_t YCALCBLOCKS(uint64_t partition_size, uint32_t block_size) { uint64_t result = partition_size; do_div(result, block_size); - return (uint32_t)result; + return (uint32_t) result; } #else #define YCALCBLOCKS(s, b) ((s)/(b)) @@ -163,6 +163,7 @@ static uint32_t YCALCBLOCKS(uint64_t partition_size, uint32_t block_size) #include "yportenv.h" #include "yaffs_trace.h" #include "yaffs_guts.h" +#include "yaffs_attribs.h" #include "yaffs_linux.h" @@ -170,7 +171,7 @@ static uint32_t YCALCBLOCKS(uint64_t partition_size, uint32_t block_size) #include "yaffs_mtdif1.h" #include "yaffs_mtdif2.h" -unsigned int yaffs_traceMask = YAFFS_TRACE_BAD_BLOCKS | YAFFS_TRACE_ALWAYS; +unsigned int yaffs_trace_mask = YAFFS_TRACE_BAD_BLOCKS | YAFFS_TRACE_ALWAYS; unsigned int yaffs_wr_attempts = YAFFS_WR_ATTEMPTS; unsigned int yaffs_auto_checkpoint = 1; unsigned int yaffs_gc_control = 1; @@ -178,13 +179,13 @@ unsigned int yaffs_bg_enable = 1; /* Module Parameters */ #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) -module_param(yaffs_traceMask, uint, 0644); +module_param(yaffs_trace_mask, uint, 0644); module_param(yaffs_wr_attempts, uint, 0644); module_param(yaffs_auto_checkpoint, uint, 0644); module_param(yaffs_gc_control, uint, 0644); module_param(yaffs_bg_enable, uint, 0644); #else -MODULE_PARM(yaffs_traceMask, "i"); +MODULE_PARM(yaffs_trace_mask, "i"); MODULE_PARM(yaffs_wr_attempts, "i"); MODULE_PARM(yaffs_auto_checkpoint, "i"); MODULE_PARM(yaffs_gc_control, "i"); @@ -204,29 +205,28 @@ static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino); #endif #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 18)) -#define yaffs_InodeToObjectLV(iptr) ((iptr)->i_private) +#define yaffs_inode_to_obj_lv(iptr) ((iptr)->i_private) #else -#define yaffs_InodeToObjectLV(iptr) ((iptr)->u.generic_ip) +#define yaffs_inode_to_obj_lv(iptr) ((iptr)->u.generic_ip) #endif -#define yaffs_InodeToObject(iptr) ((yaffs_Object *)(yaffs_InodeToObjectLV(iptr))) -#define yaffs_DentryToObject(dptr) yaffs_InodeToObject((dptr)->d_inode) +#define yaffs_inode_to_obj(iptr) ((struct yaffs_obj *)(yaffs_inode_to_obj_lv(iptr))) +#define yaffs_dentry_to_obj(dptr) yaffs_inode_to_obj((dptr)->d_inode) #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) -#define yaffs_SuperToDevice(sb) ((yaffs_Device *)sb->s_fs_info) +#define yaffs_super_to_dev(sb) ((struct yaffs_dev *)sb->s_fs_info) #else -#define yaffs_SuperToDevice(sb) ((yaffs_Device *)sb->u.generic_sbp) +#define yaffs_super_to_dev(sb) ((struct yaffs_dev *)sb->u.generic_sbp) #endif - #define update_dir_time(dir) do {\ (dir)->i_ctime = (dir)->i_mtime = CURRENT_TIME; \ } while(0) - + static void yaffs_put_super(struct super_block *sb); static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, - loff_t *pos); + loff_t * pos); static ssize_t yaffs_hold_space(struct file *f); static void yaffs_release_space(struct file *f); @@ -240,7 +240,7 @@ static int yaffs_file_flush(struct file *file); static int yaffs_sync_object(struct file *file, int datasync); #else static int yaffs_sync_object(struct file *file, struct dentry *dentry, - int datasync); + int datasync); #endif static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir); @@ -249,24 +249,24 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir); static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *n); static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry, - struct nameidata *n); + struct nameidata *n); #else static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode); static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry); #endif static int yaffs_link(struct dentry *old_dentry, struct inode *dir, - struct dentry *dentry); + struct dentry *dentry); static int yaffs_unlink(struct inode *dir, struct dentry *dentry); static int yaffs_symlink(struct inode *dir, struct dentry *dentry, - const char *symname); + const char *symname); static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode); #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, - dev_t dev); + dev_t dev); #else static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, - int dev); + int dev); #endif static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry); @@ -308,31 +308,30 @@ static int yaffs_writepage(struct page *page); #ifdef CONFIG_YAFFS_XATTR int yaffs_setxattr(struct dentry *dentry, const char *name, - const void *value, size_t size, int flags); + const void *value, size_t size, int flags); ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff, - size_t size); + size_t size); int yaffs_removexattr(struct dentry *dentry, const char *name); ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size); #endif - #if (YAFFS_USE_WRITE_BEGIN_END != 0) static int yaffs_write_begin(struct file *filp, struct address_space *mapping, - loff_t pos, unsigned len, unsigned flags, - struct page **pagep, void **fsdata); + loff_t pos, unsigned len, unsigned flags, + struct page **pagep, void **fsdata); static int yaffs_write_end(struct file *filp, struct address_space *mapping, - loff_t pos, unsigned len, unsigned copied, - struct page *pg, void *fsdadata); + loff_t pos, unsigned len, unsigned copied, + struct page *pg, void *fsdadata); #else static int yaffs_prepare_write(struct file *f, struct page *pg, - unsigned offset, unsigned to); + unsigned offset, unsigned to); static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset, - unsigned to); + unsigned to); #endif -static int yaffs_readlink(struct dentry *dentry, char __user *buffer, - int buflen); +static int yaffs_readlink(struct dentry *dentry, char __user * buffer, + int buflen); #if (YAFFS_NEW_FOLLOW_LINK == 1) void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias); static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd); @@ -340,13 +339,12 @@ static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd); static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd); #endif -static void yaffs_MarkSuperBlockDirty(yaffs_Device *dev); +static void yaffs_touch_super(struct yaffs_dev *dev); static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin); static int yaffs_vfs_setattr(struct inode *, struct iattr *); - static struct address_space_operations yaffs_file_address_operations = { .readpage = yaffs_readpage, .writepage = yaffs_writepage, @@ -359,7 +357,6 @@ static struct address_space_operations yaffs_file_address_operations = { #endif }; - #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 22)) static const struct file_operations yaffs_file_operations = { .read = do_sync_read, @@ -404,14 +401,13 @@ static const struct file_operations yaffs_file_operations = { #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)) static void zero_user_segment(struct page *page, unsigned start, unsigned end) { - void * kaddr = kmap_atomic(page, KM_USER0); + void *kaddr = kmap_atomic(page, KM_USER0); memset(kaddr + start, 0, end - start); kunmap_atomic(kaddr, KM_USER0); flush_dcache_page(page); } #endif - static const struct inode_operations yaffs_file_inode_operations = { .setattr = yaffs_setattr, #ifdef CONFIG_YAFFS_XATTR @@ -483,11 +479,10 @@ static const struct super_operations yaffs_super_ops = { .write_super = yaffs_write_super, }; - -static int yaffs_vfs_setattr(struct inode *inode, struct iattr *attr) +static int yaffs_vfs_setattr(struct inode *inode, struct iattr *attr) { #ifdef YAFFS_USE_SETATTR_COPY - setattr_copy(inode,attr); + setattr_copy(inode, attr); return 0; #else return inode_setattr(inode, attr); @@ -495,54 +490,58 @@ static int yaffs_vfs_setattr(struct inode *inode, struct iattr *attr) } -static int yaffs_vfs_setsize(struct inode *inode, loff_t newsize) +static int yaffs_vfs_setsize(struct inode *inode, loff_t newsize) { #ifdef YAFFS_USE_TRUNCATE_SETSIZE - truncate_setsize(inode,newsize); + truncate_setsize(inode, newsize); return 0; #else - truncate_inode_pages(&inode->i_data,newsize); + truncate_inode_pages(&inode->i_data, newsize); return 0; #endif } -static unsigned yaffs_gc_control_callback(yaffs_Device *dev) +static unsigned yaffs_gc_control_callback(struct yaffs_dev *dev) { return yaffs_gc_control; } - -static void yaffs_GrossLock(yaffs_Device *dev) + +static void yaffs_gross_lock(struct yaffs_dev *dev) { T(YAFFS_TRACE_LOCK, (TSTR("yaffs locking %p\n"), current)); - down(&(yaffs_DeviceToLC(dev)->grossLock)); + mutex_lock(&(yaffs_dev_to_lc(dev)->gross_lock)); T(YAFFS_TRACE_LOCK, (TSTR("yaffs locked %p\n"), current)); } -static void yaffs_GrossUnlock(yaffs_Device *dev) +static void yaffs_gross_unlock(struct yaffs_dev *dev) { T(YAFFS_TRACE_LOCK, (TSTR("yaffs unlocking %p\n"), current)); - up(&(yaffs_DeviceToLC(dev)->grossLock)); + mutex_unlock(&(yaffs_dev_to_lc(dev)->gross_lock)); } #ifdef YAFFS_COMPILE_EXPORTFS -static struct inode * -yaffs2_nfs_get_inode(struct super_block *sb, uint64_t ino, uint32_t generation) +static struct inode *yaffs2_nfs_get_inode(struct super_block *sb, uint64_t ino, + uint32_t generation) { return Y_IGET(sb, ino); } -static struct dentry * -yaffs2_fh_to_dentry(struct super_block *sb, struct fid *fid, int fh_len, int fh_type) +static struct dentry *yaffs2_fh_to_dentry(struct super_block *sb, + struct fid *fid, int fh_len, + int fh_type) { - return generic_fh_to_dentry(sb, fid, fh_len, fh_type, yaffs2_nfs_get_inode) ; + return generic_fh_to_dentry(sb, fid, fh_len, fh_type, + yaffs2_nfs_get_inode); } -static struct dentry * - yaffs2_fh_to_parent(struct super_block *sb, struct fid *fid, int fh_len, int fh_type) +static struct dentry *yaffs2_fh_to_parent(struct super_block *sb, + struct fid *fid, int fh_len, + int fh_type) { - return generic_fh_to_parent(sb, fid, fh_len, fh_type, yaffs2_nfs_get_inode); + return generic_fh_to_parent(sb, fid, fh_len, fh_type, + yaffs2_nfs_get_inode); } struct dentry *yaffs2_get_parent(struct dentry *dentry) @@ -552,15 +551,15 @@ struct dentry *yaffs2_get_parent(struct dentry *dentry) struct dentry *parent = ERR_PTR(-ENOENT); struct inode *inode; unsigned long parent_ino; - yaffs_Object *d_obj; - yaffs_Object *parent_obj; + struct yaffs_obj *d_obj; + struct yaffs_obj *parent_obj; - d_obj = yaffs_InodeToObject(dentry->d_inode); + d_obj = yaffs_inode_to_obj(dentry->d_inode); if (d_obj) { parent_obj = d_obj->parent; if (parent_obj) { - parent_ino = yaffs_GetObjectInode(parent_obj); + parent_ino = yaffs_get_obj_inode(parent_obj); inode = Y_IGET(sb, parent_ino); if (IS_ERR(inode)) { @@ -582,12 +581,11 @@ struct dentry *yaffs2_get_parent(struct dentry *dentry) * using the default functions of exportfs. */ -static struct export_operations yaffs_export_ops = -{ +static struct export_operations yaffs_export_ops = { .fh_to_dentry = yaffs2_fh_to_dentry, .fh_to_parent = yaffs2_fh_to_parent, .get_parent = yaffs2_get_parent, -} ; +}; #endif @@ -599,126 +597,127 @@ static struct export_operations yaffs_export_ops = * A search context iterates along a doubly linked list of siblings in the * directory. If the iterating object is deleted then this would corrupt * the list iteration, likely causing a crash. The search context avoids - * this by using the removeObjectCallback to move the search context to the + * this by using the remove_obj_fn to move the search context to the * next object before the object is deleted. * * Many readdirs (and thus seach conexts) may be alive simulateously so - * each yaffs_Device has a list of these. + * each struct yaffs_dev has a list of these. * * A seach context lives for the duration of a readdir. * * All these functions must be called while yaffs is locked. */ -struct yaffs_SearchContext { - yaffs_Device *dev; - yaffs_Object *dirObj; - yaffs_Object *nextReturn; - struct ylist_head others; +struct yaffs_search_context { + struct yaffs_dev *dev; + struct yaffs_obj *dir_obj; + struct yaffs_obj *next_return; + struct list_head others; }; /* - * yaffs_NewSearch() creates a new search context, initialises it and + * yaffs_new_search() creates a new search context, initialises it and * adds it to the device's search context list. * * Called at start of readdir. */ -static struct yaffs_SearchContext * yaffs_NewSearch(yaffs_Object *dir) +static struct yaffs_search_context *yaffs_new_search(struct yaffs_obj *dir) { - yaffs_Device *dev = dir->myDev; - struct yaffs_SearchContext *sc = YMALLOC(sizeof(struct yaffs_SearchContext)); - if(sc){ - sc->dirObj = dir; + struct yaffs_dev *dev = dir->my_dev; + struct yaffs_search_context *sc = + YMALLOC(sizeof(struct yaffs_search_context)); + if (sc) { + sc->dir_obj = dir; sc->dev = dev; - if( ylist_empty(&sc->dirObj->variant.directoryVariant.children)) - sc->nextReturn = NULL; + if (list_empty(&sc->dir_obj->variant.dir_variant.children)) + sc->next_return = NULL; else - sc->nextReturn = ylist_entry( - dir->variant.directoryVariant.children.next, - yaffs_Object,siblings); - YINIT_LIST_HEAD(&sc->others); - ylist_add(&sc->others,&(yaffs_DeviceToLC(dev)->searchContexts)); + sc->next_return = + list_entry(dir->variant.dir_variant.children.next, + struct yaffs_obj, siblings); + INIT_LIST_HEAD(&sc->others); + list_add(&sc->others, &(yaffs_dev_to_lc(dev)->search_contexts)); } return sc; } /* - * yaffs_EndSearch() disposes of a search context and cleans up. + * yaffs_search_end() disposes of a search context and cleans up. */ -static void yaffs_EndSearch(struct yaffs_SearchContext * sc) +static void yaffs_search_end(struct yaffs_search_context *sc) { - if(sc){ - ylist_del(&sc->others); + if (sc) { + list_del(&sc->others); YFREE(sc); } } /* - * yaffs_SearchAdvance() moves a search context to the next object. + * yaffs_search_advance() moves a search context to the next object. * Called when the search iterates or when an object removal causes * the search context to be moved to the next object. */ -static void yaffs_SearchAdvance(struct yaffs_SearchContext *sc) +static void yaffs_search_advance(struct yaffs_search_context *sc) { - if(!sc) - return; + if (!sc) + return; - if( sc->nextReturn == NULL || - ylist_empty(&sc->dirObj->variant.directoryVariant.children)) - sc->nextReturn = NULL; - else { - struct ylist_head *next = sc->nextReturn->siblings.next; + if (sc->next_return == NULL || + list_empty(&sc->dir_obj->variant.dir_variant.children)) + sc->next_return = NULL; + else { + struct list_head *next = sc->next_return->siblings.next; - if( next == &sc->dirObj->variant.directoryVariant.children) - sc->nextReturn = NULL; /* end of list */ - else - sc->nextReturn = ylist_entry(next,yaffs_Object,siblings); - } + if (next == &sc->dir_obj->variant.dir_variant.children) + sc->next_return = NULL; /* end of list */ + else + sc->next_return = + list_entry(next, struct yaffs_obj, siblings); + } } /* - * yaffs_RemoveObjectCallback() is called when an object is unlinked. + * yaffs_remove_obj_callback() is called when an object is unlinked. * We check open search contexts and advance any which are currently * on the object being iterated. */ -static void yaffs_RemoveObjectCallback(yaffs_Object *obj) +static void yaffs_remove_obj_callback(struct yaffs_obj *obj) { - struct ylist_head *i; - struct yaffs_SearchContext *sc; - struct ylist_head *search_contexts = &(yaffs_DeviceToLC(obj->myDev)->searchContexts); + struct list_head *i; + struct yaffs_search_context *sc; + struct list_head *search_contexts = + &(yaffs_dev_to_lc(obj->my_dev)->search_contexts); - - /* Iterate through the directory search contexts. - * If any are currently on the object being removed, then advance - * the search context to the next object to prevent a hanging pointer. - */ - ylist_for_each(i, search_contexts) { - if (i) { - sc = ylist_entry(i, struct yaffs_SearchContext,others); - if(sc->nextReturn == obj) - yaffs_SearchAdvance(sc); - } + /* Iterate through the directory search contexts. + * If any are currently on the object being removed, then advance + * the search context to the next object to prevent a hanging pointer. + */ + list_for_each(i, search_contexts) { + if (i) { + sc = list_entry(i, struct yaffs_search_context, others); + if (sc->next_return == obj) + yaffs_search_advance(sc); + } } } - /*-----------------------------------------------------------------*/ -static int yaffs_readlink(struct dentry *dentry, char __user *buffer, - int buflen) +static int yaffs_readlink(struct dentry *dentry, char __user * buffer, + int buflen) { unsigned char *alias; int ret; - yaffs_Device *dev = yaffs_DentryToObject(dentry)->myDev; + struct yaffs_dev *dev = yaffs_dentry_to_obj(dentry)->my_dev; - yaffs_GrossLock(dev); + yaffs_gross_lock(dev); - alias = yaffs_GetSymlinkAlias(yaffs_DentryToObject(dentry)); + alias = yaffs_get_symlink_alias(yaffs_dentry_to_obj(dentry)); - yaffs_GrossUnlock(dev); + yaffs_gross_unlock(dev); if (!alias) return -ENOMEM; @@ -730,45 +729,52 @@ static int yaffs_readlink(struct dentry *dentry, char __user *buffer, #if (YAFFS_NEW_FOLLOW_LINK == 1) static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd) +{ + void *ret; #else static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd) -#endif { + int ret +#endif unsigned char *alias; - int ret; - yaffs_Device *dev = yaffs_DentryToObject(dentry)->myDev; + int ret_int = 0; + struct yaffs_dev *dev = yaffs_dentry_to_obj(dentry)->my_dev; - yaffs_GrossLock(dev); + yaffs_gross_lock(dev); - alias = yaffs_GetSymlinkAlias(yaffs_DentryToObject(dentry)); - yaffs_GrossUnlock(dev); + alias = yaffs_get_symlink_alias(yaffs_dentry_to_obj(dentry)); + yaffs_gross_unlock(dev); if (!alias) { - ret = -ENOMEM; + ret_int = -ENOMEM; goto out; } - #if (YAFFS_NEW_FOLLOW_LINK == 1) nd_set_link(nd, alias); - ret = (int)alias; + ret = alias; out: - return ERR_PTR(ret); + if (ret_int) + ret = ERR_PTR(ret_int); + return ret; #else ret = vfs_follow_link(nd, alias); kfree(alias); out: + if (ret_int) + ret = ret_int; return ret; #endif } #if (YAFFS_NEW_FOLLOW_LINK == 1) -void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias) { +void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias) +{ kfree(alias); } #endif struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, - yaffs_Object *obj); + struct yaffs_obj *obj); /* * Lookup is used to find objects in the fs @@ -776,41 +782,39 @@ struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry, - struct nameidata *n) + struct nameidata *n) #else static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry) #endif { - yaffs_Object *obj; + struct yaffs_obj *obj; struct inode *inode = NULL; /* NCB 2.5/2.6 needs NULL here */ - yaffs_Device *dev = yaffs_InodeToObject(dir)->myDev; + struct yaffs_dev *dev = yaffs_inode_to_obj(dir)->my_dev; - if(current != yaffs_DeviceToLC(dev)->readdirProcess) - yaffs_GrossLock(dev); + if (current != yaffs_dev_to_lc(dev)->readdir_process) + yaffs_gross_lock(dev); T(YAFFS_TRACE_OS, - (TSTR("yaffs_lookup for %d:%s\n"), - yaffs_InodeToObject(dir)->objectId, dentry->d_name.name)); + (TSTR("yaffs_lookup for %d:%s\n"), + yaffs_inode_to_obj(dir)->obj_id, dentry->d_name.name)); - obj = yaffs_FindObjectByName(yaffs_InodeToObject(dir), - dentry->d_name.name); + obj = yaffs_find_by_name(yaffs_inode_to_obj(dir), dentry->d_name.name); - obj = yaffs_GetEquivalentObject(obj); /* in case it was a hardlink */ + obj = yaffs_get_equivalent_obj(obj); /* in case it was a hardlink */ /* Can't hold gross lock when calling yaffs_get_inode() */ - if(current != yaffs_DeviceToLC(dev)->readdirProcess) - yaffs_GrossUnlock(dev); + if (current != yaffs_dev_to_lc(dev)->readdir_process) + yaffs_gross_unlock(dev); if (obj) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_lookup found %d\n"), obj->objectId)); + (TSTR("yaffs_lookup found %d\n"), obj->obj_id)); inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj); if (inode) { - T(YAFFS_TRACE_OS, - (TSTR("yaffs_loookup dentry \n"))); + T(YAFFS_TRACE_OS, (TSTR("yaffs_loookup dentry \n"))); /* #if 0 asserted by NCB for 2.5/6 compatability - falls through to * d_add even if NULL inode */ #if 0 @@ -823,7 +827,7 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry) } } else { - T(YAFFS_TRACE_OS,(TSTR("yaffs_lookup not found\n"))); + T(YAFFS_TRACE_OS, (TSTR("yaffs_lookup not found\n"))); } @@ -834,7 +838,6 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry) return NULL; } - #ifdef YAFFS_HAS_PUT_INODE /* For now put inode is just for debugging @@ -843,26 +846,25 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry) static void yaffs_put_inode(struct inode *inode) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_put_inode: ino %d, count %d\n"), (int)inode->i_ino, - atomic_read(&inode->i_count))); + (TSTR("yaffs_put_inode: ino %d, count %d\n"), (int)inode->i_ino, + atomic_read(&inode->i_count))); } #endif - -static void yaffs_UnstitchObject(struct inode *inode, yaffs_Object *obj) +static void yaffs_unstitch_obj(struct inode *inode, struct yaffs_obj *obj) { /* Clear the association between the inode and - * the yaffs_Object. + * the struct yaffs_obj. */ - obj->myInode = NULL; - yaffs_InodeToObjectLV(inode) = NULL; + obj->my_inode = NULL; + yaffs_inode_to_obj_lv(inode) = NULL; /* If the object freeing was deferred, then the real * free happens now. * This should fix the inode inconsistency problem. */ - yaffs_HandleDeferedFree(obj); + yaffs_handle_defered_free(obj); } #ifdef YAFFS_HAS_EVICT_INODE @@ -870,38 +872,37 @@ static void yaffs_UnstitchObject(struct inode *inode, yaffs_Object *obj) * yaffs_clear_inode() and yaffs_delete_inode() * */ -static void yaffs_evict_inode( struct inode *inode) +static void yaffs_evict_inode(struct inode *inode) { - yaffs_Object *obj; - yaffs_Device *dev; + struct yaffs_obj *obj; + struct yaffs_dev *dev; int deleteme = 0; - obj = yaffs_InodeToObject(inode); + obj = yaffs_inode_to_obj(inode); T(YAFFS_TRACE_OS, - (TSTR("yaffs_evict_inode: ino %d, count %d %s\n"), (int)inode->i_ino, - atomic_read(&inode->i_count), - obj ? "object exists" : "null object")); + (TSTR("yaffs_evict_inode: ino %d, count %d %s\n"), (int)inode->i_ino, + atomic_read(&inode->i_count), + obj ? "object exists" : "null object")); if (!inode->i_nlink && !is_bad_inode(inode)) deleteme = 1; - truncate_inode_pages(&inode->i_data,0); + truncate_inode_pages(&inode->i_data, 0); end_writeback(inode); - if(deleteme && obj){ - dev = obj->myDev; - yaffs_GrossLock(dev); - yaffs_DeleteObject(obj); - yaffs_GrossUnlock(dev); + if (deleteme && obj) { + dev = obj->my_dev; + yaffs_gross_lock(dev); + yaffs_del_obj(obj); + yaffs_gross_unlock(dev); } if (obj) { - dev = obj->myDev; - yaffs_GrossLock(dev); - yaffs_UnstitchObject(inode,obj); - yaffs_GrossUnlock(dev); + dev = obj->my_dev; + yaffs_gross_lock(dev); + yaffs_unstitch_obj(inode, obj); + yaffs_gross_unlock(dev); } - } #else @@ -914,21 +915,21 @@ static void yaffs_evict_inode( struct inode *inode) static void yaffs_clear_inode(struct inode *inode) { - yaffs_Object *obj; - yaffs_Device *dev; + struct yaffs_obj *obj; + struct yaffs_dev *dev; - obj = yaffs_InodeToObject(inode); + obj = yaffs_inode_to_obj(inode); T(YAFFS_TRACE_OS, - (TSTR("yaffs_clear_inode: ino %d, count %d %s\n"), (int)inode->i_ino, - atomic_read(&inode->i_count), - obj ? "object exists" : "null object")); + (TSTR("yaffs_clear_inode: ino %d, count %d %s\n"), (int)inode->i_ino, + atomic_read(&inode->i_count), + obj ? "object exists" : "null object")); if (obj) { - dev = obj->myDev; - yaffs_GrossLock(dev); - yaffs_UnstitchObject(inode,obj); - yaffs_GrossUnlock(dev); + dev = obj->my_dev; + yaffs_gross_lock(dev); + yaffs_unstitch_obj(inode, obj); + yaffs_gross_unlock(dev); } } @@ -940,19 +941,19 @@ static void yaffs_clear_inode(struct inode *inode) */ static void yaffs_delete_inode(struct inode *inode) { - yaffs_Object *obj = yaffs_InodeToObject(inode); - yaffs_Device *dev; + struct yaffs_obj *obj = yaffs_inode_to_obj(inode); + struct yaffs_dev *dev; T(YAFFS_TRACE_OS, - (TSTR("yaffs_delete_inode: ino %d, count %d %s\n"), (int)inode->i_ino, - atomic_read(&inode->i_count), - obj ? "object exists" : "null object")); + (TSTR("yaffs_delete_inode: ino %d, count %d %s\n"), (int)inode->i_ino, + atomic_read(&inode->i_count), + obj ? "object exists" : "null object")); if (obj) { - dev = obj->myDev; - yaffs_GrossLock(dev); - yaffs_DeleteObject(obj); - yaffs_GrossUnlock(dev); + dev = obj->my_dev; + yaffs_gross_lock(dev); + yaffs_del_obj(obj); + yaffs_gross_unlock(dev); } #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 13)) truncate_inode_pages(&inode->i_data, 0); @@ -961,26 +962,25 @@ static void yaffs_delete_inode(struct inode *inode) } #endif - #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) static int yaffs_file_flush(struct file *file, fl_owner_t id) #else static int yaffs_file_flush(struct file *file) #endif { - yaffs_Object *obj = yaffs_DentryToObject(file->f_dentry); + struct yaffs_obj *obj = yaffs_dentry_to_obj(file->f_dentry); - yaffs_Device *dev = obj->myDev; + struct yaffs_dev *dev = obj->my_dev; T(YAFFS_TRACE_OS, - (TSTR("yaffs_file_flush object %d (%s)\n"), obj->objectId, - obj->dirty ? "dirty" : "clean")); + (TSTR("yaffs_file_flush object %d (%s)\n"), obj->obj_id, + obj->dirty ? "dirty" : "clean")); - yaffs_GrossLock(dev); + yaffs_gross_lock(dev); - yaffs_FlushFile(obj, 1, 0); + yaffs_flush_file(obj, 1, 0); - yaffs_GrossUnlock(dev); + yaffs_gross_unlock(dev); return 0; } @@ -989,20 +989,20 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg) { /* Lifted from jffs2 */ - yaffs_Object *obj; + struct yaffs_obj *obj; unsigned char *pg_buf; int ret; - yaffs_Device *dev; + struct yaffs_dev *dev; T(YAFFS_TRACE_OS, - (TSTR("yaffs_readpage_nolock at %08x, size %08x\n"), - (unsigned)(pg->index << PAGE_CACHE_SHIFT), - (unsigned)PAGE_CACHE_SIZE)); + (TSTR("yaffs_readpage_nolock at %08x, size %08x\n"), + (unsigned)(pg->index << PAGE_CACHE_SHIFT), + (unsigned)PAGE_CACHE_SIZE)); - obj = yaffs_DentryToObject(f->f_dentry); + obj = yaffs_dentry_to_obj(f->f_dentry); - dev = obj->myDev; + dev = obj->my_dev; #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) BUG_ON(!PageLocked(pg)); @@ -1014,13 +1014,12 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg) pg_buf = kmap(pg); /* FIXME: Can kmap fail? */ - yaffs_GrossLock(dev); + yaffs_gross_lock(dev); - ret = yaffs_ReadDataFromFile(obj, pg_buf, - pg->index << PAGE_CACHE_SHIFT, - PAGE_CACHE_SIZE); + ret = yaffs_file_rd(obj, pg_buf, + pg->index << PAGE_CACHE_SHIFT, PAGE_CACHE_SIZE); - yaffs_GrossUnlock(dev); + yaffs_gross_unlock(dev); if (ret >= 0) ret = 0; @@ -1052,7 +1051,7 @@ static int yaffs_readpage(struct file *f, struct page *pg) int ret; T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage\n"))); - ret=yaffs_readpage_unlock(f, pg); + ret = yaffs_readpage_unlock(f, pg); T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage done\n"))); return ret; } @@ -1065,14 +1064,14 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc) static int yaffs_writepage(struct page *page) #endif { - yaffs_Device *dev; + struct yaffs_dev *dev; struct address_space *mapping = page->mapping; struct inode *inode; unsigned long end_index; char *buffer; - yaffs_Object *obj; - int nWritten = 0; - unsigned nBytes; + struct yaffs_obj *obj; + int n_written = 0; + unsigned n_bytes; loff_t i_size; if (!mapping) @@ -1084,20 +1083,21 @@ static int yaffs_writepage(struct page *page) end_index = i_size >> PAGE_CACHE_SHIFT; - if(page->index < end_index) - nBytes = PAGE_CACHE_SIZE; + if (page->index < end_index) + n_bytes = PAGE_CACHE_SIZE; else { - nBytes = i_size & (PAGE_CACHE_SIZE -1); + n_bytes = i_size & (PAGE_CACHE_SIZE - 1); - if (page->index > end_index || !nBytes) { + if (page->index > end_index || !n_bytes) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_writepage at %08x, inode size = %08x!!!\n"), - (unsigned)(page->index << PAGE_CACHE_SHIFT), - (unsigned)inode->i_size)); + (TSTR + ("yaffs_writepage at %08x, inode size = %08x!!!\n"), + (unsigned)(page->index << PAGE_CACHE_SHIFT), + (unsigned)inode->i_size)); T(YAFFS_TRACE_OS, - (TSTR(" -> don't care!!\n"))); + (TSTR(" -> don't care!!\n"))); - zero_user_segment(page,0,PAGE_CACHE_SIZE); + zero_user_segment(page, 0, PAGE_CACHE_SIZE); set_page_writeback(page); unlock_page(page); end_page_writeback(page); @@ -1105,34 +1105,34 @@ static int yaffs_writepage(struct page *page) } } - if(nBytes != PAGE_CACHE_SIZE) - zero_user_segment(page,nBytes,PAGE_CACHE_SIZE); + if (n_bytes != PAGE_CACHE_SIZE) + zero_user_segment(page, n_bytes, PAGE_CACHE_SIZE); get_page(page); buffer = kmap(page); - obj = yaffs_InodeToObject(inode); - dev = obj->myDev; - yaffs_GrossLock(dev); + obj = yaffs_inode_to_obj(inode); + dev = obj->my_dev; + yaffs_gross_lock(dev); T(YAFFS_TRACE_OS, - (TSTR("yaffs_writepage at %08x, size %08x\n"), - (unsigned)(page->index << PAGE_CACHE_SHIFT), nBytes)); + (TSTR("yaffs_writepage at %08x, size %08x\n"), + (unsigned)(page->index << PAGE_CACHE_SHIFT), n_bytes)); T(YAFFS_TRACE_OS, - (TSTR("writepag0: obj = %05x, ino = %05x\n"), - (int)obj->variant.fileVariant.fileSize, (int)inode->i_size)); + (TSTR("writepag0: obj = %05x, ino = %05x\n"), + (int)obj->variant.file_variant.file_size, (int)inode->i_size)); - nWritten = yaffs_WriteDataToFile(obj, buffer, - page->index << PAGE_CACHE_SHIFT, nBytes, 0); + n_written = yaffs_wr_file(obj, buffer, + page->index << PAGE_CACHE_SHIFT, n_bytes, 0); - yaffs_MarkSuperBlockDirty(dev); + yaffs_touch_super(dev); T(YAFFS_TRACE_OS, - (TSTR("writepag1: obj = %05x, ino = %05x\n"), - (int)obj->variant.fileVariant.fileSize, (int)inode->i_size)); + (TSTR("writepag1: obj = %05x, ino = %05x\n"), + (int)obj->variant.file_variant.file_size, (int)inode->i_size)); - yaffs_GrossUnlock(dev); + yaffs_gross_unlock(dev); kunmap(page); set_page_writeback(page); @@ -1140,14 +1140,13 @@ static int yaffs_writepage(struct page *page) end_page_writeback(page); put_page(page); - return (nWritten == nBytes) ? 0 : -ENOSPC; + return (n_written == n_bytes) ? 0 : -ENOSPC; } - #if (YAFFS_USE_WRITE_BEGIN_END > 0) static int yaffs_write_begin(struct file *filp, struct address_space *mapping, - loff_t pos, unsigned len, unsigned flags, - struct page **pagep, void **fsdata) + loff_t pos, unsigned len, unsigned flags, + struct page **pagep, void **fsdata) { struct page *pg = NULL; pgoff_t index = pos >> PAGE_CACHE_SHIFT; @@ -1164,12 +1163,12 @@ static int yaffs_write_begin(struct file *filp, struct address_space *mapping, *pagep = pg; if (!pg) { - ret = -ENOMEM; + ret = -ENOMEM; goto out; } T(YAFFS_TRACE_OS, - (TSTR("start yaffs_write_begin index %d(%x) uptodate %d\n"), - (int)index,(int)index,Page_Uptodate(pg) ? 1 : 0)); + (TSTR("start yaffs_write_begin index %d(%x) uptodate %d\n"), + (int)index, (int)index, Page_Uptodate(pg) ? 1 : 0)); /* Get fs space */ space_held = yaffs_hold_space(filp); @@ -1194,7 +1193,7 @@ static int yaffs_write_begin(struct file *filp, struct address_space *mapping, out: T(YAFFS_TRACE_OS, - (TSTR("end yaffs_write_begin fail returning %d\n"), ret)); + (TSTR("end yaffs_write_begin fail returning %d\n"), ret)); if (space_held) yaffs_release_space(filp); if (pg) { @@ -1207,7 +1206,7 @@ out: #else static int yaffs_prepare_write(struct file *f, struct page *pg, - unsigned offset, unsigned to) + unsigned offset, unsigned to) { T(YAFFS_TRACE_OS, (TSTR("yaffs_prepair_write\n"))); @@ -1219,8 +1218,8 @@ static int yaffs_prepare_write(struct file *f, struct page *pg, #if (YAFFS_USE_WRITE_BEGIN_END > 0) static int yaffs_write_end(struct file *filp, struct address_space *mapping, - loff_t pos, unsigned len, unsigned copied, - struct page *pg, void *fsdadata) + loff_t pos, unsigned len, unsigned copied, + struct page *pg, void *fsdadata) { int ret = 0; void *addr, *kva; @@ -1230,15 +1229,15 @@ static int yaffs_write_end(struct file *filp, struct address_space *mapping, addr = kva + offset_into_page; T(YAFFS_TRACE_OS, - ("yaffs_write_end addr %p pos %x nBytes %d\n", - addr,(unsigned)pos, copied)); + ("yaffs_write_end addr %p pos %x n_bytes %d\n", + addr, (unsigned)pos, copied)); ret = yaffs_file_write(filp, addr, copied, &pos); if (ret != copied) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_write_end not same size ret %d copied %d\n"), - ret, copied)); + (TSTR("yaffs_write_end not same size ret %d copied %d\n"), + ret, copied)); SetPageError(pg); } else { /* Nothing */ @@ -1254,13 +1253,13 @@ static int yaffs_write_end(struct file *filp, struct address_space *mapping, #else static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset, - unsigned to) + unsigned to) { void *addr, *kva; loff_t pos = (((loff_t) pg->index) << PAGE_CACHE_SHIFT) + offset; - int nBytes = to - offset; - int nWritten; + int n_bytes = to - offset; + int n_written; unsigned spos = pos; unsigned saddr; @@ -1268,18 +1267,19 @@ static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset, kva = kmap(pg); addr = kva + offset; - saddr = (unsigned) addr; + saddr = (unsigned)addr; T(YAFFS_TRACE_OS, - (TSTR("yaffs_commit_write addr %x pos %x nBytes %d\n"), - saddr, spos, nBytes)); + (TSTR("yaffs_commit_write addr %x pos %x n_bytes %d\n"), + saddr, spos, n_bytes)); - nWritten = yaffs_file_write(f, addr, nBytes, &pos); + n_written = yaffs_file_write(f, addr, n_bytes, &pos); - if (nWritten != nBytes) { + if (n_written != n_bytes) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_commit_write not same size nWritten %d nBytes %d\n"), - nWritten, nBytes)); + (TSTR + ("yaffs_commit_write not same size n_written %d n_bytes %d\n"), + n_written, n_bytes)); SetPageError(pg); } else { /* Nothing */ @@ -1288,22 +1288,21 @@ static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset, kunmap(pg); T(YAFFS_TRACE_OS, - (TSTR("yaffs_commit_write returning %d\n"), - nWritten == nBytes ? 0 : nWritten)); + (TSTR("yaffs_commit_write returning %d\n"), + n_written == n_bytes ? 0 : n_written)); - return nWritten == nBytes ? 0 : nWritten; + return n_written == n_bytes ? 0 : n_written; } #endif - -static void yaffs_FillInodeFromObject(struct inode *inode, yaffs_Object *obj) +static void yaffs_fill_inode_from_obj(struct inode *inode, + struct yaffs_obj *obj) { if (inode && obj) { - /* Check mode against the variant type and attempt to repair if broken. */ - __u32 mode = obj->yst_mode; - switch (obj->variantType) { + u32 mode = obj->yst_mode; + switch (obj->variant_type) { case YAFFS_OBJECT_TYPE_FILE: if (!S_ISREG(mode)) { obj->yst_mode &= ~S_IFMT; @@ -1335,7 +1334,7 @@ static void yaffs_FillInodeFromObject(struct inode *inode, yaffs_Object *obj) inode->i_flags |= S_NOATIME; - inode->i_ino = obj->objectId; + inode->i_ino = obj->obj_id; inode->i_mode = obj->yst_mode; inode->i_uid = obj->yst_uid; inode->i_gid = obj->yst_gid; @@ -1357,31 +1356,32 @@ static void yaffs_FillInodeFromObject(struct inode *inode, yaffs_Object *obj) inode->i_mtime = obj->yst_mtime; inode->i_ctime = obj->yst_ctime; #endif - inode->i_size = yaffs_GetObjectFileLength(obj); + inode->i_size = yaffs_get_obj_length(obj); inode->i_blocks = (inode->i_size + 511) >> 9; - inode->i_nlink = yaffs_GetObjectLinkCount(obj); + inode->i_nlink = yaffs_get_obj_link_count(obj); T(YAFFS_TRACE_OS, - (TSTR("yaffs_FillInode mode %x uid %d gid %d size %d count %d\n"), - inode->i_mode, inode->i_uid, inode->i_gid, - (int)inode->i_size, atomic_read(&inode->i_count))); + (TSTR + ("yaffs_fill_inode mode %x uid %d gid %d size %d count %d\n"), + inode->i_mode, inode->i_uid, inode->i_gid, + (int)inode->i_size, atomic_read(&inode->i_count))); switch (obj->yst_mode & S_IFMT) { default: /* fifo, device or socket */ #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) init_special_inode(inode, obj->yst_mode, - old_decode_dev(obj->yst_rdev)); + old_decode_dev(obj->yst_rdev)); #else init_special_inode(inode, obj->yst_mode, - (dev_t) (obj->yst_rdev)); + (dev_t) (obj->yst_rdev)); #endif break; case S_IFREG: /* file */ inode->i_op = &yaffs_file_inode_operations; inode->i_fop = &yaffs_file_operations; inode->i_mapping->a_ops = - &yaffs_file_address_operations; + &yaffs_file_address_operations; break; case S_IFDIR: /* directory */ inode->i_op = &yaffs_dir_inode_operations; @@ -1392,63 +1392,63 @@ static void yaffs_FillInodeFromObject(struct inode *inode, yaffs_Object *obj) break; } - yaffs_InodeToObjectLV(inode) = obj; + yaffs_inode_to_obj_lv(inode) = obj; - obj->myInode = inode; + obj->my_inode = inode; } else { T(YAFFS_TRACE_OS, - (TSTR("yaffs_FileInode invalid parameters\n"))); + (TSTR("yaffs_fill_inode invalid parameters\n"))); } } struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, - yaffs_Object *obj) + struct yaffs_obj *obj) { struct inode *inode; if (!sb) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_get_inode for NULL super_block!!\n"))); + (TSTR("yaffs_get_inode for NULL super_block!!\n"))); return NULL; } if (!obj) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_get_inode for NULL object!!\n"))); + (TSTR("yaffs_get_inode for NULL object!!\n"))); return NULL; } T(YAFFS_TRACE_OS, - (TSTR("yaffs_get_inode for object %d\n"), obj->objectId)); + (TSTR("yaffs_get_inode for object %d\n"), obj->obj_id)); - inode = Y_IGET(sb, obj->objectId); + inode = Y_IGET(sb, obj->obj_id); if (IS_ERR(inode)) return NULL; /* NB Side effect: iget calls back to yaffs_read_inode(). */ /* iget also increments the inode's i_count */ - /* NB You can't be holding grossLock or deadlock will happen! */ + /* NB You can't be holding gross_lock or deadlock will happen! */ return inode; } static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, - loff_t *pos) + loff_t * pos) { - yaffs_Object *obj; - int nWritten, ipos; + struct yaffs_obj *obj; + int n_written, ipos; struct inode *inode; - yaffs_Device *dev; + struct yaffs_dev *dev; - obj = yaffs_DentryToObject(f->f_dentry); + obj = yaffs_dentry_to_obj(f->f_dentry); - dev = obj->myDev; + dev = obj->my_dev; - yaffs_GrossLock(dev); + yaffs_gross_lock(dev); inode = f->f_dentry->d_inode; @@ -1459,37 +1459,36 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, if (!obj) T(YAFFS_TRACE_OS, - (TSTR("yaffs_file_write: hey obj is null!\n"))); + (TSTR("yaffs_file_write: hey obj is null!\n"))); else T(YAFFS_TRACE_OS, - (TSTR("yaffs_file_write about to write writing %u(%x) bytes" + (TSTR("yaffs_file_write about to write writing %u(%x) bytes" "to object %d at %d(%x)\n"), - (unsigned) n, (unsigned) n, obj->objectId, ipos,ipos)); + (unsigned)n, (unsigned)n, obj->obj_id, ipos, ipos)); - nWritten = yaffs_WriteDataToFile(obj, buf, ipos, n, 0); + n_written = yaffs_wr_file(obj, buf, ipos, n, 0); - yaffs_MarkSuperBlockDirty(dev); + yaffs_touch_super(dev); T(YAFFS_TRACE_OS, - (TSTR("yaffs_file_write: %d(%x) bytes written\n"), - (unsigned )n,(unsigned)n)); + (TSTR("yaffs_file_write: %d(%x) bytes written\n"), + (unsigned)n, (unsigned)n)); - if (nWritten > 0) { - ipos += nWritten; + if (n_written > 0) { + ipos += n_written; *pos = ipos; if (ipos > inode->i_size) { inode->i_size = ipos; inode->i_blocks = (ipos + 511) >> 9; T(YAFFS_TRACE_OS, - (TSTR("yaffs_file_write size updated to %d bytes, " - "%d blocks\n"), - ipos, (int)(inode->i_blocks))); + (TSTR("yaffs_file_write size updated to %d bytes, " + "%d blocks\n"), ipos, (int)(inode->i_blocks))); } } - yaffs_GrossUnlock(dev); - return (nWritten == 0) && (n > 0) ? -ENOSPC : nWritten; + yaffs_gross_unlock(dev); + return (n_written == 0) && (n > 0) ? -ENOSPC : n_written; } /* Space holding and freeing is done to ensure we have space available for write_begin/end */ @@ -1498,49 +1497,45 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, static ssize_t yaffs_hold_space(struct file *f) { - yaffs_Object *obj; - yaffs_Device *dev; + struct yaffs_obj *obj; + struct yaffs_dev *dev; - int nFreeChunks; + int n_free_chunks; + obj = yaffs_dentry_to_obj(f->f_dentry); - obj = yaffs_DentryToObject(f->f_dentry); + dev = obj->my_dev; - dev = obj->myDev; + yaffs_gross_lock(dev); - yaffs_GrossLock(dev); + n_free_chunks = yaffs_get_n_free_chunks(dev); - nFreeChunks = yaffs_GetNumberOfFreeChunks(dev); + yaffs_gross_unlock(dev); - yaffs_GrossUnlock(dev); - - return (nFreeChunks > 20) ? 1 : 0; + return (n_free_chunks > 20) ? 1 : 0; } static void yaffs_release_space(struct file *f) { - yaffs_Object *obj; - yaffs_Device *dev; + struct yaffs_obj *obj; + struct yaffs_dev *dev; + obj = yaffs_dentry_to_obj(f->f_dentry); - obj = yaffs_DentryToObject(f->f_dentry); + dev = obj->my_dev; - dev = obj->myDev; + yaffs_gross_lock(dev); - yaffs_GrossLock(dev); - - - yaffs_GrossUnlock(dev); + yaffs_gross_unlock(dev); } - static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin) { long long retval; lock_kernel(); - switch (origin){ + switch (origin) { case 2: offset += i_size_read(file->f_path.dentry->d_inode); break; @@ -1549,7 +1544,7 @@ static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin) } retval = -EINVAL; - if (offset >= 0){ + if (offset >= 0) { if (offset != file->f_pos) file->f_pos = offset; @@ -1559,60 +1554,61 @@ static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin) return retval; } - static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir) { - yaffs_Object *obj; - yaffs_Device *dev; - struct yaffs_SearchContext *sc; + struct yaffs_obj *obj; + struct yaffs_dev *dev; + struct yaffs_search_context *sc; struct inode *inode = f->f_dentry->d_inode; unsigned long offset, curoffs; - yaffs_Object *l; - int retVal = 0; + struct yaffs_obj *l; + int ret_val = 0; char name[YAFFS_MAX_NAME_LENGTH + 1]; - obj = yaffs_DentryToObject(f->f_dentry); - dev = obj->myDev; + obj = yaffs_dentry_to_obj(f->f_dentry); + dev = obj->my_dev; - yaffs_GrossLock(dev); + yaffs_gross_lock(dev); - yaffs_DeviceToLC(dev)->readdirProcess = current; + yaffs_dev_to_lc(dev)->readdir_process = current; offset = f->f_pos; - sc = yaffs_NewSearch(obj); - if(!sc){ - retVal = -ENOMEM; - goto out; - } + sc = yaffs_new_search(obj); + if (!sc) { + ret_val = -ENOMEM; + goto out; + } - T(YAFFS_TRACE_OS, (TSTR("yaffs_readdir: starting at %d\n"), (int)offset)); + T(YAFFS_TRACE_OS, + (TSTR("yaffs_readdir: starting at %d\n"), (int)offset)); if (offset == 0) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_readdir: entry . ino %d \n"), - (int)inode->i_ino)); - yaffs_GrossUnlock(dev); - if (filldir(dirent, ".", 1, offset, inode->i_ino, DT_DIR) < 0){ - yaffs_GrossLock(dev); + (TSTR("yaffs_readdir: entry . ino %d \n"), + (int)inode->i_ino)); + yaffs_gross_unlock(dev); + if (filldir(dirent, ".", 1, offset, inode->i_ino, DT_DIR) < 0) { + yaffs_gross_lock(dev); goto out; } - yaffs_GrossLock(dev); + yaffs_gross_lock(dev); offset++; f->f_pos++; } if (offset == 1) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_readdir: entry .. ino %d \n"), - (int)f->f_dentry->d_parent->d_inode->i_ino)); - yaffs_GrossUnlock(dev); + (TSTR("yaffs_readdir: entry .. ino %d \n"), + (int)f->f_dentry->d_parent->d_inode->i_ino)); + yaffs_gross_unlock(dev); if (filldir(dirent, "..", 2, offset, - f->f_dentry->d_parent->d_inode->i_ino, DT_DIR) < 0){ - yaffs_GrossLock(dev); + f->f_dentry->d_parent->d_inode->i_ino, + DT_DIR) < 0) { + yaffs_gross_lock(dev); goto out; } - yaffs_GrossLock(dev); + yaffs_gross_lock(dev); offset++; f->f_pos++; } @@ -1627,49 +1623,44 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir) f->f_version = inode->i_version; } - while(sc->nextReturn){ + while (sc->next_return) { curoffs++; - l = sc->nextReturn; + l = sc->next_return; if (curoffs >= offset) { - int this_inode = yaffs_GetObjectInode(l); - int this_type = yaffs_GetObjectType(l); + int this_inode = yaffs_get_obj_inode(l); + int this_type = yaffs_get_obj_type(l); - yaffs_GetObjectName(l, name, - YAFFS_MAX_NAME_LENGTH + 1); + yaffs_get_obj_name(l, name, YAFFS_MAX_NAME_LENGTH + 1); T(YAFFS_TRACE_OS, (TSTR("yaffs_readdir: %s inode %d\n"), - name, yaffs_GetObjectInode(l))); + name, yaffs_get_obj_inode(l))); - yaffs_GrossUnlock(dev); + yaffs_gross_unlock(dev); if (filldir(dirent, - name, - strlen(name), - offset, - this_inode, - this_type) < 0){ - yaffs_GrossLock(dev); + name, + strlen(name), + offset, this_inode, this_type) < 0) { + yaffs_gross_lock(dev); goto out; } - yaffs_GrossLock(dev); + yaffs_gross_lock(dev); offset++; f->f_pos++; } - yaffs_SearchAdvance(sc); + yaffs_search_advance(sc); } out: - yaffs_EndSearch(sc); - yaffs_DeviceToLC(dev)->readdirProcess = NULL; - yaffs_GrossUnlock(dev); + yaffs_search_end(sc); + yaffs_dev_to_lc(dev)->readdir_process = NULL; + yaffs_gross_unlock(dev); - return retVal; + return ret_val; } - - /* * File creation. Allocate an inode, and we're done.. */ @@ -1682,66 +1673,68 @@ out: #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, - dev_t rdev) + dev_t rdev) #else static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, - int rdev) + int rdev) #endif { struct inode *inode; - yaffs_Object *obj = NULL; - yaffs_Device *dev; + struct yaffs_obj *obj = NULL; + struct yaffs_dev *dev; - yaffs_Object *parent = yaffs_InodeToObject(dir); + struct yaffs_obj *parent = yaffs_inode_to_obj(dir); int error = -ENOSPC; uid_t uid = YCRED(current)->fsuid; - gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid; + gid_t gid = + (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid; if ((dir->i_mode & S_ISGID) && S_ISDIR(mode)) mode |= S_ISGID; if (parent) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_mknod: parent object %d type %d\n"), - parent->objectId, parent->variantType)); + (TSTR("yaffs_mknod: parent object %d type %d\n"), + parent->obj_id, parent->variant_type)); } else { T(YAFFS_TRACE_OS, - (TSTR("yaffs_mknod: could not get parent object\n"))); + (TSTR("yaffs_mknod: could not get parent object\n"))); return -EPERM; } T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making oject for %s, " - "mode %x dev %x\n"), - dentry->d_name.name, mode, rdev)); + "mode %x dev %x\n"), + dentry->d_name.name, mode, rdev)); - dev = parent->myDev; + dev = parent->my_dev; - yaffs_GrossLock(dev); + yaffs_gross_lock(dev); switch (mode & S_IFMT) { default: /* Special (socket, fifo, device...) */ T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making special\n"))); #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) - obj = yaffs_MknodSpecial(parent, dentry->d_name.name, mode, uid, - gid, old_encode_dev(rdev)); + obj = + yaffs_create_special(parent, dentry->d_name.name, mode, uid, + gid, old_encode_dev(rdev)); #else - obj = yaffs_MknodSpecial(parent, dentry->d_name.name, mode, uid, - gid, rdev); + obj = + yaffs_create_special(parent, dentry->d_name.name, mode, uid, + gid, rdev); #endif break; case S_IFREG: /* file */ T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making file\n"))); - obj = yaffs_MknodFile(parent, dentry->d_name.name, mode, uid, - gid); + obj = yaffs_create_file(parent, dentry->d_name.name, mode, uid, + gid); break; case S_IFDIR: /* directory */ - T(YAFFS_TRACE_OS, - (TSTR("yaffs_mknod: making directory\n"))); - obj = yaffs_MknodDirectory(parent, dentry->d_name.name, mode, - uid, gid); + T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making directory\n"))); + obj = yaffs_create_dir(parent, dentry->d_name.name, mode, + uid, gid); break; case S_IFLNK: /* symlink */ T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making symlink\n"))); @@ -1750,20 +1743,19 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, } /* Can not call yaffs_get_inode() with gross lock held */ - yaffs_GrossUnlock(dev); + yaffs_gross_unlock(dev); if (obj) { inode = yaffs_get_inode(dir->i_sb, mode, rdev, obj); d_instantiate(dentry, inode); update_dir_time(dir); T(YAFFS_TRACE_OS, - (TSTR("yaffs_mknod created object %d count = %d\n"), - obj->objectId, atomic_read(&inode->i_count))); + (TSTR("yaffs_mknod created object %d count = %d\n"), + obj->obj_id, atomic_read(&inode->i_count))); error = 0; - yaffs_FillInodeFromObject(dir,parent); + yaffs_fill_inode_from_obj(dir, parent); } else { - T(YAFFS_TRACE_OS, - (TSTR("yaffs_mknod failed making object\n"))); + T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod failed making object\n"))); error = -ENOMEM; } @@ -1772,10 +1764,10 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode) { - int retVal; + int ret_val; T(YAFFS_TRACE_OS, (TSTR("yaffs_mkdir\n"))); - retVal = yaffs_mknod(dir, dentry, mode | S_IFDIR, 0); - return retVal; + ret_val = yaffs_mknod(dir, dentry, mode | S_IFDIR, 0); + return ret_val; } #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) @@ -1785,37 +1777,36 @@ static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode, static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode) #endif { - T(YAFFS_TRACE_OS,(TSTR("yaffs_create\n"))); + T(YAFFS_TRACE_OS, (TSTR("yaffs_create\n"))); return yaffs_mknod(dir, dentry, mode | S_IFREG, 0); } static int yaffs_unlink(struct inode *dir, struct dentry *dentry) { - int retVal; + int ret_val; - yaffs_Device *dev; - yaffs_Object *obj; + struct yaffs_dev *dev; + struct yaffs_obj *obj; T(YAFFS_TRACE_OS, - (TSTR("yaffs_unlink %d:%s\n"), - (int)(dir->i_ino), - dentry->d_name.name)); - obj = yaffs_InodeToObject(dir); - dev = obj->myDev; + (TSTR("yaffs_unlink %d:%s\n"), + (int)(dir->i_ino), dentry->d_name.name)); + obj = yaffs_inode_to_obj(dir); + dev = obj->my_dev; - yaffs_GrossLock(dev); + yaffs_gross_lock(dev); - retVal = yaffs_Unlink(obj, dentry->d_name.name); + ret_val = yaffs_unlinker(obj, dentry->d_name.name); - if (retVal == YAFFS_OK) { + if (ret_val == YAFFS_OK) { dentry->d_inode->i_nlink--; dir->i_version++; - yaffs_GrossUnlock(dev); + yaffs_gross_unlock(dev); mark_inode_dirty(dentry->d_inode); update_dir_time(dir); return 0; } - yaffs_GrossUnlock(dev); + yaffs_gross_unlock(dev); return -ENOTEMPTY; } @@ -1823,37 +1814,38 @@ static int yaffs_unlink(struct inode *dir, struct dentry *dentry) * Create a link... */ static int yaffs_link(struct dentry *old_dentry, struct inode *dir, - struct dentry *dentry) + struct dentry *dentry) { struct inode *inode = old_dentry->d_inode; - yaffs_Object *obj = NULL; - yaffs_Object *link = NULL; - yaffs_Device *dev; + struct yaffs_obj *obj = NULL; + struct yaffs_obj *link = NULL; + struct yaffs_dev *dev; T(YAFFS_TRACE_OS, (TSTR("yaffs_link\n"))); - obj = yaffs_InodeToObject(inode); - dev = obj->myDev; + obj = yaffs_inode_to_obj(inode); + dev = obj->my_dev; - yaffs_GrossLock(dev); + yaffs_gross_lock(dev); - if (!S_ISDIR(inode->i_mode)) /* Don't link directories */ - link = yaffs_Link(yaffs_InodeToObject(dir), dentry->d_name.name, - obj); + if (!S_ISDIR(inode->i_mode)) /* Don't link directories */ + link = + yaffs_link_obj(yaffs_inode_to_obj(dir), dentry->d_name.name, + obj); if (link) { - old_dentry->d_inode->i_nlink = yaffs_GetObjectLinkCount(obj); + old_dentry->d_inode->i_nlink = yaffs_get_obj_link_count(obj); d_instantiate(dentry, old_dentry->d_inode); atomic_inc(&old_dentry->d_inode->i_count); T(YAFFS_TRACE_OS, - (TSTR("yaffs_link link count %d i_count %d\n"), - old_dentry->d_inode->i_nlink, - atomic_read(&old_dentry->d_inode->i_count))); + (TSTR("yaffs_link link count %d i_count %d\n"), + old_dentry->d_inode->i_nlink, + atomic_read(&old_dentry->d_inode->i_count))); } - yaffs_GrossUnlock(dev); + yaffs_gross_unlock(dev); - if (link){ + if (link) { update_dir_time(dir); return 0; } @@ -1862,20 +1854,21 @@ static int yaffs_link(struct dentry *old_dentry, struct inode *dir, } static int yaffs_symlink(struct inode *dir, struct dentry *dentry, - const char *symname) + const char *symname) { - yaffs_Object *obj; - yaffs_Device *dev; + struct yaffs_obj *obj; + struct yaffs_dev *dev; uid_t uid = YCRED(current)->fsuid; - gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid; + gid_t gid = + (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid; T(YAFFS_TRACE_OS, (TSTR("yaffs_symlink\n"))); - dev = yaffs_InodeToObject(dir)->myDev; - yaffs_GrossLock(dev); - obj = yaffs_MknodSymLink(yaffs_InodeToObject(dir), dentry->d_name.name, - S_IFLNK | S_IRWXUGO, uid, gid, symname); - yaffs_GrossUnlock(dev); + dev = yaffs_inode_to_obj(dir)->my_dev; + yaffs_gross_lock(dev); + obj = yaffs_create_symlink(yaffs_inode_to_obj(dir), dentry->d_name.name, + S_IFLNK | S_IRWXUGO, uid, gid, symname); + yaffs_gross_unlock(dev); if (obj) { struct inode *inode; @@ -1896,25 +1889,24 @@ static int yaffs_symlink(struct inode *dir, struct dentry *dentry, static int yaffs_sync_object(struct file *file, int datasync) #else static int yaffs_sync_object(struct file *file, struct dentry *dentry, - int datasync) + int datasync) #endif { - yaffs_Object *obj; - yaffs_Device *dev; + struct yaffs_obj *obj; + struct yaffs_dev *dev; #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 34)) struct dentry *dentry = file->f_path.dentry; #endif - obj = yaffs_DentryToObject(dentry); + obj = yaffs_dentry_to_obj(dentry); - dev = obj->myDev; + dev = obj->my_dev; - T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, - (TSTR("yaffs_sync_object\n"))); - yaffs_GrossLock(dev); - yaffs_FlushFile(obj, 1, datasync); - yaffs_GrossUnlock(dev); + T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, (TSTR("yaffs_sync_object\n"))); + yaffs_gross_lock(dev); + yaffs_flush_file(obj, 1, datasync); + yaffs_gross_unlock(dev); return 0; } @@ -1926,46 +1918,44 @@ static int yaffs_sync_object(struct file *file, struct dentry *dentry, static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry) { - yaffs_Device *dev; - int retVal = YAFFS_FAIL; - yaffs_Object *target; + struct yaffs_dev *dev; + int ret_val = YAFFS_FAIL; + struct yaffs_obj *target; T(YAFFS_TRACE_OS, (TSTR("yaffs_rename\n"))); - dev = yaffs_InodeToObject(old_dir)->myDev; + dev = yaffs_inode_to_obj(old_dir)->my_dev; - yaffs_GrossLock(dev); + yaffs_gross_lock(dev); /* Check if the target is an existing directory that is not empty. */ - target = yaffs_FindObjectByName(yaffs_InodeToObject(new_dir), - new_dentry->d_name.name); + target = yaffs_find_by_name(yaffs_inode_to_obj(new_dir), + new_dentry->d_name.name); - - - if (target && target->variantType == YAFFS_OBJECT_TYPE_DIRECTORY && - !ylist_empty(&target->variant.directoryVariant.children)) { + if (target && target->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY && + !list_empty(&target->variant.dir_variant.children)) { T(YAFFS_TRACE_OS, (TSTR("target is non-empty dir\n"))); - retVal = YAFFS_FAIL; + ret_val = YAFFS_FAIL; } else { /* Now does unlinking internally using shadowing mechanism */ - T(YAFFS_TRACE_OS, (TSTR("calling yaffs_RenameObject\n"))); + T(YAFFS_TRACE_OS, (TSTR("calling yaffs_rename_obj\n"))); - retVal = yaffs_RenameObject(yaffs_InodeToObject(old_dir), - old_dentry->d_name.name, - yaffs_InodeToObject(new_dir), - new_dentry->d_name.name); + ret_val = yaffs_rename_obj(yaffs_inode_to_obj(old_dir), + old_dentry->d_name.name, + yaffs_inode_to_obj(new_dir), + new_dentry->d_name.name); } - yaffs_GrossUnlock(dev); + yaffs_gross_unlock(dev); - if (retVal == YAFFS_OK) { + if (ret_val == YAFFS_OK) { if (target) { new_dentry->d_inode->i_nlink--; mark_inode_dirty(new_dentry->d_inode); } - + update_dir_time(old_dir); - if(old_dir != new_dir) + if (old_dir != new_dir) update_dir_time(new_dir); return 0; } else { @@ -1977,105 +1967,97 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr) { struct inode *inode = dentry->d_inode; int error = 0; - yaffs_Device *dev; + struct yaffs_dev *dev; T(YAFFS_TRACE_OS, - (TSTR("yaffs_setattr of object %d\n"), - yaffs_InodeToObject(inode)->objectId)); + (TSTR("yaffs_setattr of object %d\n"), + yaffs_inode_to_obj(inode)->obj_id)); - /* Fail if a requested resize >= 2GB */ - if (attr->ia_valid & ATTR_SIZE && - (attr->ia_size >> 31)) + /* Fail if a requested resize >= 2GB */ + if (attr->ia_valid & ATTR_SIZE && (attr->ia_size >> 31)) error = -EINVAL; if (error == 0) error = inode_change_ok(inode, attr); if (error == 0) { int result; - if (!error){ + if (!error) { error = yaffs_vfs_setattr(inode, attr); - T(YAFFS_TRACE_OS,(TSTR("inode_setattr called\n"))); - if (attr->ia_valid & ATTR_SIZE){ - yaffs_vfs_setsize(inode,attr->ia_size); - inode->i_blocks = (inode->i_size + 511) >> 9; + T(YAFFS_TRACE_OS, (TSTR("inode_setattr called\n"))); + if (attr->ia_valid & ATTR_SIZE) { + yaffs_vfs_setsize(inode, attr->ia_size); + inode->i_blocks = (inode->i_size + 511) >> 9; } } - dev = yaffs_InodeToObject(inode)->myDev; - if (attr->ia_valid & ATTR_SIZE){ - T(YAFFS_TRACE_OS,(TSTR("resize to %d(%x)\n"), - (int)(attr->ia_size),(int)(attr->ia_size))); + dev = yaffs_inode_to_obj(inode)->my_dev; + if (attr->ia_valid & ATTR_SIZE) { + T(YAFFS_TRACE_OS, (TSTR("resize to %d(%x)\n"), + (int)(attr->ia_size), + (int)(attr->ia_size))); } - yaffs_GrossLock(dev); - result = yaffs_SetAttributes(yaffs_InodeToObject(inode), attr); - if(result == YAFFS_OK) { + yaffs_gross_lock(dev); + result = yaffs_set_attribs(yaffs_inode_to_obj(inode), attr); + if (result == YAFFS_OK) { error = 0; } else { error = -EPERM; } - yaffs_GrossUnlock(dev); + yaffs_gross_unlock(dev); } - T(YAFFS_TRACE_OS, - (TSTR("yaffs_setattr done returning %d\n"),error)); + T(YAFFS_TRACE_OS, (TSTR("yaffs_setattr done returning %d\n"), error)); return error; } #ifdef CONFIG_YAFFS_XATTR int yaffs_setxattr(struct dentry *dentry, const char *name, - const void *value, size_t size, int flags) + const void *value, size_t size, int flags) { struct inode *inode = dentry->d_inode; int error = 0; - yaffs_Device *dev; - yaffs_Object *obj = yaffs_InodeToObject(inode); - - T(YAFFS_TRACE_OS, - (TSTR("yaffs_setxattr of object %d\n"), - obj->objectId)); + struct yaffs_dev *dev; + struct yaffs_obj *obj = yaffs_inode_to_obj(inode); + T(YAFFS_TRACE_OS, (TSTR("yaffs_setxattr of object %d\n"), obj->obj_id)); if (error == 0) { int result; - dev = obj->myDev; - yaffs_GrossLock(dev); - result = yaffs_SetXAttribute(obj, name, value, size, flags); - if(result == YAFFS_OK) + dev = obj->my_dev; + yaffs_gross_lock(dev); + result = yaffs_set_xattrib(obj, name, value, size, flags); + if (result == YAFFS_OK) error = 0; - else if(result < 0) + else if (result < 0) error = result; - yaffs_GrossUnlock(dev); + yaffs_gross_unlock(dev); } - T(YAFFS_TRACE_OS, - (TSTR("yaffs_setxattr done returning %d\n"),error)); + T(YAFFS_TRACE_OS, (TSTR("yaffs_setxattr done returning %d\n"), error)); return error; } - -ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff, - size_t size) +ssize_t yaffs_getxattr(struct dentry * dentry, const char *name, void *buff, + size_t size) { struct inode *inode = dentry->d_inode; int error = 0; - yaffs_Device *dev; - yaffs_Object *obj = yaffs_InodeToObject(inode); + struct yaffs_dev *dev; + struct yaffs_obj *obj = yaffs_inode_to_obj(inode); T(YAFFS_TRACE_OS, - (TSTR("yaffs_getxattr \"%s\" from object %d\n"), - name, obj->objectId)); + (TSTR("yaffs_getxattr \"%s\" from object %d\n"), name, obj->obj_id)); if (error == 0) { - dev = obj->myDev; - yaffs_GrossLock(dev); - error = yaffs_GetXAttribute(obj, name, buff, size); - yaffs_GrossUnlock(dev); + dev = obj->my_dev; + yaffs_gross_lock(dev); + error = yaffs_get_xattrib(obj, name, buff, size); + yaffs_gross_unlock(dev); } - T(YAFFS_TRACE_OS, - (TSTR("yaffs_getxattr done returning %d\n"),error)); + T(YAFFS_TRACE_OS, (TSTR("yaffs_getxattr done returning %d\n"), error)); return error; } @@ -2084,220 +2066,212 @@ int yaffs_removexattr(struct dentry *dentry, const char *name) { struct inode *inode = dentry->d_inode; int error = 0; - yaffs_Device *dev; - yaffs_Object *obj = yaffs_InodeToObject(inode); + struct yaffs_dev *dev; + struct yaffs_obj *obj = yaffs_inode_to_obj(inode); T(YAFFS_TRACE_OS, - (TSTR("yaffs_removexattr of object %d\n"), - obj->objectId)); - + (TSTR("yaffs_removexattr of object %d\n"), obj->obj_id)); if (error == 0) { int result; - dev = obj->myDev; - yaffs_GrossLock(dev); - result = yaffs_RemoveXAttribute(obj, name); - if(result == YAFFS_OK) + dev = obj->my_dev; + yaffs_gross_lock(dev); + result = yaffs_remove_xattrib(obj, name); + if (result == YAFFS_OK) error = 0; - else if(result < 0) + else if (result < 0) error = result; - yaffs_GrossUnlock(dev); + yaffs_gross_unlock(dev); } T(YAFFS_TRACE_OS, - (TSTR("yaffs_removexattr done returning %d\n"),error)); + (TSTR("yaffs_removexattr done returning %d\n"), error)); return error; } -ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size) +ssize_t yaffs_listxattr(struct dentry * dentry, char *buff, size_t size) { struct inode *inode = dentry->d_inode; int error = 0; - yaffs_Device *dev; - yaffs_Object *obj = yaffs_InodeToObject(inode); + struct yaffs_dev *dev; + struct yaffs_obj *obj = yaffs_inode_to_obj(inode); T(YAFFS_TRACE_OS, - (TSTR("yaffs_listxattr of object %d\n"), - obj->objectId)); - + (TSTR("yaffs_listxattr of object %d\n"), obj->obj_id)); if (error == 0) { - dev = obj->myDev; - yaffs_GrossLock(dev); - error = yaffs_ListXAttributes(obj, buff, size); - yaffs_GrossUnlock(dev); + dev = obj->my_dev; + yaffs_gross_lock(dev); + error = yaffs_list_xattrib(obj, buff, size); + yaffs_gross_unlock(dev); } - T(YAFFS_TRACE_OS, - (TSTR("yaffs_listxattr done returning %d\n"),error)); + T(YAFFS_TRACE_OS, (TSTR("yaffs_listxattr done returning %d\n"), error)); return error; } #endif - #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf) { - yaffs_Device *dev = yaffs_DentryToObject(dentry)->myDev; + struct yaffs_dev *dev = yaffs_dentry_to_obj(dentry)->my_dev; struct super_block *sb = dentry->d_sb; #elif (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) static int yaffs_statfs(struct super_block *sb, struct kstatfs *buf) { - yaffs_Device *dev = yaffs_SuperToDevice(sb); + struct yaffs_dev *dev = yaffs_super_to_dev(sb); #else static int yaffs_statfs(struct super_block *sb, struct statfs *buf) { - yaffs_Device *dev = yaffs_SuperToDevice(sb); + struct yaffs_dev *dev = yaffs_super_to_dev(sb); #endif T(YAFFS_TRACE_OS, (TSTR("yaffs_statfs\n"))); - yaffs_GrossLock(dev); + yaffs_gross_lock(dev); buf->f_type = YAFFS_MAGIC; buf->f_bsize = sb->s_blocksize; buf->f_namelen = 255; - if (dev->nDataBytesPerChunk & (dev->nDataBytesPerChunk - 1)) { + if (dev->data_bytes_per_chunk & (dev->data_bytes_per_chunk - 1)) { /* Do this if chunk size is not a power of 2 */ - uint64_t bytesInDev; - uint64_t bytesFree; + uint64_t bytes_in_dev; + uint64_t bytes_free; - bytesInDev = ((uint64_t)((dev->param.endBlock - dev->param.startBlock + 1))) * - ((uint64_t)(dev->param.nChunksPerBlock * dev->nDataBytesPerChunk)); + bytes_in_dev = + ((uint64_t) + ((dev->param.end_block - dev->param.start_block + + 1))) * ((uint64_t) (dev->param.chunks_per_block * + dev->data_bytes_per_chunk)); - do_div(bytesInDev, sb->s_blocksize); /* bytesInDev becomes the number of blocks */ - buf->f_blocks = bytesInDev; + do_div(bytes_in_dev, sb->s_blocksize); /* bytes_in_dev becomes the number of blocks */ + buf->f_blocks = bytes_in_dev; - bytesFree = ((uint64_t)(yaffs_GetNumberOfFreeChunks(dev))) * - ((uint64_t)(dev->nDataBytesPerChunk)); + bytes_free = ((uint64_t) (yaffs_get_n_free_chunks(dev))) * + ((uint64_t) (dev->data_bytes_per_chunk)); - do_div(bytesFree, sb->s_blocksize); + do_div(bytes_free, sb->s_blocksize); - buf->f_bfree = bytesFree; + buf->f_bfree = bytes_free; - } else if (sb->s_blocksize > dev->nDataBytesPerChunk) { + } else if (sb->s_blocksize > dev->data_bytes_per_chunk) { buf->f_blocks = - (dev->param.endBlock - dev->param.startBlock + 1) * - dev->param.nChunksPerBlock / - (sb->s_blocksize / dev->nDataBytesPerChunk); + (dev->param.end_block - dev->param.start_block + 1) * + dev->param.chunks_per_block / + (sb->s_blocksize / dev->data_bytes_per_chunk); buf->f_bfree = - yaffs_GetNumberOfFreeChunks(dev) / - (sb->s_blocksize / dev->nDataBytesPerChunk); + yaffs_get_n_free_chunks(dev) / + (sb->s_blocksize / dev->data_bytes_per_chunk); } else { buf->f_blocks = - (dev->param.endBlock - dev->param.startBlock + 1) * - dev->param.nChunksPerBlock * - (dev->nDataBytesPerChunk / sb->s_blocksize); + (dev->param.end_block - dev->param.start_block + 1) * + dev->param.chunks_per_block * + (dev->data_bytes_per_chunk / sb->s_blocksize); buf->f_bfree = - yaffs_GetNumberOfFreeChunks(dev) * - (dev->nDataBytesPerChunk / sb->s_blocksize); + yaffs_get_n_free_chunks(dev) * + (dev->data_bytes_per_chunk / sb->s_blocksize); } buf->f_files = 0; buf->f_ffree = 0; buf->f_bavail = buf->f_bfree; - yaffs_GrossUnlock(dev); + yaffs_gross_unlock(dev); return 0; } - - -static void yaffs_FlushInodes(struct super_block *sb) +static void yaffs_flush_inodes(struct super_block *sb) { struct inode *iptr; - yaffs_Object *obj; - - list_for_each_entry(iptr,&sb->s_inodes, i_sb_list){ - obj = yaffs_InodeToObject(iptr); - if(obj){ + struct yaffs_obj *obj; + + list_for_each_entry(iptr, &sb->s_inodes, i_sb_list) { + obj = yaffs_inode_to_obj(iptr); + if (obj) { T(YAFFS_TRACE_OS, (TSTR("flushing obj %d\n"), - obj->objectId)); - yaffs_FlushFile(obj,1,0); + obj->obj_id)); + yaffs_flush_file(obj, 1, 0); } } } - -static void yaffs_FlushSuperBlock(struct super_block *sb, int do_checkpoint) +static void yaffs_flush_super(struct super_block *sb, int do_checkpoint) { - yaffs_Device *dev = yaffs_SuperToDevice(sb); - if(!dev) + struct yaffs_dev *dev = yaffs_super_to_dev(sb); + if (!dev) return; - - yaffs_FlushInodes(sb); - yaffs_UpdateDirtyDirectories(dev); - yaffs_FlushEntireDeviceCache(dev); - if(do_checkpoint) - yaffs_CheckpointSave(dev); + + yaffs_flush_inodes(sb); + yaffs_update_dirty_dirs(dev); + yaffs_flush_whole_cache(dev); + if (do_checkpoint) + yaffs_checkpoint_save(dev); } - -static unsigned yaffs_bg_gc_urgency(yaffs_Device *dev) +static unsigned yaffs_bg_gc_urgency(struct yaffs_dev *dev) { - unsigned erasedChunks = dev->nErasedBlocks * dev->param.nChunksPerBlock; - struct yaffs_LinuxContext *context = yaffs_DeviceToLC(dev); - unsigned scatteredFree = 0; /* Free chunks not in an erased block */ + unsigned erased_chunks = + dev->n_erased_blocks * dev->param.chunks_per_block; + struct yaffs_linux_context *context = yaffs_dev_to_lc(dev); + unsigned scattered = 0; /* Free chunks not in an erased block */ - if(erasedChunks < dev->nFreeChunks) - scatteredFree = (dev->nFreeChunks - erasedChunks); + if (erased_chunks < dev->n_free_chunks) + scattered = (dev->n_free_chunks - erased_chunks); - if(!context->bgRunning) + if (!context->bg_running) return 0; - else if(scatteredFree < (dev->param.nChunksPerBlock * 2)) + else if (scattered < (dev->param.chunks_per_block * 2)) return 0; - else if(erasedChunks > dev->nFreeChunks/2) + else if (erased_chunks > dev->n_free_chunks / 2) return 0; - else if(erasedChunks > dev->nFreeChunks/4) + else if (erased_chunks > dev->n_free_chunks / 4) return 1; else return 2; } -static int yaffs_do_sync_fs(struct super_block *sb, - int request_checkpoint) +static int yaffs_do_sync_fs(struct super_block *sb, int request_checkpoint) { - yaffs_Device *dev = yaffs_SuperToDevice(sb); + struct yaffs_dev *dev = yaffs_super_to_dev(sb); unsigned int oneshot_checkpoint = (yaffs_auto_checkpoint & 4); unsigned gc_urgent = yaffs_bg_gc_urgency(dev); int do_checkpoint; T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND, - (TSTR("yaffs_do_sync_fs: gc-urgency %d %s %s%s\n"), - gc_urgent, - sb->s_dirt ? "dirty" : "clean", - request_checkpoint ? "checkpoint requested" : "no checkpoint", - oneshot_checkpoint ? " one-shot" : "" )); + (TSTR("yaffs_do_sync_fs: gc-urgency %d %s %s%s\n"), + gc_urgent, + sb->s_dirt ? "dirty" : "clean", + request_checkpoint ? "checkpoint requested" : "no checkpoint", + oneshot_checkpoint ? " one-shot" : "")); - yaffs_GrossLock(dev); + yaffs_gross_lock(dev); do_checkpoint = ((request_checkpoint && !gc_urgent) || - oneshot_checkpoint) && - !dev->isCheckpointed; + oneshot_checkpoint) && !dev->is_checkpointed; if (sb->s_dirt || do_checkpoint) { - yaffs_FlushSuperBlock(sb, !dev->isCheckpointed && do_checkpoint); + yaffs_flush_super(sb, !dev->is_checkpointed && do_checkpoint); sb->s_dirt = 0; - if(oneshot_checkpoint) + if (oneshot_checkpoint) yaffs_auto_checkpoint &= ~4; } - yaffs_GrossUnlock(dev); + yaffs_gross_unlock(dev); return 0; } /* * yaffs background thread functions . - * yaffs_BackgroundThread() the thread function - * yaffs_BackgroundStart() launches the background thread. - * yaffs_BackgroundStop() cleans up the background thread. + * yaffs_bg_thread_fn() the thread function + * yaffs_bg_start() launches the background thread. + * yaffs_bg_stop() cleans up the background thread. * * NB: * The thread should only run after the yaffs is initialised @@ -2312,76 +2286,74 @@ void yaffs_background_waker(unsigned long data) wake_up_process((struct task_struct *)data); } -static int yaffs_BackgroundThread(void *data) +static int yaffs_bg_thread_fn(void *data) { - yaffs_Device *dev = (yaffs_Device *)data; - struct yaffs_LinuxContext *context = yaffs_DeviceToLC(dev); + struct yaffs_dev *dev = (struct yaffs_dev *)data; + struct yaffs_linux_context *context = yaffs_dev_to_lc(dev); unsigned long now = jiffies; unsigned long next_dir_update = now; unsigned long next_gc = now; unsigned long expires; unsigned int urgency; - int gcResult; + int gc_result; struct timer_list timer; T(YAFFS_TRACE_BACKGROUND, - (TSTR("yaffs_background starting for dev %p\n"), - (void *)dev)); + (TSTR("yaffs_background starting for dev %p\n"), (void *)dev)); #ifdef YAFFS_COMPILE_FREEZER set_freezable(); #endif - while(context->bgRunning){ - T(YAFFS_TRACE_BACKGROUND, - (TSTR("yaffs_background\n"))); + while (context->bg_running) { + T(YAFFS_TRACE_BACKGROUND, (TSTR("yaffs_background\n"))); - if(kthread_should_stop()) + if (kthread_should_stop()) break; #ifdef YAFFS_COMPILE_FREEZER - if(try_to_freeze()) + if (try_to_freeze()) continue; #endif - yaffs_GrossLock(dev); + yaffs_gross_lock(dev); now = jiffies; - if(time_after(now, next_dir_update) && yaffs_bg_enable){ - yaffs_UpdateDirtyDirectories(dev); + if (time_after(now, next_dir_update) && yaffs_bg_enable) { + yaffs_update_dirty_dirs(dev); next_dir_update = now + HZ; } - if(time_after(now,next_gc) && yaffs_bg_enable){ - if(!dev->isCheckpointed){ + if (time_after(now, next_gc) && yaffs_bg_enable) { + if (!dev->is_checkpointed) { urgency = yaffs_bg_gc_urgency(dev); - gcResult = yaffs_BackgroundGarbageCollect(dev, urgency); - if(urgency > 1) - next_gc = now + HZ/20+1; - else if(urgency > 0) - next_gc = now + HZ/10+1; + gc_result = yaffs_bg_gc(dev, urgency); + if (urgency > 1) + next_gc = now + HZ / 20 + 1; + else if (urgency > 0) + next_gc = now + HZ / 10 + 1; else next_gc = now + HZ * 2; - } else /* - * gc not running so set to next_dir_update - * to cut down on wake ups - */ + } else /* + * gc not running so set to next_dir_update + * to cut down on wake ups + */ next_gc = next_dir_update; } - yaffs_GrossUnlock(dev); + yaffs_gross_unlock(dev); #if 1 expires = next_dir_update; - if (time_before(next_gc,expires)) + if (time_before(next_gc, expires)) expires = next_gc; - if(time_before(expires,now)) + if (time_before(expires, now)) expires = now + HZ; Y_INIT_TIMER(&timer); - timer.expires = expires+1; - timer.data = (unsigned long) current; + timer.expires = expires + 1; + timer.data = (unsigned long)current; timer.function = yaffs_background_waker; - set_current_state(TASK_INTERRUPTIBLE); + set_current_state(TASK_INTERRUPTIBLE); add_timer(&timer); schedule(); del_timer_sync(&timer); @@ -2393,55 +2365,55 @@ static int yaffs_BackgroundThread(void *data) return 0; } -static int yaffs_BackgroundStart(yaffs_Device *dev) +static int yaffs_bg_start(struct yaffs_dev *dev) { int retval = 0; - struct yaffs_LinuxContext *context = yaffs_DeviceToLC(dev); + struct yaffs_linux_context *context = yaffs_dev_to_lc(dev); - if(dev->readOnly) + if (dev->read_only) return -1; - context->bgRunning = 1; + context->bg_running = 1; - context->bgThread = kthread_run(yaffs_BackgroundThread, - (void *)dev,"yaffs-bg-%d",context->mount_id); + context->bg_thread = kthread_run(yaffs_bg_thread_fn, + (void *)dev, "yaffs-bg-%d", + context->mount_id); - if(IS_ERR(context->bgThread)){ - retval = PTR_ERR(context->bgThread); - context->bgThread = NULL; - context->bgRunning = 0; + if (IS_ERR(context->bg_thread)) { + retval = PTR_ERR(context->bg_thread); + context->bg_thread = NULL; + context->bg_running = 0; } return retval; } -static void yaffs_BackgroundStop(yaffs_Device *dev) +static void yaffs_bg_stop(struct yaffs_dev *dev) { - struct yaffs_LinuxContext *ctxt = yaffs_DeviceToLC(dev); + struct yaffs_linux_context *ctxt = yaffs_dev_to_lc(dev); - ctxt->bgRunning = 0; + ctxt->bg_running = 0; - if( ctxt->bgThread){ - kthread_stop(ctxt->bgThread); - ctxt->bgThread = NULL; + if (ctxt->bg_thread) { + kthread_stop(ctxt->bg_thread); + ctxt->bg_thread = NULL; } } #else -static int yaffs_BackgroundThread(void *data) +static int yaffs_bg_thread_fn(void *data) { return 0; } -static int yaffs_BackgroundStart(yaffs_Device *dev) +static int yaffs_bg_start(struct yaffs_dev *dev) { return 0; } -static void yaffs_BackgroundStop(yaffs_Device *dev) +static void yaffs_bg_stop(struct yaffs_dev *dev) { } #endif - #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) static void yaffs_write_super(struct super_block *sb) #else @@ -2451,8 +2423,8 @@ static int yaffs_write_super(struct super_block *sb) unsigned request_checkpoint = (yaffs_auto_checkpoint >= 2); T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND, - (TSTR("yaffs_write_super%s\n"), - request_checkpoint ? " checkpt" : "")); + (TSTR("yaffs_write_super%s\n"), + request_checkpoint ? " checkpt" : "")); yaffs_do_sync_fs(sb, request_checkpoint); @@ -2461,7 +2433,6 @@ static int yaffs_write_super(struct super_block *sb) #endif } - #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) static int yaffs_sync_fs(struct super_block *sb, int wait) #else @@ -2471,8 +2442,7 @@ static int yaffs_sync_fs(struct super_block *sb) unsigned request_checkpoint = (yaffs_auto_checkpoint >= 1); T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, - (TSTR("yaffs_sync_fs%s\n"), - request_checkpoint ? " checkpt" : "")); + (TSTR("yaffs_sync_fs%s\n"), request_checkpoint ? " checkpt" : "")); yaffs_do_sync_fs(sb, request_checkpoint); @@ -2484,11 +2454,10 @@ static int yaffs_sync_fs(struct super_block *sb) static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino) { struct inode *inode; - yaffs_Object *obj; - yaffs_Device *dev = yaffs_SuperToDevice(sb); + struct yaffs_obj *obj; + struct yaffs_dev *dev = yaffs_super_to_dev(sb); - T(YAFFS_TRACE_OS, - (TSTR("yaffs_iget for %lu\n"), ino)); + T(YAFFS_TRACE_OS, (TSTR("yaffs_iget for %lu\n"), ino)); inode = iget_locked(sb, ino); if (!inode) @@ -2501,13 +2470,13 @@ static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino) * need to lock again. */ - yaffs_GrossLock(dev); + yaffs_gross_lock(dev); - obj = yaffs_FindObjectByNumber(dev, inode->i_ino); + obj = yaffs_find_by_number(dev, inode->i_ino); - yaffs_FillInodeFromObject(inode, obj); + yaffs_fill_inode_from_obj(inode, obj); - yaffs_GrossUnlock(dev); + yaffs_gross_unlock(dev); unlock_new_inode(inode); return inode; @@ -2522,68 +2491,66 @@ static void yaffs_read_inode(struct inode *inode) * need to lock again. */ - yaffs_Object *obj; - yaffs_Device *dev = yaffs_SuperToDevice(inode->i_sb); + struct yaffs_obj *obj; + struct yaffs_dev *dev = yaffs_super_to_dev(inode->i_sb); T(YAFFS_TRACE_OS, - (TSTR("yaffs_read_inode for %d\n"), (int)inode->i_ino)); + (TSTR("yaffs_read_inode for %d\n"), (int)inode->i_ino)); - if(current != yaffs_DeviceToLC(dev)->readdirProcess) - yaffs_GrossLock(dev); + if (current != yaffs_dev_to_lc(dev)->readdir_process) + yaffs_gross_lock(dev); - obj = yaffs_FindObjectByNumber(dev, inode->i_ino); + obj = yaffs_find_by_number(dev, inode->i_ino); - yaffs_FillInodeFromObject(inode, obj); + yaffs_fill_inode_from_obj(inode, obj); - if(current != yaffs_DeviceToLC(dev)->readdirProcess) - yaffs_GrossUnlock(dev); + if (current != yaffs_dev_to_lc(dev)->readdir_process) + yaffs_gross_unlock(dev); } #endif -static YLIST_HEAD(yaffs_context_list); -struct semaphore yaffs_context_lock; +static LIST_HEAD(yaffs_context_list); +struct mutex yaffs_context_lock; static void yaffs_put_super(struct super_block *sb) { - yaffs_Device *dev = yaffs_SuperToDevice(sb); + struct yaffs_dev *dev = yaffs_super_to_dev(sb); T(YAFFS_TRACE_OS, (TSTR("yaffs_put_super\n"))); T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND, - (TSTR("Shutting down yaffs background thread\n"))); - yaffs_BackgroundStop(dev); + (TSTR("Shutting down yaffs background thread\n"))); + yaffs_bg_stop(dev); T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND, - (TSTR("yaffs background thread shut down\n"))); + (TSTR("yaffs background thread shut down\n"))); - yaffs_GrossLock(dev); + yaffs_gross_lock(dev); - yaffs_FlushSuperBlock(sb,1); + yaffs_flush_super(sb, 1); - if (yaffs_DeviceToLC(dev)->putSuperFunc) - yaffs_DeviceToLC(dev)->putSuperFunc(sb); + if (yaffs_dev_to_lc(dev)->put_super_fn) + yaffs_dev_to_lc(dev)->put_super_fn(sb); + yaffs_deinitialise(dev); - yaffs_Deinitialise(dev); + yaffs_gross_unlock(dev); - yaffs_GrossUnlock(dev); + mutex_lock(&yaffs_context_lock); + list_del_init(&(yaffs_dev_to_lc(dev)->context_list)); + mutex_unlock(&yaffs_context_lock); - down(&yaffs_context_lock); - ylist_del_init(&(yaffs_DeviceToLC(dev)->contextList)); - up(&yaffs_context_lock); - - if (yaffs_DeviceToLC(dev)->spareBuffer) { - YFREE(yaffs_DeviceToLC(dev)->spareBuffer); - yaffs_DeviceToLC(dev)->spareBuffer = NULL; + if (yaffs_dev_to_lc(dev)->spare_buffer) { + YFREE(yaffs_dev_to_lc(dev)->spare_buffer); + yaffs_dev_to_lc(dev)->spare_buffer = NULL; } kfree(dev); } - -static void yaffs_MTDPutSuper(struct super_block *sb) +static void yaffs_mtd_put_super(struct super_block *sb) { - struct mtd_info *mtd = yaffs_DeviceToMtd(yaffs_SuperToDevice(sb)); + struct mtd_info *mtd = yaffs_dev_to_mtd(yaffs_super_to_dev(sb)); if (mtd->sync) mtd->sync(mtd); @@ -2591,17 +2558,16 @@ static void yaffs_MTDPutSuper(struct super_block *sb) put_mtd_device(mtd); } - -static void yaffs_MarkSuperBlockDirty(yaffs_Device *dev) +static void yaffs_touch_super(struct yaffs_dev *dev) { - struct super_block *sb = yaffs_DeviceToLC(dev)->superBlock; + struct super_block *sb = yaffs_dev_to_lc(dev)->super; - T(YAFFS_TRACE_OS, (TSTR("yaffs_MarkSuperBlockDirty() sb = %p\n"), sb)); + T(YAFFS_TRACE_OS, (TSTR("yaffs_touch_super() sb = %p\n"), sb)); if (sb) sb->s_dirt = 1; } -typedef struct { +struct yaffs_options { int inband_tags; int skip_checkpoint_read; int skip_checkpoint_write; @@ -2612,10 +2578,11 @@ typedef struct { int lazy_loading_overridden; int empty_lost_and_found; int empty_lost_and_found_overridden; -} yaffs_options; +}; #define MAX_OPT_LEN 30 -static int yaffs_parse_options(yaffs_options *options, const char *options_str) +static int yaffs_parse_options(struct yaffs_options *options, + const char *options_str) { char cur_opt[MAX_OPT_LEN + 1]; int p; @@ -2627,7 +2594,7 @@ static int yaffs_parse_options(yaffs_options *options, const char *options_str) memset(cur_opt, 0, MAX_OPT_LEN + 1); p = 0; - while(*options_str == ',') + while (*options_str == ',') options_str++; while (*options_str && *options_str != ',') { @@ -2640,24 +2607,24 @@ static int yaffs_parse_options(yaffs_options *options, const char *options_str) if (!strcmp(cur_opt, "inband-tags")) options->inband_tags = 1; - else if (!strcmp(cur_opt, "tags-ecc-off")){ + else if (!strcmp(cur_opt, "tags-ecc-off")) { options->tags_ecc_on = 0; - options->tags_ecc_overridden=1; - } else if (!strcmp(cur_opt, "tags-ecc-on")){ + options->tags_ecc_overridden = 1; + } else if (!strcmp(cur_opt, "tags-ecc-on")) { options->tags_ecc_on = 1; options->tags_ecc_overridden = 1; - } else if (!strcmp(cur_opt, "lazy-loading-off")){ + } else if (!strcmp(cur_opt, "lazy-loading-off")) { options->lazy_loading_enabled = 0; - options->lazy_loading_overridden=1; - } else if (!strcmp(cur_opt, "lazy-loading-on")){ + options->lazy_loading_overridden = 1; + } else if (!strcmp(cur_opt, "lazy-loading-on")) { options->lazy_loading_enabled = 1; options->lazy_loading_overridden = 1; - } else if (!strcmp(cur_opt, "empty-lost-and-found-off")){ + } else if (!strcmp(cur_opt, "empty-lost-and-found-off")) { options->empty_lost_and_found = 0; - options->empty_lost_and_found_overridden=1; - } else if (!strcmp(cur_opt, "empty-lost-and-found-on")){ + options->empty_lost_and_found_overridden = 1; + } else if (!strcmp(cur_opt, "empty-lost-and-found-on")) { options->empty_lost_and_found = 1; - options->empty_lost_and_found_overridden=1; + options->empty_lost_and_found_overridden = 1; } else if (!strcmp(cur_opt, "no-cache")) options->no_cache = 1; else if (!strcmp(cur_opt, "no-checkpoint-read")) @@ -2669,7 +2636,7 @@ static int yaffs_parse_options(yaffs_options *options, const char *options_str) options->skip_checkpoint_write = 1; } else { printk(KERN_INFO "yaffs: Bad mount option \"%s\"\n", - cur_opt); + cur_opt); error = 1; } } @@ -2677,36 +2644,35 @@ static int yaffs_parse_options(yaffs_options *options, const char *options_str) return error; } -static struct super_block *yaffs_internal_read_super(int yaffsVersion, - struct super_block *sb, - void *data, int silent) +static struct super_block *yaffs_internal_read_super(int yaffs_version, + struct super_block *sb, + void *data, int silent) { - int nBlocks; + int n_blocks; struct inode *inode = NULL; struct dentry *root; - yaffs_Device *dev = 0; + struct yaffs_dev *dev = 0; char devname_buf[BDEVNAME_SIZE + 1]; struct mtd_info *mtd; int err; char *data_str = (char *)data; - struct yaffs_LinuxContext *context = NULL; - yaffs_DeviceParam *param; + struct yaffs_linux_context *context = NULL; + struct yaffs_param *param; - int readOnly = 0; + int read_only = 0; - yaffs_options options; + struct yaffs_options options; unsigned mount_id; int found; - struct yaffs_LinuxContext *context_iterator; - struct ylist_head *l; + struct yaffs_linux_context *context_iterator; + struct list_head *l; sb->s_magic = YAFFS_MAGIC; sb->s_op = &yaffs_super_ops; sb->s_flags |= MS_NOATIME; - readOnly =((sb->s_flags & MS_RDONLY) != 0); - + read_only = ((sb->s_flags & MS_RDONLY) != 0); #ifdef YAFFS_COMPILE_EXPORTFS sb->s_export_op = &yaffs_export_ops; @@ -2721,8 +2687,7 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion, else printk(KERN_INFO "yaffs: dev is %d name is \"%s\" %s\n", sb->s_dev, - yaffs_devname(sb, devname_buf), - readOnly ? "ro" : "rw"); + yaffs_devname(sb, devname_buf), read_only ? "ro" : "rw"); if (!data_str) data_str = ""; @@ -2736,20 +2701,17 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion, return NULL; } - sb->s_blocksize = PAGE_CACHE_SIZE; sb->s_blocksize_bits = PAGE_CACHE_SHIFT; T(YAFFS_TRACE_OS, - (TSTR("yaffs_read_super: Using yaffs%d\n"), yaffsVersion)); + (TSTR("yaffs_read_super: Using yaffs%d\n"), yaffs_version)); T(YAFFS_TRACE_OS, - (TSTR("yaffs_read_super: block size %d\n"), - (int)(sb->s_blocksize))); + (TSTR("yaffs_read_super: block size %d\n"), (int)(sb->s_blocksize))); T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: Attempting MTD mount of %u.%u,\"%s\"\n"), - MAJOR(sb->s_dev), MINOR(sb->s_dev), - yaffs_devname(sb, devname_buf))); + (TSTR("yaffs: Attempting MTD mount of %u.%u,\"%s\"\n"), + MAJOR(sb->s_dev), MINOR(sb->s_dev), yaffs_devname(sb, devname_buf))); /* Check it's an mtd device..... */ if (MAJOR(sb->s_dev) != MTD_BLOCK_MAJOR) @@ -2759,15 +2721,15 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion, mtd = get_mtd_device(NULL, MINOR(sb->s_dev)); if (!mtd) { T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: MTD device #%u doesn't appear to exist\n"), - MINOR(sb->s_dev))); + (TSTR("yaffs: MTD device #%u doesn't appear to exist\n"), + MINOR(sb->s_dev))); return NULL; } /* Check it's NAND */ if (mtd->type != MTD_NANDFLASH) { T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: MTD device is not NAND it's type %d\n"), - mtd->type)); + (TSTR("yaffs: MTD device is not NAND it's type %d\n"), + mtd->type)); return NULL; } @@ -2789,28 +2751,24 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion, #ifdef CONFIG_YAFFS_AUTO_YAFFS2 - if (yaffsVersion == 1 && WRITE_SIZE(mtd) >= 2048) { - T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: auto selecting yaffs2\n"))); - yaffsVersion = 2; + if (yaffs_version == 1 && WRITE_SIZE(mtd) >= 2048) { + T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: auto selecting yaffs2\n"))); + yaffs_version = 2; } /* Added NCB 26/5/2006 for completeness */ - if (yaffsVersion == 2 && !options.inband_tags && WRITE_SIZE(mtd) == 512) { - T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: auto selecting yaffs1\n"))); - yaffsVersion = 1; + if (yaffs_version == 2 && !options.inband_tags + && WRITE_SIZE(mtd) == 512) { + T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: auto selecting yaffs1\n"))); + yaffs_version = 1; } - #endif - if (yaffsVersion == 2) { + if (yaffs_version == 2) { /* Check for version 2 style functions */ if (!mtd->erase || !mtd->block_isbad || - !mtd->block_markbad || - !mtd->read || - !mtd->write || + !mtd->block_markbad || !mtd->read || !mtd->write || #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) !mtd->read_oob || !mtd->write_oob) { #else @@ -2819,23 +2777,21 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion, #endif T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: MTD device does not support required " - "functions\n"))); + "functions\n"))); return NULL; } if ((WRITE_SIZE(mtd) < YAFFS_MIN_YAFFS2_CHUNK_SIZE || - mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) && + mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) && !options.inband_tags) { T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: MTD device does not have the " - "right page sizes\n"))); + "right page sizes\n"))); return NULL; } } else { /* Check for V1 style functions */ - if (!mtd->erase || - !mtd->read || - !mtd->write || + if (!mtd->erase || !mtd->read || !mtd->write || #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) !mtd->read_oob || !mtd->write_oob) { #else @@ -2844,7 +2800,7 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion, #endif T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: MTD device does not support required " - "functions\n"))); + "functions\n"))); return NULL; } @@ -2852,29 +2808,30 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion, mtd->oobsize != YAFFS_BYTES_PER_SPARE) { T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: MTD device does not support have the " - "right page sizes\n"))); + "right page sizes\n"))); return NULL; } } /* OK, so if we got here, we have an MTD that's NAND and looks * like it has the right capabilities - * Set the yaffs_Device up for mtd + * Set the struct yaffs_dev up for mtd */ - if (!readOnly && !(mtd->flags & MTD_WRITEABLE)){ - readOnly = 1; - printk(KERN_INFO "yaffs: mtd is read only, setting superblock read only"); + if (!read_only && !(mtd->flags & MTD_WRITEABLE)) { + read_only = 1; + printk(KERN_INFO + "yaffs: mtd is read only, setting superblock read only"); sb->s_flags |= MS_RDONLY; } - dev = kmalloc(sizeof(yaffs_Device), GFP_KERNEL); - context = kmalloc(sizeof(struct yaffs_LinuxContext),GFP_KERNEL); - - if(!dev || !context ){ - if(dev) + dev = kmalloc(sizeof(struct yaffs_dev), GFP_KERNEL); + context = kmalloc(sizeof(struct yaffs_linux_context), GFP_KERNEL); + + if (!dev || !context) { + if (dev) kfree(dev); - if(context) + if (context) kfree(context); dev = NULL; context = NULL; @@ -2884,182 +2841,180 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion, /* Deep shit could not allocate device structure */ T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs_read_super: Failed trying to allocate " - "yaffs_Device. \n"))); + "struct yaffs_dev. \n"))); return NULL; } - memset(dev, 0, sizeof(yaffs_Device)); + memset(dev, 0, sizeof(struct yaffs_dev)); param = &(dev->param); - memset(context,0,sizeof(struct yaffs_LinuxContext)); - dev->osContext = context; - YINIT_LIST_HEAD(&(context->contextList)); + memset(context, 0, sizeof(struct yaffs_linux_context)); + dev->os_context = context; + INIT_LIST_HEAD(&(context->context_list)); context->dev = dev; - context->superBlock = sb; + context->super = sb; - dev->readOnly = readOnly; + dev->read_only = read_only; #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) sb->s_fs_info = dev; #else sb->u.generic_sbp = dev; #endif - - dev->driverContext = mtd; + + dev->driver_context = mtd; param->name = mtd->name; /* Set up the memory size parameters.... */ - nBlocks = YCALCBLOCKS(mtd->size, (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK)); + n_blocks = + YCALCBLOCKS(mtd->size, + (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK)); - param->startBlock = 0; - param->endBlock = nBlocks - 1; - param->nChunksPerBlock = YAFFS_CHUNKS_PER_BLOCK; - param->totalBytesPerChunk = YAFFS_BYTES_PER_CHUNK; - param->nReservedBlocks = 5; - param->nShortOpCaches = (options.no_cache) ? 0 : 10; - param->inbandTags = options.inband_tags; + param->start_block = 0; + param->end_block = n_blocks - 1; + param->chunks_per_block = YAFFS_CHUNKS_PER_BLOCK; + param->total_bytes_per_chunk = YAFFS_BYTES_PER_CHUNK; + param->n_reserved_blocks = 5; + param->n_caches = (options.no_cache) ? 0 : 10; + param->inband_tags = options.inband_tags; #ifdef CONFIG_YAFFS_DISABLE_LAZY_LOAD - param->disableLazyLoad = 1; + param->disable_lazy_load = 1; #endif #ifdef CONFIG_YAFFS_XATTR - param->enableXattr = 1; + param->enable_xattr = 1; #endif - if(options.lazy_loading_overridden) - param->disableLazyLoad = !options.lazy_loading_enabled; + if (options.lazy_loading_overridden) + param->disable_lazy_load = !options.lazy_loading_enabled; #ifdef CONFIG_YAFFS_DISABLE_TAGS_ECC - param->noTagsECC = 1; + param->no_tags_ecc = 1; #endif #ifdef CONFIG_YAFFS_DISABLE_BACKGROUND #else - param->deferDirectoryUpdate = 1; + param->defered_dir_update = 1; #endif - if(options.tags_ecc_overridden) - param->noTagsECC = !options.tags_ecc_on; + if (options.tags_ecc_overridden) + param->no_tags_ecc = !options.tags_ecc_on; #ifdef CONFIG_YAFFS_EMPTY_LOST_AND_FOUND - param->emptyLostAndFound = 1; + param->empty_lost_n_found = 1; #endif #ifdef CONFIG_YAFFS_DISABLE_BLOCK_REFRESHING - param->refreshPeriod = 0; + param->refresh_period = 0; #else - param->refreshPeriod = 500; + param->refresh_period = 500; #endif #ifdef CONFIG_YAFFS__ALWAYS_CHECK_CHUNK_ERASED - param->alwaysCheckErased = 1; + param->always_check_erased = 1; #endif - if(options.empty_lost_and_found_overridden) - param->emptyLostAndFound = options.empty_lost_and_found; + if (options.empty_lost_and_found_overridden) + param->empty_lost_n_found = options.empty_lost_and_found; /* ... and the functions. */ - if (yaffsVersion == 2) { - param->writeChunkWithTagsToNAND = - nandmtd2_WriteChunkWithTagsToNAND; - param->readChunkWithTagsFromNAND = - nandmtd2_ReadChunkWithTagsFromNAND; - param->markNANDBlockBad = nandmtd2_MarkNANDBlockBad; - param->queryNANDBlock = nandmtd2_QueryNANDBlock; - yaffs_DeviceToLC(dev)->spareBuffer = YMALLOC(mtd->oobsize); - param->isYaffs2 = 1; + if (yaffs_version == 2) { + param->write_chunk_tags_fn = nandmtd2_write_chunk_tags; + param->read_chunk_tags_fn = nandmtd2_read_chunk_tags; + param->bad_block_fn = nandmtd2_mark_block_bad; + param->query_block_fn = nandmtd2_query_block; + yaffs_dev_to_lc(dev)->spare_buffer = YMALLOC(mtd->oobsize); + param->is_yaffs2 = 1; #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) - param->totalBytesPerChunk = mtd->writesize; - param->nChunksPerBlock = mtd->erasesize / mtd->writesize; + param->total_bytes_per_chunk = mtd->writesize; + param->chunks_per_block = mtd->erasesize / mtd->writesize; #else - param->totalBytesPerChunk = mtd->oobblock; - param->nChunksPerBlock = mtd->erasesize / mtd->oobblock; + param->total_bytes_per_chunk = mtd->oobblock; + param->chunks_per_block = mtd->erasesize / mtd->oobblock; #endif - nBlocks = YCALCBLOCKS(mtd->size, mtd->erasesize); + n_blocks = YCALCBLOCKS(mtd->size, mtd->erasesize); - param->startBlock = 0; - param->endBlock = nBlocks - 1; + param->start_block = 0; + param->end_block = n_blocks - 1; } else { #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) /* use the MTD interface in yaffs_mtdif1.c */ - param->writeChunkWithTagsToNAND = - nandmtd1_WriteChunkWithTagsToNAND; - param->readChunkWithTagsFromNAND = - nandmtd1_ReadChunkWithTagsFromNAND; - param->markNANDBlockBad = nandmtd1_MarkNANDBlockBad; - param->queryNANDBlock = nandmtd1_QueryNANDBlock; + param->write_chunk_tags_fn = nandmtd1_write_chunk_tags; + param->read_chunk_tags_fn = nandmtd1_read_chunk_tags; + param->bad_block_fn = nandmtd1_mark_block_bad; + param->query_block_fn = nandmtd1_query_block; #else - param->writeChunkToNAND = nandmtd_WriteChunkToNAND; - param->readChunkFromNAND = nandmtd_ReadChunkFromNAND; + param->write_chunk_fn = nandmtd_write_chunk; + param->read_chunk_fn = nandmtd_read_chunk; #endif - param->isYaffs2 = 0; + param->is_yaffs2 = 0; } /* ... and common functions */ - param->eraseBlockInNAND = nandmtd_EraseBlockInNAND; - param->initialiseNAND = nandmtd_InitialiseNAND; + param->erase_fn = nandmtd_erase_block; + param->initialise_flash_fn = nandmtd_initialise; - yaffs_DeviceToLC(dev)->putSuperFunc = yaffs_MTDPutSuper; + yaffs_dev_to_lc(dev)->put_super_fn = yaffs_mtd_put_super; - param->markSuperBlockDirty = yaffs_MarkSuperBlockDirty; - param->gcControl = yaffs_gc_control_callback; + param->sb_dirty_fn = yaffs_touch_super; + param->gc_control = yaffs_gc_control_callback; - yaffs_DeviceToLC(dev)->superBlock= sb; - + yaffs_dev_to_lc(dev)->super = sb; #ifndef CONFIG_YAFFS_DOES_ECC - param->useNANDECC = 1; + param->use_nand_ecc = 1; #endif #ifdef CONFIG_YAFFS_DISABLE_WIDE_TNODES - param->wideTnodesDisabled = 1; + param->wide_tnodes_disabled = 1; #endif - param->skipCheckpointRead = options.skip_checkpoint_read; - param->skipCheckpointWrite = options.skip_checkpoint_write; + param->skip_checkpt_rd = options.skip_checkpoint_read; + param->skip_checkpt_wr = options.skip_checkpoint_write; - down(&yaffs_context_lock); + mutex_lock(&yaffs_context_lock); /* Get a mount id */ found = 0; - for(mount_id=0; ! found; mount_id++){ + for (mount_id = 0; !found; mount_id++) { found = 1; - ylist_for_each(l,&yaffs_context_list){ - context_iterator = ylist_entry(l,struct yaffs_LinuxContext,contextList); - if(context_iterator->mount_id == mount_id) + list_for_each(l, &yaffs_context_list) { + context_iterator = + list_entry(l, struct yaffs_linux_context, + context_list); + if (context_iterator->mount_id == mount_id) found = 0; } } context->mount_id = mount_id; - ylist_add_tail(&(yaffs_DeviceToLC(dev)->contextList), &yaffs_context_list); - up(&yaffs_context_lock); + list_add_tail(&(yaffs_dev_to_lc(dev)->context_list), + &yaffs_context_list); + mutex_unlock(&yaffs_context_lock); - /* Directory search handling...*/ - YINIT_LIST_HEAD(&(yaffs_DeviceToLC(dev)->searchContexts)); - param->removeObjectCallback = yaffs_RemoveObjectCallback; + /* Directory search handling... */ + INIT_LIST_HEAD(&(yaffs_dev_to_lc(dev)->search_contexts)); + param->remove_obj_fn = yaffs_remove_obj_callback; - init_MUTEX(&(yaffs_DeviceToLC(dev)->grossLock)); + mutex_init(&(yaffs_dev_to_lc(dev)->gross_lock)); - yaffs_GrossLock(dev); + yaffs_gross_lock(dev); - err = yaffs_GutsInitialise(dev); + err = yaffs_guts_initialise(dev); T(YAFFS_TRACE_OS, (TSTR("yaffs_read_super: guts initialised %s\n"), (err == YAFFS_OK) ? "OK" : "FAILED")); - - if(err == YAFFS_OK) - yaffs_BackgroundStart(dev); - - if(!context->bgThread) - param->deferDirectoryUpdate = 0; + if (err == YAFFS_OK) + yaffs_bg_start(dev); + + if (!context->bg_thread) + param->defered_dir_update = 0; /* Release lock before yaffs_get_inode() */ - yaffs_GrossUnlock(dev); + yaffs_gross_unlock(dev); /* Create root inode */ if (err == YAFFS_OK) - inode = yaffs_get_inode(sb, S_IFDIR | 0755, 0, - yaffs_Root(dev)); + inode = yaffs_get_inode(sb, S_IFDIR | 0755, 0, yaffs_root(dev)); if (!inode) return NULL; @@ -3078,16 +3033,15 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion, return NULL; } sb->s_root = root; - sb->s_dirt = !dev->isCheckpointed; + sb->s_dirt = !dev->is_checkpointed; T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs_read_super: isCheckpointed %d\n"), - dev->isCheckpointed)); + (TSTR("yaffs_read_super: is_checkpointed %d\n"), + dev->is_checkpointed)); T(YAFFS_TRACE_OS, (TSTR("yaffs_read_super: done\n"))); return sb; } - #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) static int yaffs_internal_read_super_mtd(struct super_block *sb, void *data, int silent) @@ -3133,7 +3087,6 @@ static DECLARE_FSTYPE(yaffs_fs_type, "yaffs", yaffs_read_super, FS_REQUIRES_DEV); #endif - #ifdef CONFIG_YAFFS_YAFFS2 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) @@ -3145,11 +3098,11 @@ static int yaffs2_internal_read_super_mtd(struct super_block *sb, void *data, #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) static int yaffs2_read_super(struct file_system_type *fs, - int flags, const char *dev_name, void *data, - struct vfsmount *mnt) + int flags, const char *dev_name, void *data, + struct vfsmount *mnt) { return get_sb_bdev(fs, flags, dev_name, data, - yaffs2_internal_read_super_mtd, mnt); + yaffs2_internal_read_super_mtd, mnt); } #else static struct super_block *yaffs2_read_super(struct file_system_type *fs, @@ -3180,66 +3133,91 @@ static DECLARE_FSTYPE(yaffs2_fs_type, "yaffs2", yaffs2_read_super, FS_REQUIRES_DEV); #endif -#endif /* CONFIG_YAFFS_YAFFS2 */ +#endif /* CONFIG_YAFFS_YAFFS2 */ static struct proc_dir_entry *my_proc_entry; static struct proc_dir_entry *debug_proc_entry; -static char *yaffs_dump_dev_part0(char *buf, yaffs_Device * dev) +static char *yaffs_dump_dev_part0(char *buf, struct yaffs_dev *dev) { - buf += sprintf(buf, "startBlock......... %d\n", dev->param.startBlock); - buf += sprintf(buf, "endBlock........... %d\n", dev->param.endBlock); - buf += sprintf(buf, "totalBytesPerChunk. %d\n", dev->param.totalBytesPerChunk); - buf += sprintf(buf, "useNANDECC......... %d\n", dev->param.useNANDECC); - buf += sprintf(buf, "noTagsECC.......... %d\n", dev->param.noTagsECC); - buf += sprintf(buf, "isYaffs2........... %d\n", dev->param.isYaffs2); - buf += sprintf(buf, "inbandTags......... %d\n", dev->param.inbandTags); - buf += sprintf(buf, "emptyLostAndFound.. %d\n", dev->param.emptyLostAndFound); - buf += sprintf(buf, "disableLazyLoad.... %d\n", dev->param.disableLazyLoad); - buf += sprintf(buf, "refreshPeriod...... %d\n", dev->param.refreshPeriod); - buf += sprintf(buf, "nShortOpCaches..... %d\n", dev->param.nShortOpCaches); - buf += sprintf(buf, "nReservedBlocks.... %d\n", dev->param.nReservedBlocks); - buf += sprintf(buf, "alwaysCheckErased.. %d\n", dev->param.alwaysCheckErased); + buf += + sprintf(buf, "start_block.......... %d\n", dev->param.start_block); + buf += sprintf(buf, "end_block............ %d\n", dev->param.end_block); + buf += + sprintf(buf, "total_bytes_per_chunk %d\n", + dev->param.total_bytes_per_chunk); + buf += + sprintf(buf, "use_nand_ecc......... %d\n", dev->param.use_nand_ecc); + buf += + sprintf(buf, "no_tags_ecc.......... %d\n", dev->param.no_tags_ecc); + buf += sprintf(buf, "is_yaffs2............ %d\n", dev->param.is_yaffs2); + buf += + sprintf(buf, "inband_tags.......... %d\n", dev->param.inband_tags); + buf += + sprintf(buf, "empty_lost_n_found... %d\n", + dev->param.empty_lost_n_found); + buf += + sprintf(buf, "disable_lazy_load.... %d\n", + dev->param.disable_lazy_load); + buf += + sprintf(buf, "refresh_period....... %d\n", + dev->param.refresh_period); + buf += sprintf(buf, "n_caches............. %d\n", dev->param.n_caches); + buf += + sprintf(buf, "n_reserved_blocks.... %d\n", + dev->param.n_reserved_blocks); + buf += + sprintf(buf, "always_check_erased.. %d\n", + dev->param.always_check_erased); buf += sprintf(buf, "\n"); return buf; } - -static char *yaffs_dump_dev_part1(char *buf, yaffs_Device * dev) +static char *yaffs_dump_dev_part1(char *buf, struct yaffs_dev *dev) { - buf += sprintf(buf, "nDataBytesPerChunk. %d\n", dev->nDataBytesPerChunk); - buf += sprintf(buf, "chunkGroupBits..... %d\n", dev->chunkGroupBits); - buf += sprintf(buf, "chunkGroupSize..... %d\n", dev->chunkGroupSize); - buf += sprintf(buf, "nErasedBlocks...... %d\n", dev->nErasedBlocks); - buf += sprintf(buf, "blocksInCheckpoint. %d\n", dev->blocksInCheckpoint); - buf += sprintf(buf, "\n"); - buf += sprintf(buf, "nTnodes............ %d\n", dev->nTnodes); - buf += sprintf(buf, "nObjects........... %d\n", dev->nObjects); - buf += sprintf(buf, "nFreeChunks........ %d\n", dev->nFreeChunks); - buf += sprintf(buf, "\n"); - buf += sprintf(buf, "nPageWrites........ %u\n", dev->nPageWrites); - buf += sprintf(buf, "nPageReads......... %u\n", dev->nPageReads); - buf += sprintf(buf, "nBlockErasures..... %u\n", dev->nBlockErasures); - buf += sprintf(buf, "nGCCopies.......... %u\n", dev->nGCCopies); - buf += sprintf(buf, "allGCs............. %u\n", dev->allGCs); - buf += sprintf(buf, "passiveGCs......... %u\n", dev->passiveGCs); - buf += sprintf(buf, "oldestDirtyGCs..... %u\n", dev->oldestDirtyGCs); - buf += sprintf(buf, "nGCBlocks.......... %u\n", dev->nGCBlocks); - buf += sprintf(buf, "backgroundGCs...... %u\n", dev->backgroundGCs); - buf += sprintf(buf, "nRetriedWrites..... %u\n", dev->nRetriedWrites); - buf += sprintf(buf, "nRetireBlocks...... %u\n", dev->nRetiredBlocks); - buf += sprintf(buf, "eccFixed........... %u\n", dev->eccFixed); - buf += sprintf(buf, "eccUnfixed......... %u\n", dev->eccUnfixed); - buf += sprintf(buf, "tagsEccFixed....... %u\n", dev->tagsEccFixed); - buf += sprintf(buf, "tagsEccUnfixed..... %u\n", dev->tagsEccUnfixed); - buf += sprintf(buf, "cacheHits.......... %u\n", dev->cacheHits); - buf += sprintf(buf, "nDeletedFiles...... %u\n", dev->nDeletedFiles); - buf += sprintf(buf, "nUnlinkedFiles..... %u\n", dev->nUnlinkedFiles); - buf += sprintf(buf, "refreshCount....... %u\n", dev->refreshCount); buf += - sprintf(buf, "nBackgroudDeletions %u\n", dev->nBackgroundDeletions); + sprintf(buf, "data_bytes_per_chunk. %d\n", + dev->data_bytes_per_chunk); + buf += sprintf(buf, "chunk_grp_bits....... %d\n", dev->chunk_grp_bits); + buf += sprintf(buf, "chunk_grp_size....... %d\n", dev->chunk_grp_size); + buf += sprintf(buf, "n_erased_blocks...... %d\n", dev->n_erased_blocks); + buf += + sprintf(buf, "blocks_in_checkpt.... %d\n", dev->blocks_in_checkpt); + buf += sprintf(buf, "\n"); + buf += sprintf(buf, "n_tnodes............. %d\n", dev->n_tnodes); + buf += sprintf(buf, "n_obj................ %d\n", dev->n_obj); + buf += sprintf(buf, "n_free_chunks........ %d\n", dev->n_free_chunks); + buf += sprintf(buf, "\n"); + buf += sprintf(buf, "n_page_writes........ %u\n", dev->n_page_writes); + buf += sprintf(buf, "n_page_reads......... %u\n", dev->n_page_reads); + buf += sprintf(buf, "n_erasures........... %u\n", dev->n_erasures); + buf += sprintf(buf, "n_gc_copies.......... %u\n", dev->n_gc_copies); + buf += sprintf(buf, "all_gcs.............. %u\n", dev->all_gcs); + buf += + sprintf(buf, "passive_gc_count..... %u\n", dev->passive_gc_count); + buf += + sprintf(buf, "oldest_dirty_gc_count %u\n", + dev->oldest_dirty_gc_count); + buf += sprintf(buf, "n_gc_blocks.......... %u\n", dev->n_gc_blocks); + buf += sprintf(buf, "bg_gcs............... %u\n", dev->bg_gcs); + buf += + sprintf(buf, "n_retired_writes..... %u\n", dev->n_retired_writes); + buf += + sprintf(buf, "n_retired_blocks..... %u\n", dev->n_retired_blocks); + buf += sprintf(buf, "n_ecc_fixed.......... %u\n", dev->n_ecc_fixed); + buf += sprintf(buf, "n_ecc_unfixed........ %u\n", dev->n_ecc_unfixed); + buf += + sprintf(buf, "n_tags_ecc_fixed..... %u\n", dev->n_tags_ecc_fixed); + buf += + sprintf(buf, "n_tags_ecc_unfixed... %u\n", dev->n_tags_ecc_unfixed); + buf += sprintf(buf, "cache_hits........... %u\n", dev->cache_hits); + buf += sprintf(buf, "n_deleted_files...... %u\n", dev->n_deleted_files); + buf += + sprintf(buf, "n_unlinked_files..... %u\n", dev->n_unlinked_files); + buf += sprintf(buf, "refresh_count........ %u\n", dev->refresh_count); + buf += sprintf(buf, "n_bg_deletions....... %u\n", dev->n_bg_deletions); return buf; } @@ -3248,13 +3226,13 @@ static int yaffs_proc_read(char *page, char **start, off_t offset, int count, int *eof, void *data) { - struct ylist_head *item; + struct list_head *item; char *buf = page; int step = offset; int n = 0; /* Get proc_file_read() to step 'offset' by one on each sucessive call. - * We use 'offset' (*ppos) to indicate where we are in devList. + * We use 'offset' (*ppos) to indicate where we are in dev_list. * This also assumes the user has posted a read buffer large * enough to hold the complete output; but that's life in /proc. */ @@ -3263,63 +3241,71 @@ static int yaffs_proc_read(char *page, /* Print header first */ if (step == 0) - buf += sprintf(buf, "Multi-version YAFFS built:" __DATE__ " " __TIME__"\n"); + buf += + sprintf(buf, + "Multi-version YAFFS built:" __DATE__ " " __TIME__ + "\n"); else if (step == 1) - buf += sprintf(buf,"\n"); + buf += sprintf(buf, "\n"); else { - step-=2; - - down(&yaffs_context_lock); + step -= 2; + + mutex_lock(&yaffs_context_lock); /* Locate and print the Nth entry. Order N-squared but N is small. */ - ylist_for_each(item, &yaffs_context_list) { - struct yaffs_LinuxContext *dc = ylist_entry(item, struct yaffs_LinuxContext, contextList); - yaffs_Device *dev = dc->dev; + list_for_each(item, &yaffs_context_list) { + struct yaffs_linux_context *dc = + list_entry(item, struct yaffs_linux_context, + context_list); + struct yaffs_dev *dev = dc->dev; if (n < (step & ~1)) { - n+=2; + n += 2; continue; } - if((step & 1)==0){ - buf += sprintf(buf, "\nDevice %d \"%s\"\n", n, dev->param.name); + if ((step & 1) == 0) { + buf += + sprintf(buf, "\nDevice %d \"%s\"\n", n, + dev->param.name); buf = yaffs_dump_dev_part0(buf, dev); } else buf = yaffs_dump_dev_part1(buf, dev); - + break; } - up(&yaffs_context_lock); + mutex_unlock(&yaffs_context_lock); } return buf - page < count ? buf - page : count; } static int yaffs_stats_proc_read(char *page, - char **start, - off_t offset, int count, int *eof, void *data) + char **start, + off_t offset, int count, int *eof, void *data) { - struct ylist_head *item; + struct list_head *item; char *buf = page; int n = 0; - down(&yaffs_context_lock); + mutex_lock(&yaffs_context_lock); /* Locate and print the Nth entry. Order N-squared but N is small. */ - ylist_for_each(item, &yaffs_context_list) { - struct yaffs_LinuxContext *dc = ylist_entry(item, struct yaffs_LinuxContext, contextList); - yaffs_Device *dev = dc->dev; + list_for_each(item, &yaffs_context_list) { + struct yaffs_linux_context *dc = + list_entry(item, struct yaffs_linux_context, context_list); + struct yaffs_dev *dev = dc->dev; - int erasedChunks; + int erased_chunks; - erasedChunks = dev->nErasedBlocks * dev->param.nChunksPerBlock; - - buf += sprintf(buf,"%d, %d, %d, %u, %u, %u, %u\n", - n, dev->nFreeChunks, erasedChunks, - dev->backgroundGCs, dev->oldestDirtyGCs, - dev->nObjects, dev->nTnodes); + erased_chunks = + dev->n_erased_blocks * dev->param.chunks_per_block; + + buf += sprintf(buf, "%d, %d, %d, %u, %u, %u, %u\n", + n, dev->n_free_chunks, erased_chunks, + dev->bg_gcs, dev->oldest_dirty_gc_count, + dev->n_obj, dev->n_tnodes); } - up(&yaffs_context_lock); - + mutex_unlock(&yaffs_context_lock); return buf - page < count ? buf - page : count; } @@ -3334,41 +3320,39 @@ static struct { char *mask_name; unsigned mask_bitfield; } mask_flags[] = { - {"allocate", YAFFS_TRACE_ALLOCATE}, - {"always", YAFFS_TRACE_ALWAYS}, - {"background", YAFFS_TRACE_BACKGROUND}, - {"bad_blocks", YAFFS_TRACE_BAD_BLOCKS}, - {"buffers", YAFFS_TRACE_BUFFERS}, - {"bug", YAFFS_TRACE_BUG}, - {"checkpt", YAFFS_TRACE_CHECKPOINT}, - {"deletion", YAFFS_TRACE_DELETION}, - {"erase", YAFFS_TRACE_ERASE}, - {"error", YAFFS_TRACE_ERROR}, - {"gc_detail", YAFFS_TRACE_GC_DETAIL}, - {"gc", YAFFS_TRACE_GC}, - {"lock", YAFFS_TRACE_LOCK}, - {"mtd", YAFFS_TRACE_MTD}, - {"nandaccess", YAFFS_TRACE_NANDACCESS}, - {"os", YAFFS_TRACE_OS}, - {"scan_debug", YAFFS_TRACE_SCAN_DEBUG}, - {"scan", YAFFS_TRACE_SCAN}, - {"tracing", YAFFS_TRACE_TRACING}, - {"sync", YAFFS_TRACE_SYNC}, - {"write", YAFFS_TRACE_WRITE}, - - {"verify", YAFFS_TRACE_VERIFY}, - {"verify_nand", YAFFS_TRACE_VERIFY_NAND}, - {"verify_full", YAFFS_TRACE_VERIFY_FULL}, - {"verify_all", YAFFS_TRACE_VERIFY_ALL}, - - {"all", 0xffffffff}, - {"none", 0}, - {NULL, 0}, -}; + { + "allocate", YAFFS_TRACE_ALLOCATE}, { + "always", YAFFS_TRACE_ALWAYS}, { + "background", YAFFS_TRACE_BACKGROUND}, { + "bad_blocks", YAFFS_TRACE_BAD_BLOCKS}, { + "buffers", YAFFS_TRACE_BUFFERS}, { + "bug", YAFFS_TRACE_BUG}, { + "checkpt", YAFFS_TRACE_CHECKPOINT}, { + "deletion", YAFFS_TRACE_DELETION}, { + "erase", YAFFS_TRACE_ERASE}, { + "error", YAFFS_TRACE_ERROR}, { + "gc_detail", YAFFS_TRACE_GC_DETAIL}, { + "gc", YAFFS_TRACE_GC}, { + "lock", YAFFS_TRACE_LOCK}, { + "mtd", YAFFS_TRACE_MTD}, { + "nandaccess", YAFFS_TRACE_NANDACCESS}, { + "os", YAFFS_TRACE_OS}, { + "scan_debug", YAFFS_TRACE_SCAN_DEBUG}, { + "scan", YAFFS_TRACE_SCAN}, { + "tracing", YAFFS_TRACE_TRACING}, { + "sync", YAFFS_TRACE_SYNC}, { + "write", YAFFS_TRACE_WRITE}, { + "verify", YAFFS_TRACE_VERIFY}, { + "verify_nand", YAFFS_TRACE_VERIFY_NAND}, { + "verify_full", YAFFS_TRACE_VERIFY_FULL}, { + "verify_all", YAFFS_TRACE_VERIFY_ALL}, { + "all", 0xffffffff}, { + "none", 0}, { +NULL, 0},}; #define MAX_MASK_NAME_LENGTH 40 static int yaffs_proc_write_trace_options(struct file *file, const char *buf, - unsigned long count, void *data) + unsigned long count, void *data) { unsigned rg = 0, mask_bitfield; char *end; @@ -3380,7 +3364,7 @@ static int yaffs_proc_write_trace_options(struct file *file, const char *buf, int add, len = 0; int pos = 0; - rg = yaffs_traceMask; + rg = yaffs_trace_mask; while (!done && (pos < count)) { done = 1; @@ -3410,15 +3394,17 @@ static int yaffs_proc_write_trace_options(struct file *file, const char *buf, done = 0; } else { for (x = buf + pos, i = 0; - (*x == '_' || (*x >= 'a' && *x <= 'z')) && - i < MAX_MASK_NAME_LENGTH; x++, i++, pos++) + (*x == '_' || (*x >= 'a' && *x <= 'z')) && + i < MAX_MASK_NAME_LENGTH; x++, i++, pos++) substring[i] = *x; substring[i] = '\0'; for (i = 0; mask_flags[i].mask_name != NULL; i++) { - if (strcmp(substring, mask_flags[i].mask_name) == 0) { + if (strcmp(substring, mask_flags[i].mask_name) + == 0) { mask_name = mask_flags[i].mask_name; - mask_bitfield = mask_flags[i].mask_bitfield; + mask_bitfield = + mask_flags[i].mask_bitfield; done = 0; break; } @@ -3444,27 +3430,27 @@ static int yaffs_proc_write_trace_options(struct file *file, const char *buf, } } - yaffs_traceMask = rg | YAFFS_TRACE_ALWAYS; + yaffs_trace_mask = rg | YAFFS_TRACE_ALWAYS; - printk(KERN_DEBUG "new trace = 0x%08X\n", yaffs_traceMask); + printk(KERN_DEBUG "new trace = 0x%08X\n", yaffs_trace_mask); if (rg & YAFFS_TRACE_ALWAYS) { for (i = 0; mask_flags[i].mask_name != NULL; i++) { char flag; flag = ((rg & mask_flags[i].mask_bitfield) == mask_flags[i].mask_bitfield) ? '+' : '-'; - printk(KERN_DEBUG "%c%s\n", flag, mask_flags[i].mask_name); + printk(KERN_DEBUG "%c%s\n", flag, + mask_flags[i].mask_name); } } return count; } - static int yaffs_proc_write(struct file *file, const char *buf, - unsigned long count, void *data) + unsigned long count, void *data) { - return yaffs_proc_write_trace_options(file, buf, count, data); + return yaffs_proc_write_trace_options(file, buf, count, data); } /* Stuff to handle installation of file systems */ @@ -3489,18 +3475,15 @@ static int __init init_yaffs_fs(void) #ifdef CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED T(YAFFS_TRACE_ALWAYS, - (TSTR(" \n\n\n\nYAFFS-WARNING CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED selected.\n\n\n\n"))); + (TSTR + (" \n\n\n\nYAFFS-WARNING CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED selected.\n\n\n\n"))); #endif - - - - init_MUTEX(&yaffs_context_lock); + mutex_init(&yaffs_context_lock); /* Install the proc_fs entries */ my_proc_entry = create_proc_entry("yaffs", - S_IRUGO | S_IFREG, - YPROC_ROOT); + S_IRUGO | S_IFREG, YPROC_ROOT); if (my_proc_entry) { my_proc_entry->write_proc = yaffs_proc_write; @@ -3510,8 +3493,7 @@ static int __init init_yaffs_fs(void) return -ENOMEM; debug_proc_entry = create_proc_entry("yaffs_stats", - S_IRUGO | S_IFREG, - YPROC_ROOT); + S_IRUGO | S_IFREG, YPROC_ROOT); if (debug_proc_entry) { debug_proc_entry->write_proc = NULL; @@ -3553,7 +3535,7 @@ static void __exit exit_yaffs_fs(void) struct file_system_to_install *fsinst; T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs built " __DATE__ " " __TIME__ " removing. \n"))); + (TSTR("yaffs built " __DATE__ " " __TIME__ " removing. \n"))); remove_proc_entry("yaffs", YPROC_ROOT); remove_proc_entry("yaffs_stats", YPROC_ROOT); @@ -3570,8 +3552,8 @@ static void __exit exit_yaffs_fs(void) } module_init(init_yaffs_fs) -module_exit(exit_yaffs_fs) + module_exit(exit_yaffs_fs) -MODULE_DESCRIPTION("YAFFS2 - a NAND specific flash file system"); + MODULE_DESCRIPTION("YAFFS2 - a NAND specific flash file system"); MODULE_AUTHOR("Charles Manning, Aleph One Ltd., 2002-2010"); MODULE_LICENSE("GPL"); diff --git a/fs/yaffs2/yaffs_yaffs1.c b/fs/yaffs2/yaffs_yaffs1.c index 78cc8199..4ab0f22b 100644 --- a/fs/yaffs2/yaffs_yaffs1.c +++ b/fs/yaffs2/yaffs_yaffs1.c @@ -10,69 +10,65 @@ * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. */ + #include "yaffs_yaffs1.h" #include "yportenv.h" #include "yaffs_trace.h" #include "yaffs_bitmap.h" #include "yaffs_getblockinfo.h" #include "yaffs_nand.h" +#include "yaffs_attribs.h" - -int yaffs1_Scan(yaffs_Device *dev) +int yaffs1_scan(struct yaffs_dev *dev) { - yaffs_ExtendedTags tags; + struct yaffs_ext_tags tags; int blk; - int blockIterator; - int startIterator; - int endIterator; int result; int chunk; int c; int deleted; - yaffs_BlockState state; - yaffs_Object *hardList = NULL; - yaffs_BlockInfo *bi; - __u32 sequenceNumber; - yaffs_ObjectHeader *oh; - yaffs_Object *in; - yaffs_Object *parent; + enum yaffs_block_state state; + struct yaffs_obj *hard_list = NULL; + struct yaffs_block_info *bi; + u32 seq_number; + struct yaffs_obj_hdr *oh; + struct yaffs_obj *in; + struct yaffs_obj *parent; int alloc_failed = 0; - struct yaffs_ShadowFixerStruct *shadowFixerList = NULL; - - - __u8 *chunkData; - + struct yaffs_shadow_fixer *shadow_fixers = NULL; + u8 *chunk_data; T(YAFFS_TRACE_SCAN, - (TSTR("yaffs1_Scan starts intstartblk %d intendblk %d..." TENDSTR), - dev->internalStartBlock, dev->internalEndBlock)); + (TSTR("yaffs1_scan starts intstartblk %d intendblk %d..." TENDSTR), + dev->internal_start_block, dev->internal_end_block)); - chunkData = yaffs_GetTempBuffer(dev, __LINE__); + chunk_data = yaffs_get_temp_buffer(dev, __LINE__); - dev->sequenceNumber = YAFFS_LOWEST_SEQUENCE_NUMBER; + dev->seq_number = YAFFS_LOWEST_SEQUENCE_NUMBER; /* Scan all the blocks to determine their state */ - bi = dev->blockInfo; - for (blk = dev->internalStartBlock; blk <= dev->internalEndBlock; blk++) { - yaffs_ClearChunkBits(dev, blk); - bi->pagesInUse = 0; - bi->softDeletions = 0; + bi = dev->block_info; + for (blk = dev->internal_start_block; blk <= dev->internal_end_block; + blk++) { + yaffs_clear_chunk_bits(dev, blk); + bi->pages_in_use = 0; + bi->soft_del_pages = 0; - yaffs_QueryInitialBlockState(dev, blk, &state, &sequenceNumber); + yaffs_query_init_block_state(dev, blk, &state, &seq_number); - bi->blockState = state; - bi->sequenceNumber = sequenceNumber; + bi->block_state = state; + bi->seq_number = seq_number; - if (bi->sequenceNumber == YAFFS_SEQUENCE_BAD_BLOCK) - bi->blockState = state = YAFFS_BLOCK_STATE_DEAD; + if (bi->seq_number == YAFFS_SEQUENCE_BAD_BLOCK) + bi->block_state = state = YAFFS_BLOCK_STATE_DEAD; T(YAFFS_TRACE_SCAN_DEBUG, (TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk, - state, sequenceNumber)); + state, seq_number)); if (state == YAFFS_BLOCK_STATE_DEAD) { T(YAFFS_TRACE_BAD_BLOCKS, @@ -80,49 +76,43 @@ int yaffs1_Scan(yaffs_Device *dev) } else if (state == YAFFS_BLOCK_STATE_EMPTY) { T(YAFFS_TRACE_SCAN_DEBUG, (TSTR("Block empty " TENDSTR))); - dev->nErasedBlocks++; - dev->nFreeChunks += dev->param.nChunksPerBlock; + dev->n_erased_blocks++; + dev->n_free_chunks += dev->param.chunks_per_block; } bi++; } - startIterator = dev->internalStartBlock; - endIterator = dev->internalEndBlock; - /* For each block.... */ - for (blockIterator = startIterator; !alloc_failed && blockIterator <= endIterator; - blockIterator++) { + for (blk = dev->internal_start_block; + !alloc_failed && blk <= dev->internal_end_block; blk++) { YYIELD(); - YYIELD(); - - blk = blockIterator; - - bi = yaffs_GetBlockInfo(dev, blk); - state = bi->blockState; + bi = yaffs_get_block_info(dev, blk); + state = bi->block_state; deleted = 0; - /* For each chunk in each block that needs scanning....*/ - for (c = 0; !alloc_failed && c < dev->param.nChunksPerBlock && + /* For each chunk in each block that needs scanning.... */ + for (c = 0; !alloc_failed && c < dev->param.chunks_per_block && state == YAFFS_BLOCK_STATE_NEEDS_SCANNING; c++) { /* Read the tags and decide what to do */ - chunk = blk * dev->param.nChunksPerBlock + c; + chunk = blk * dev->param.chunks_per_block + c; - result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL, - &tags); + result = yaffs_rd_chunk_tags_nand(dev, chunk, NULL, + &tags); /* Let's have a good look at this chunk... */ - if (tags.eccResult == YAFFS_ECC_RESULT_UNFIXED || tags.chunkDeleted) { + if (tags.ecc_result == YAFFS_ECC_RESULT_UNFIXED + || tags.is_deleted) { /* YAFFS1 only... * A deleted chunk */ deleted++; - dev->nFreeChunks++; + dev->n_free_chunks++; /*T((" %d %d deleted\n",blk,c)); */ - } else if (!tags.chunkUsed) { + } else if (!tags.chunk_used) { /* An unassigned chunk in the block * This means that either the block is empty or * this is the one being allocated from @@ -131,7 +121,7 @@ int yaffs1_Scan(yaffs_Device *dev) if (c == 0) { /* We're looking at the first chunk in the block so the block is unused */ state = YAFFS_BLOCK_STATE_EMPTY; - dev->nErasedBlocks++; + dev->n_erased_blocks++; } else { /* this is the block being allocated from */ T(YAFFS_TRACE_SCAN, @@ -139,102 +129,108 @@ int yaffs1_Scan(yaffs_Device *dev) (" Allocating from %d %d" TENDSTR), blk, c)); state = YAFFS_BLOCK_STATE_ALLOCATING; - dev->allocationBlock = blk; - dev->allocationPage = c; - dev->allocationBlockFinder = blk; + dev->alloc_block = blk; + dev->alloc_page = c; + dev->alloc_block_finder = blk; /* Set block finder here to encourage the allocator to go forth from here. */ } - dev->nFreeChunks += (dev->param.nChunksPerBlock - c); - } else if (tags.chunkId > 0) { - /* chunkId > 0 so it is a data chunk... */ + dev->n_free_chunks += + (dev->param.chunks_per_block - c); + } else if (tags.chunk_id > 0) { + /* chunk_id > 0 so it is a data chunk... */ unsigned int endpos; - yaffs_SetChunkBit(dev, blk, c); - bi->pagesInUse++; + yaffs_set_chunk_bit(dev, blk, c); + bi->pages_in_use++; - in = yaffs_FindOrCreateObjectByNumber(dev, - tags. - objectId, - YAFFS_OBJECT_TYPE_FILE); + in = yaffs_find_or_create_by_number(dev, + tags.obj_id, + YAFFS_OBJECT_TYPE_FILE); /* PutChunkIntoFile checks for a clash (two data chunks with - * the same chunkId). + * the same chunk_id). */ if (!in) alloc_failed = 1; if (in) { - if (!yaffs_PutChunkIntoFile(in, tags.chunkId, chunk, 1)) + if (!yaffs_put_chunk_in_file + (in, tags.chunk_id, chunk, 1)) alloc_failed = 1; } endpos = - (tags.chunkId - 1) * dev->nDataBytesPerChunk + - tags.byteCount; - if (in && - in->variantType == YAFFS_OBJECT_TYPE_FILE - && in->variant.fileVariant.scannedFileSize < + (tags.chunk_id - + 1) * dev->data_bytes_per_chunk + + tags.n_bytes; + if (in + && in->variant_type == + YAFFS_OBJECT_TYPE_FILE + && in->variant.file_variant.scanned_size < endpos) { - in->variant.fileVariant. - scannedFileSize = endpos; - if (!dev->param.useHeaderFileSize) { - in->variant.fileVariant. - fileSize = - in->variant.fileVariant. - scannedFileSize; + in->variant.file_variant.scanned_size = + endpos; + if (!dev->param.use_header_file_size) { + in->variant. + file_variant.file_size = + in->variant. + file_variant.scanned_size; } } - /* T((" %d %d data %d %d\n",blk,c,tags.objectId,tags.chunkId)); */ + /* T((" %d %d data %d %d\n",blk,c,tags.obj_id,tags.chunk_id)); */ } else { - /* chunkId == 0, so it is an ObjectHeader. + /* chunk_id == 0, so it is an ObjectHeader. * Thus, we read in the object header and make the object */ - yaffs_SetChunkBit(dev, blk, c); - bi->pagesInUse++; + yaffs_set_chunk_bit(dev, blk, c); + bi->pages_in_use++; - result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk, - chunkData, - NULL); + result = yaffs_rd_chunk_tags_nand(dev, chunk, + chunk_data, + NULL); - oh = (yaffs_ObjectHeader *) chunkData; + oh = (struct yaffs_obj_hdr *)chunk_data; - in = yaffs_FindObjectByNumber(dev, - tags.objectId); - if (in && in->variantType != oh->type) { + in = yaffs_find_by_number(dev, tags.obj_id); + if (in && in->variant_type != oh->type) { /* This should not happen, but somehow - * Wev'e ended up with an objectId that has been reused but not yet + * Wev'e ended up with an obj_id that has been reused but not yet * deleted, and worse still it has changed type. Delete the old object. */ - yaffs_DeleteObject(in); + yaffs_del_obj(in); in = 0; } - in = yaffs_FindOrCreateObjectByNumber(dev, - tags. - objectId, - oh->type); + in = yaffs_find_or_create_by_number(dev, + tags.obj_id, + oh->type); if (!in) alloc_failed = 1; - if (in && oh->shadowsObject > 0) { + if (in && oh->shadows_obj > 0) { - struct yaffs_ShadowFixerStruct *fixer; - fixer = YMALLOC(sizeof(struct yaffs_ShadowFixerStruct)); + struct yaffs_shadow_fixer *fixer; + fixer = + YMALLOC(sizeof + (struct + yaffs_shadow_fixer)); if (fixer) { - fixer->next = shadowFixerList; - shadowFixerList = fixer; - fixer->objectId = tags.objectId; - fixer->shadowedId = oh->shadowsObject; + fixer->next = shadow_fixers; + shadow_fixers = fixer; + fixer->obj_id = tags.obj_id; + fixer->shadowed_id = + oh->shadows_obj; T(YAFFS_TRACE_SCAN, (TSTR - (" Shadow fixer: %d shadows %d" TENDSTR), - fixer->objectId, fixer->shadowedId)); + (" Shadow fixer: %d shadows %d" + TENDSTR), fixer->obj_id, + fixer->shadowed_id)); } @@ -243,74 +239,49 @@ int yaffs1_Scan(yaffs_Device *dev) if (in && in->valid) { /* We have already filled this one. We have a duplicate and need to resolve it. */ - unsigned existingSerial = in->serial; - unsigned newSerial = tags.serialNumber; + unsigned existing_serial = in->serial; + unsigned new_serial = + tags.serial_number; - if (((existingSerial + 1) & 3) == newSerial) { + if (((existing_serial + 1) & 3) == + new_serial) { /* Use new one - destroy the exisiting one */ - yaffs_DeleteChunk(dev, - in->hdrChunk, - 1, __LINE__); + yaffs_chunk_del(dev, + in->hdr_chunk, + 1, __LINE__); in->valid = 0; } else { /* Use existing - destroy this one. */ - yaffs_DeleteChunk(dev, chunk, 1, - __LINE__); + yaffs_chunk_del(dev, chunk, 1, + __LINE__); } } if (in && !in->valid && - (tags.objectId == YAFFS_OBJECTID_ROOT || - tags.objectId == YAFFS_OBJECTID_LOSTNFOUND)) { + (tags.obj_id == YAFFS_OBJECTID_ROOT || + tags.obj_id == + YAFFS_OBJECTID_LOSTNFOUND)) { /* We only load some info, don't fiddle with directory structure */ in->valid = 1; - in->variantType = oh->type; + in->variant_type = oh->type; in->yst_mode = oh->yst_mode; -#ifdef CONFIG_YAFFS_WINCE - in->win_atime[0] = oh->win_atime[0]; - in->win_ctime[0] = oh->win_ctime[0]; - in->win_mtime[0] = oh->win_mtime[0]; - in->win_atime[1] = oh->win_atime[1]; - in->win_ctime[1] = oh->win_ctime[1]; - in->win_mtime[1] = oh->win_mtime[1]; -#else - in->yst_uid = oh->yst_uid; - in->yst_gid = oh->yst_gid; - in->yst_atime = oh->yst_atime; - in->yst_mtime = oh->yst_mtime; - in->yst_ctime = oh->yst_ctime; - in->yst_rdev = oh->yst_rdev; -#endif - in->hdrChunk = chunk; - in->serial = tags.serialNumber; + yaffs_load_attribs(in, oh); + in->hdr_chunk = chunk; + in->serial = tags.serial_number; } else if (in && !in->valid) { /* we need to load this info */ in->valid = 1; - in->variantType = oh->type; + in->variant_type = oh->type; in->yst_mode = oh->yst_mode; -#ifdef CONFIG_YAFFS_WINCE - in->win_atime[0] = oh->win_atime[0]; - in->win_ctime[0] = oh->win_ctime[0]; - in->win_mtime[0] = oh->win_mtime[0]; - in->win_atime[1] = oh->win_atime[1]; - in->win_ctime[1] = oh->win_ctime[1]; - in->win_mtime[1] = oh->win_mtime[1]; -#else - in->yst_uid = oh->yst_uid; - in->yst_gid = oh->yst_gid; - in->yst_atime = oh->yst_atime; - in->yst_mtime = oh->yst_mtime; - in->yst_ctime = oh->yst_ctime; - in->yst_rdev = oh->yst_rdev; -#endif - in->hdrChunk = chunk; - in->serial = tags.serialNumber; + yaffs_load_attribs(in, oh); + in->hdr_chunk = chunk; + in->serial = tags.serial_number; - yaffs_SetObjectNameFromOH(in, oh); + yaffs_set_obj_name_from_oh(in, oh); in->dirty = 0; /* directory stuff... @@ -318,21 +289,22 @@ int yaffs1_Scan(yaffs_Device *dev) */ parent = - yaffs_FindOrCreateObjectByNumber - (dev, oh->parentObjectId, + yaffs_find_or_create_by_number + (dev, oh->parent_obj_id, YAFFS_OBJECT_TYPE_DIRECTORY); if (!parent) alloc_failed = 1; - if (parent && parent->variantType == + if (parent && parent->variant_type == YAFFS_OBJECT_TYPE_UNKNOWN) { /* Set up as a directory */ - parent->variantType = - YAFFS_OBJECT_TYPE_DIRECTORY; - YINIT_LIST_HEAD(&parent->variant. - directoryVariant. - children); - } else if (!parent || parent->variantType != - YAFFS_OBJECT_TYPE_DIRECTORY) { + parent->variant_type = + YAFFS_OBJECT_TYPE_DIRECTORY; + INIT_LIST_HEAD(&parent-> + variant.dir_variant.children); + } else if (!parent + || parent->variant_type != + YAFFS_OBJECT_TYPE_DIRECTORY) + { /* Hoosterman, another problem.... * We're trying to use a non-directory as a directory */ @@ -341,15 +313,16 @@ int yaffs1_Scan(yaffs_Device *dev) (TSTR ("yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found." TENDSTR))); - parent = dev->lostNFoundDir; + parent = dev->lost_n_found; } - yaffs_AddObjectToDirectory(parent, in); + yaffs_add_obj_to_dir(parent, in); - if (0 && (parent == dev->deletedDir || - parent == dev->unlinkedDir)) { + if (0 && (parent == dev->del_dir || + parent == + dev->unlinked_dir)) { in->deleted = 1; /* If it is unlinked at start up then it wants deleting */ - dev->nDeletedFiles++; + dev->n_deleted_files++; } /* Note re hardlinks. * Since we might scan a hardlink before its equivalent object is scanned @@ -358,26 +331,27 @@ int yaffs1_Scan(yaffs_Device *dev) * list and fix up all the chains. */ - switch (in->variantType) { + switch (in->variant_type) { case YAFFS_OBJECT_TYPE_UNKNOWN: /* Todo got a problem */ break; case YAFFS_OBJECT_TYPE_FILE: - if (dev->param.useHeaderFileSize) + if (dev->param. + use_header_file_size) - in->variant.fileVariant. - fileSize = - oh->fileSize; + in->variant. + file_variant.file_size + = oh->file_size; break; case YAFFS_OBJECT_TYPE_HARDLINK: - in->variant.hardLinkVariant. - equivalentObjectId = - oh->equivalentObjectId; - in->hardLinks.next = - (struct ylist_head *) - hardList; - hardList = in; + in->variant. + hardlink_variant.equiv_id = + oh->equiv_id; + in->hard_links.next = + (struct list_head *) + hard_list; + hard_list = in; break; case YAFFS_OBJECT_TYPE_DIRECTORY: /* Do nothing */ @@ -386,9 +360,11 @@ int yaffs1_Scan(yaffs_Device *dev) /* Do nothing */ break; case YAFFS_OBJECT_TYPE_SYMLINK: - in->variant.symLinkVariant.alias = - yaffs_CloneString(oh->alias); - if (!in->variant.symLinkVariant.alias) + in->variant.symlink_variant. + alias = + yaffs_clone_str(oh->alias); + if (!in->variant. + symlink_variant.alias) alloc_failed = 1; break; } @@ -398,68 +374,65 @@ int yaffs1_Scan(yaffs_Device *dev) } if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) { - /* If we got this far while scanning, then the block is fully allocated.*/ + /* If we got this far while scanning, then the block is fully allocated. */ state = YAFFS_BLOCK_STATE_FULL; } if (state == YAFFS_BLOCK_STATE_ALLOCATING) { - /* If the block was partially allocated then treat it as fully allocated.*/ + /* If the block was partially allocated then treat it as fully allocated. */ state = YAFFS_BLOCK_STATE_FULL; - dev->allocationBlock = -1; + dev->alloc_block = -1; } - bi->blockState = state; + bi->block_state = state; /* Now let's see if it was dirty */ - if (bi->pagesInUse == 0 && - !bi->hasShrinkHeader && - bi->blockState == YAFFS_BLOCK_STATE_FULL) { - yaffs_BlockBecameDirty(dev, blk); + if (bi->pages_in_use == 0 && + !bi->has_shrink_hdr && + bi->block_state == YAFFS_BLOCK_STATE_FULL) { + yaffs_block_became_dirty(dev, blk); } } - /* Ok, we've done all the scanning. * Fix up the hard link chains. * We should now have scanned all the objects, now it's time to add these * hardlinks. */ - yaffs_HardlinkFixup(dev, hardList); + yaffs_link_fixup(dev, hard_list); /* Fix up any shadowed objects */ { - struct yaffs_ShadowFixerStruct *fixer; - yaffs_Object *obj; + struct yaffs_shadow_fixer *fixer; + struct yaffs_obj *obj; - while (shadowFixerList) { - fixer = shadowFixerList; - shadowFixerList = fixer->next; + while (shadow_fixers) { + fixer = shadow_fixers; + shadow_fixers = fixer->next; /* Complete the rename transaction by deleting the shadowed object * then setting the object header to unshadowed. */ - obj = yaffs_FindObjectByNumber(dev, fixer->shadowedId); + obj = yaffs_find_by_number(dev, fixer->shadowed_id); if (obj) - yaffs_DeleteObject(obj); + yaffs_del_obj(obj); - obj = yaffs_FindObjectByNumber(dev, fixer->objectId); + obj = yaffs_find_by_number(dev, fixer->obj_id); if (obj) - yaffs_UpdateObjectHeader(obj, NULL, 1, 0, 0, NULL); + yaffs_update_oh(obj, NULL, 1, 0, 0, NULL); YFREE(fixer); } } - yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__); + yaffs_release_temp_buffer(dev, chunk_data, __LINE__); if (alloc_failed) return YAFFS_FAIL; - T(YAFFS_TRACE_SCAN, (TSTR("yaffs1_Scan ends" TENDSTR))); - + T(YAFFS_TRACE_SCAN, (TSTR("yaffs1_scan ends" TENDSTR))); return YAFFS_OK; } - diff --git a/fs/yaffs2/yaffs_yaffs1.h b/fs/yaffs2/yaffs_yaffs1.h index 9769eed3..db23e049 100644 --- a/fs/yaffs2/yaffs_yaffs1.h +++ b/fs/yaffs2/yaffs_yaffs1.h @@ -17,6 +17,6 @@ #define __YAFFS_YAFFS1_H__ #include "yaffs_guts.h" -int yaffs1_Scan(yaffs_Device *dev); +int yaffs1_scan(struct yaffs_dev *dev); #endif diff --git a/fs/yaffs2/yaffs_yaffs2.c b/fs/yaffs2/yaffs_yaffs2.c index e13dd41c..97dac454 100644 --- a/fs/yaffs2/yaffs_yaffs2.c +++ b/fs/yaffs2/yaffs_yaffs2.c @@ -11,16 +11,15 @@ * published by the Free Software Foundation. */ - #include "yaffs_guts.h" #include "yaffs_trace.h" #include "yaffs_yaffs2.h" #include "yaffs_checkptrw.h" #include "yaffs_bitmap.h" -#include "yaffs_qsort.h" #include "yaffs_nand.h" #include "yaffs_getblockinfo.h" #include "yaffs_verify.h" +#include "yaffs_attribs.h" /* * Checkpoints are really no benefit on very small partitions. @@ -32,430 +31,436 @@ #define YAFFS_SMALL_HOLE_THRESHOLD 4 - /* * Oldest Dirty Sequence Number handling. */ - -/* yaffs2_CalcOldestDirtySequence() - * yaffs2_FindOldestDirtySequence() + +/* yaffs_calc_oldest_dirty_seq() + * yaffs2_find_oldest_dirty_seq() * Calculate the oldest dirty sequence number if we don't know it. */ -void yaffs2_CalcOldestDirtySequence(yaffs_Device *dev) +void yaffs_calc_oldest_dirty_seq(struct yaffs_dev *dev) { int i; unsigned seq; - unsigned blockNo = 0; - yaffs_BlockInfo *b; + unsigned block_no = 0; + struct yaffs_block_info *b; - if(!dev->param.isYaffs2) + if (!dev->param.is_yaffs2) return; /* Find the oldest dirty sequence number. */ - seq = dev->sequenceNumber + 1; - b = dev->blockInfo; - for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) { - if (b->blockState == YAFFS_BLOCK_STATE_FULL && - (b->pagesInUse - b->softDeletions) < dev->param.nChunksPerBlock && - b->sequenceNumber < seq) { - seq = b->sequenceNumber; - blockNo = i; + seq = dev->seq_number + 1; + b = dev->block_info; + for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) { + if (b->block_state == YAFFS_BLOCK_STATE_FULL && + (b->pages_in_use - b->soft_del_pages) < + dev->param.chunks_per_block && b->seq_number < seq) { + seq = b->seq_number; + block_no = i; } b++; } - if(blockNo){ - dev->oldestDirtySequence = seq; - dev->oldestDirtyBlock = blockNo; + if (block_no) { + dev->oldest_dirty_seq = seq; + dev->oldest_dirty_block = block_no; } } - -void yaffs2_FindOldestDirtySequence(yaffs_Device *dev) +void yaffs2_find_oldest_dirty_seq(struct yaffs_dev *dev) { - if(!dev->param.isYaffs2) + if (!dev->param.is_yaffs2) return; - if(!dev->oldestDirtySequence) - yaffs2_CalcOldestDirtySequence(dev); + if (!dev->oldest_dirty_seq) + yaffs_calc_oldest_dirty_seq(dev); } /* - * yaffs_ClearOldestDirtySequence() - * Called when a block is erased or marked bad. (ie. when its sequenceNumber + * yaffs_clear_oldest_dirty_seq() + * Called when a block is erased or marked bad. (ie. when its seq_number * becomes invalid). If the value matches the oldest then we clear - * dev->oldestDirtySequence to force its recomputation. + * dev->oldest_dirty_seq to force its recomputation. */ -void yaffs2_ClearOldestDirtySequence(yaffs_Device *dev, yaffs_BlockInfo *bi) +void yaffs2_clear_oldest_dirty_seq(struct yaffs_dev *dev, + struct yaffs_block_info *bi) { - if(!dev->param.isYaffs2) + if (!dev->param.is_yaffs2) return; - if(!bi || bi->sequenceNumber == dev->oldestDirtySequence){ - dev->oldestDirtySequence = 0; - dev->oldestDirtyBlock = 0; + if (!bi || bi->seq_number == dev->oldest_dirty_seq) { + dev->oldest_dirty_seq = 0; + dev->oldest_dirty_block = 0; } } /* - * yaffs2_UpdateOldestDirtySequence() + * yaffs2_update_oldest_dirty_seq() * Update the oldest dirty sequence number whenever we dirty a block. - * Only do this if the oldestDirtySequence is actually being tracked. + * Only do this if the oldest_dirty_seq is actually being tracked. */ -void yaffs2_UpdateOldestDirtySequence(yaffs_Device *dev, unsigned blockNo, yaffs_BlockInfo *bi) +void yaffs2_update_oldest_dirty_seq(struct yaffs_dev *dev, unsigned block_no, + struct yaffs_block_info *bi) { - if(!dev->param.isYaffs2) + if (!dev->param.is_yaffs2) return; - if(dev->oldestDirtySequence){ - if(dev->oldestDirtySequence > bi->sequenceNumber){ - dev->oldestDirtySequence = bi->sequenceNumber; - dev->oldestDirtyBlock = blockNo; + if (dev->oldest_dirty_seq) { + if (dev->oldest_dirty_seq > bi->seq_number) { + dev->oldest_dirty_seq = bi->seq_number; + dev->oldest_dirty_block = block_no; } } } -int yaffs2_BlockNotDisqualifiedFromGC(yaffs_Device *dev, - yaffs_BlockInfo *bi) +int yaffs_block_ok_for_gc(struct yaffs_dev *dev, struct yaffs_block_info *bi) { - if (!dev->param.isYaffs2) + if (!dev->param.is_yaffs2) return 1; /* disqualification only applies to yaffs2. */ - if (!bi->hasShrinkHeader) + if (!bi->has_shrink_hdr) return 1; /* can gc */ - yaffs2_FindOldestDirtySequence(dev); + yaffs2_find_oldest_dirty_seq(dev); /* Can't do gc of this block if there are any blocks older than this one that have * discarded pages. */ - return (bi->sequenceNumber <= dev->oldestDirtySequence); + return (bi->seq_number <= dev->oldest_dirty_seq); } /* - * yaffs2_FindRefreshBlock() + * yaffs2_find_refresh_block() * periodically finds the oldest full block by sequence number for refreshing. * Only for yaffs2. */ -__u32 yaffs2_FindRefreshBlock(yaffs_Device *dev) +u32 yaffs2_find_refresh_block(struct yaffs_dev * dev) { - __u32 b ; + u32 b; - __u32 oldest = 0; - __u32 oldestSequence = 0; + u32 oldest = 0; + u32 oldest_seq = 0; - yaffs_BlockInfo *bi; + struct yaffs_block_info *bi; - if(!dev->param.isYaffs2) + if (!dev->param.is_yaffs2) return oldest; /* * If refresh period < 10 then refreshing is disabled. */ - if(dev->param.refreshPeriod < 10) - return oldest; + if (dev->param.refresh_period < 10) + return oldest; - /* - * Fix broken values. - */ - if(dev->refreshSkip > dev->param.refreshPeriod) - dev->refreshSkip = dev->param.refreshPeriod; + /* + * Fix broken values. + */ + if (dev->refresh_skip > dev->param.refresh_period) + dev->refresh_skip = dev->param.refresh_period; - if(dev->refreshSkip > 0) - return oldest; + if (dev->refresh_skip > 0) + return oldest; /* * Refresh skip is now zero. * We'll do a refresh this time around.... * Update the refresh skip and find the oldest block. */ - dev->refreshSkip = dev->param.refreshPeriod; - dev->refreshCount++; - bi = dev->blockInfo; - for (b = dev->internalStartBlock; b <=dev->internalEndBlock; b++){ + dev->refresh_skip = dev->param.refresh_period; + dev->refresh_count++; + bi = dev->block_info; + for (b = dev->internal_start_block; b <= dev->internal_end_block; b++) { - if (bi->blockState == YAFFS_BLOCK_STATE_FULL){ + if (bi->block_state == YAFFS_BLOCK_STATE_FULL) { - if(oldest < 1 || - bi->sequenceNumber < oldestSequence){ - oldest = b; - oldestSequence = bi->sequenceNumber; - } + if (oldest < 1 || bi->seq_number < oldest_seq) { + oldest = b; + oldest_seq = bi->seq_number; + } } bi++; } if (oldest > 0) { T(YAFFS_TRACE_GC, - (TSTR("GC refresh count %d selected block %d with sequenceNumber %d" TENDSTR), - dev->refreshCount, oldest, oldestSequence)); + (TSTR + ("GC refresh count %d selected block %d with seq_number %d" + TENDSTR), dev->refresh_count, oldest, oldest_seq)); } return oldest; } -int yaffs2_CheckpointRequired(yaffs_Device *dev) +int yaffs2_checkpt_required(struct yaffs_dev *dev) { int nblocks; - - if(!dev->param.isYaffs2) - return 0; - - nblocks = dev->internalEndBlock - dev->internalStartBlock + 1 ; - return !dev->param.skipCheckpointWrite && - !dev->readOnly && - (nblocks >= YAFFS_CHECKPOINT_MIN_BLOCKS); + if (!dev->param.is_yaffs2) + return 0; + + nblocks = dev->internal_end_block - dev->internal_start_block + 1; + + return !dev->param.skip_checkpt_wr && + !dev->read_only && (nblocks >= YAFFS_CHECKPOINT_MIN_BLOCKS); } -int yaffs2_CalcCheckpointBlocksRequired(yaffs_Device *dev) +int yaffs_calc_checkpt_blocks_required(struct yaffs_dev *dev) { int retval; - if(!dev->param.isYaffs2) + if (!dev->param.is_yaffs2) return 0; - if (!dev->nCheckpointBlocksRequired && - yaffs2_CheckpointRequired(dev)){ + if (!dev->checkpoint_blocks_required && yaffs2_checkpt_required(dev)) { /* Not a valid value so recalculate */ - int nBytes = 0; - int nBlocks; - int devBlocks = (dev->param.endBlock - dev->param.startBlock + 1); + int n_bytes = 0; + int n_blocks; + int dev_blocks = + (dev->param.end_block - dev->param.start_block + 1); - nBytes += sizeof(yaffs_CheckpointValidity); - nBytes += sizeof(yaffs_CheckpointDevice); - nBytes += devBlocks * sizeof(yaffs_BlockInfo); - nBytes += devBlocks * dev->chunkBitmapStride; - nBytes += (sizeof(yaffs_CheckpointObject) + sizeof(__u32)) * (dev->nObjects); - nBytes += (dev->tnodeSize + sizeof(__u32)) * (dev->nTnodes); - nBytes += sizeof(yaffs_CheckpointValidity); - nBytes += sizeof(__u32); /* checksum*/ + n_bytes += sizeof(struct yaffs_checkpt_validity); + n_bytes += sizeof(struct yaffs_checkpt_dev); + n_bytes += dev_blocks * sizeof(struct yaffs_block_info); + n_bytes += dev_blocks * dev->chunk_bit_stride; + n_bytes += + (sizeof(struct yaffs_checkpt_obj) + + sizeof(u32)) * (dev->n_obj); + n_bytes += (dev->tnode_size + sizeof(u32)) * (dev->n_tnodes); + n_bytes += sizeof(struct yaffs_checkpt_validity); + n_bytes += sizeof(u32); /* checksum */ /* Round up and add 2 blocks to allow for some bad blocks, so add 3 */ - nBlocks = (nBytes/(dev->nDataBytesPerChunk * dev->param.nChunksPerBlock)) + 3; + n_blocks = + (n_bytes / + (dev->data_bytes_per_chunk * + dev->param.chunks_per_block)) + 3; - dev->nCheckpointBlocksRequired = nBlocks; + dev->checkpoint_blocks_required = n_blocks; } - retval = dev->nCheckpointBlocksRequired - dev->blocksInCheckpoint; - if(retval < 0) + retval = dev->checkpoint_blocks_required - dev->blocks_in_checkpt; + if (retval < 0) retval = 0; return retval; } /*--------------------- Checkpointing --------------------*/ - -static int yaffs2_WriteCheckpointValidityMarker(yaffs_Device *dev, int head) +static int yaffs2_wr_checkpt_validity_marker(struct yaffs_dev *dev, int head) { - yaffs_CheckpointValidity cp; + struct yaffs_checkpt_validity cp; memset(&cp, 0, sizeof(cp)); - cp.structType = sizeof(cp); + cp.struct_type = sizeof(cp); cp.magic = YAFFS_MAGIC; cp.version = YAFFS_CHECKPOINT_VERSION; cp.head = (head) ? 1 : 0; - return (yaffs2_CheckpointWrite(dev, &cp, sizeof(cp)) == sizeof(cp)) ? - 1 : 0; + return (yaffs2_checkpt_wr(dev, &cp, sizeof(cp)) == sizeof(cp)) ? 1 : 0; } -static int yaffs2_ReadCheckpointValidityMarker(yaffs_Device *dev, int head) +static int yaffs2_rd_checkpt_validity_marker(struct yaffs_dev *dev, int head) { - yaffs_CheckpointValidity cp; + struct yaffs_checkpt_validity cp; int ok; - ok = (yaffs2_CheckpointRead(dev, &cp, sizeof(cp)) == sizeof(cp)); + ok = (yaffs2_checkpt_rd(dev, &cp, sizeof(cp)) == sizeof(cp)); if (ok) - ok = (cp.structType == sizeof(cp)) && - (cp.magic == YAFFS_MAGIC) && - (cp.version == YAFFS_CHECKPOINT_VERSION) && - (cp.head == ((head) ? 1 : 0)); + ok = (cp.struct_type == sizeof(cp)) && + (cp.magic == YAFFS_MAGIC) && + (cp.version == YAFFS_CHECKPOINT_VERSION) && + (cp.head == ((head) ? 1 : 0)); return ok ? 1 : 0; } -static void yaffs2_DeviceToCheckpointDevice(yaffs_CheckpointDevice *cp, - yaffs_Device *dev) +static void yaffs2_dev_to_checkpt_dev(struct yaffs_checkpt_dev *cp, + struct yaffs_dev *dev) { - cp->nErasedBlocks = dev->nErasedBlocks; - cp->allocationBlock = dev->allocationBlock; - cp->allocationPage = dev->allocationPage; - cp->nFreeChunks = dev->nFreeChunks; + cp->n_erased_blocks = dev->n_erased_blocks; + cp->alloc_block = dev->alloc_block; + cp->alloc_page = dev->alloc_page; + cp->n_free_chunks = dev->n_free_chunks; - cp->nDeletedFiles = dev->nDeletedFiles; - cp->nUnlinkedFiles = dev->nUnlinkedFiles; - cp->nBackgroundDeletions = dev->nBackgroundDeletions; - cp->sequenceNumber = dev->sequenceNumber; + cp->n_deleted_files = dev->n_deleted_files; + cp->n_unlinked_files = dev->n_unlinked_files; + cp->n_bg_deletions = dev->n_bg_deletions; + cp->seq_number = dev->seq_number; } -static void yaffs2_CheckpointDeviceToDevice(yaffs_Device *dev, - yaffs_CheckpointDevice *cp) +static void yaffs_checkpt_dev_to_dev(struct yaffs_dev *dev, + struct yaffs_checkpt_dev *cp) { - dev->nErasedBlocks = cp->nErasedBlocks; - dev->allocationBlock = cp->allocationBlock; - dev->allocationPage = cp->allocationPage; - dev->nFreeChunks = cp->nFreeChunks; + dev->n_erased_blocks = cp->n_erased_blocks; + dev->alloc_block = cp->alloc_block; + dev->alloc_page = cp->alloc_page; + dev->n_free_chunks = cp->n_free_chunks; - dev->nDeletedFiles = cp->nDeletedFiles; - dev->nUnlinkedFiles = cp->nUnlinkedFiles; - dev->nBackgroundDeletions = cp->nBackgroundDeletions; - dev->sequenceNumber = cp->sequenceNumber; + dev->n_deleted_files = cp->n_deleted_files; + dev->n_unlinked_files = cp->n_unlinked_files; + dev->n_bg_deletions = cp->n_bg_deletions; + dev->seq_number = cp->seq_number; } - -static int yaffs2_WriteCheckpointDevice(yaffs_Device *dev) +static int yaffs2_wr_checkpt_dev(struct yaffs_dev *dev) { - yaffs_CheckpointDevice cp; - __u32 nBytes; - __u32 nBlocks = (dev->internalEndBlock - dev->internalStartBlock + 1); + struct yaffs_checkpt_dev cp; + u32 n_bytes; + u32 n_blocks = + (dev->internal_end_block - dev->internal_start_block + 1); int ok; - /* Write device runtime values*/ - yaffs2_DeviceToCheckpointDevice(&cp, dev); - cp.structType = sizeof(cp); + /* Write device runtime values */ + yaffs2_dev_to_checkpt_dev(&cp, dev); + cp.struct_type = sizeof(cp); - ok = (yaffs2_CheckpointWrite(dev, &cp, sizeof(cp)) == sizeof(cp)); + ok = (yaffs2_checkpt_wr(dev, &cp, sizeof(cp)) == sizeof(cp)); /* Write block info */ if (ok) { - nBytes = nBlocks * sizeof(yaffs_BlockInfo); - ok = (yaffs2_CheckpointWrite(dev, dev->blockInfo, nBytes) == nBytes); + n_bytes = n_blocks * sizeof(struct yaffs_block_info); + ok = (yaffs2_checkpt_wr(dev, dev->block_info, n_bytes) == + n_bytes); } /* Write chunk bits */ if (ok) { - nBytes = nBlocks * dev->chunkBitmapStride; - ok = (yaffs2_CheckpointWrite(dev, dev->chunkBits, nBytes) == nBytes); + n_bytes = n_blocks * dev->chunk_bit_stride; + ok = (yaffs2_checkpt_wr(dev, dev->chunk_bits, n_bytes) == + n_bytes); } - return ok ? 1 : 0; + return ok ? 1 : 0; } -static int yaffs2_ReadCheckpointDevice(yaffs_Device *dev) +static int yaffs2_rd_checkpt_dev(struct yaffs_dev *dev) { - yaffs_CheckpointDevice cp; - __u32 nBytes; - __u32 nBlocks = (dev->internalEndBlock - dev->internalStartBlock + 1); + struct yaffs_checkpt_dev cp; + u32 n_bytes; + u32 n_blocks = + (dev->internal_end_block - dev->internal_start_block + 1); int ok; - ok = (yaffs2_CheckpointRead(dev, &cp, sizeof(cp)) == sizeof(cp)); + ok = (yaffs2_checkpt_rd(dev, &cp, sizeof(cp)) == sizeof(cp)); if (!ok) return 0; - if (cp.structType != sizeof(cp)) + if (cp.struct_type != sizeof(cp)) return 0; + yaffs_checkpt_dev_to_dev(dev, &cp); - yaffs2_CheckpointDeviceToDevice(dev, &cp); + n_bytes = n_blocks * sizeof(struct yaffs_block_info); - nBytes = nBlocks * sizeof(yaffs_BlockInfo); - - ok = (yaffs2_CheckpointRead(dev, dev->blockInfo, nBytes) == nBytes); + ok = (yaffs2_checkpt_rd(dev, dev->block_info, n_bytes) == n_bytes); if (!ok) return 0; - nBytes = nBlocks * dev->chunkBitmapStride; + n_bytes = n_blocks * dev->chunk_bit_stride; - ok = (yaffs2_CheckpointRead(dev, dev->chunkBits, nBytes) == nBytes); + ok = (yaffs2_checkpt_rd(dev, dev->chunk_bits, n_bytes) == n_bytes); return ok ? 1 : 0; } -static void yaffs2_ObjectToCheckpointObject(yaffs_CheckpointObject *cp, - yaffs_Object *obj) +static void yaffs2_obj_checkpt_obj(struct yaffs_checkpt_obj *cp, + struct yaffs_obj *obj) { - cp->objectId = obj->objectId; - cp->parentId = (obj->parent) ? obj->parent->objectId : 0; - cp->hdrChunk = obj->hdrChunk; - cp->variantType = obj->variantType; + cp->obj_id = obj->obj_id; + cp->parent_id = (obj->parent) ? obj->parent->obj_id : 0; + cp->hdr_chunk = obj->hdr_chunk; + cp->variant_type = obj->variant_type; cp->deleted = obj->deleted; - cp->softDeleted = obj->softDeleted; + cp->soft_del = obj->soft_del; cp->unlinked = obj->unlinked; cp->fake = obj->fake; - cp->renameAllowed = obj->renameAllowed; - cp->unlinkAllowed = obj->unlinkAllowed; + cp->rename_allowed = obj->rename_allowed; + cp->unlink_allowed = obj->unlink_allowed; cp->serial = obj->serial; - cp->nDataChunks = obj->nDataChunks; + cp->n_data_chunks = obj->n_data_chunks; - if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) - cp->fileSizeOrEquivalentObjectId = obj->variant.fileVariant.fileSize; - else if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) - cp->fileSizeOrEquivalentObjectId = obj->variant.hardLinkVariant.equivalentObjectId; + if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) + cp->size_or_equiv_obj = obj->variant.file_variant.file_size; + else if (obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) + cp->size_or_equiv_obj = obj->variant.hardlink_variant.equiv_id; } -static int yaffs2_CheckpointObjectToObject(yaffs_Object *obj, yaffs_CheckpointObject *cp) +static int taffs2_checkpt_obj_to_obj(struct yaffs_obj *obj, + struct yaffs_checkpt_obj *cp) { - yaffs_Object *parent; + struct yaffs_obj *parent; - if (obj->variantType != cp->variantType) { + if (obj->variant_type != cp->variant_type) { T(YAFFS_TRACE_ERROR, (TSTR("Checkpoint read object %d type %d " - TCONT("chunk %d does not match existing object type %d") - TENDSTR), cp->objectId, cp->variantType, cp->hdrChunk, - obj->variantType)); + TCONT + ("chunk %d does not match existing object type %d") + TENDSTR), cp->obj_id, + cp->variant_type, cp->hdr_chunk, + obj->variant_type)); return 0; } - obj->objectId = cp->objectId; + obj->obj_id = cp->obj_id; - if (cp->parentId) - parent = yaffs_FindOrCreateObjectByNumber( - obj->myDev, - cp->parentId, - YAFFS_OBJECT_TYPE_DIRECTORY); + if (cp->parent_id) + parent = yaffs_find_or_create_by_number(obj->my_dev, + cp->parent_id, + YAFFS_OBJECT_TYPE_DIRECTORY); else parent = NULL; if (parent) { - if (parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { - T(YAFFS_TRACE_ALWAYS, (TSTR("Checkpoint read object %d parent %d type %d" - TCONT(" chunk %d Parent type, %d, not directory") - TENDSTR), - cp->objectId, cp->parentId, cp->variantType, - cp->hdrChunk, parent->variantType)); + if (parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { + T(YAFFS_TRACE_ALWAYS, + (TSTR + ("Checkpoint read object %d parent %d type %d" + TCONT(" chunk %d Parent type, %d, not directory") + TENDSTR), cp->obj_id, cp->parent_id, + cp->variant_type, cp->hdr_chunk, + parent->variant_type)); return 0; } - yaffs_AddObjectToDirectory(parent, obj); + yaffs_add_obj_to_dir(parent, obj); } - obj->hdrChunk = cp->hdrChunk; - obj->variantType = cp->variantType; + obj->hdr_chunk = cp->hdr_chunk; + obj->variant_type = cp->variant_type; obj->deleted = cp->deleted; - obj->softDeleted = cp->softDeleted; + obj->soft_del = cp->soft_del; obj->unlinked = cp->unlinked; obj->fake = cp->fake; - obj->renameAllowed = cp->renameAllowed; - obj->unlinkAllowed = cp->unlinkAllowed; + obj->rename_allowed = cp->rename_allowed; + obj->unlink_allowed = cp->unlink_allowed; obj->serial = cp->serial; - obj->nDataChunks = cp->nDataChunks; + obj->n_data_chunks = cp->n_data_chunks; - if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) - obj->variant.fileVariant.fileSize = cp->fileSizeOrEquivalentObjectId; - else if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) - obj->variant.hardLinkVariant.equivalentObjectId = cp->fileSizeOrEquivalentObjectId; + if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) + obj->variant.file_variant.file_size = cp->size_or_equiv_obj; + else if (obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) + obj->variant.hardlink_variant.equiv_id = cp->size_or_equiv_obj; - if (obj->hdrChunk > 0) - obj->lazyLoaded = 1; + if (obj->hdr_chunk > 0) + obj->lazy_loaded = 1; return 1; } - - -static int yaffs2_CheckpointTnodeWorker(yaffs_Object *in, yaffs_Tnode *tn, - __u32 level, int chunkOffset) +static int yaffs2_checkpt_tnode_worker(struct yaffs_obj *in, + struct yaffs_tnode *tn, u32 level, + int chunk_offset) { int i; - yaffs_Device *dev = in->myDev; + struct yaffs_dev *dev = in->my_dev; int ok = 1; if (tn) { @@ -463,17 +468,28 @@ static int yaffs2_CheckpointTnodeWorker(yaffs_Object *in, yaffs_Tnode *tn, for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++) { if (tn->internal[i]) { - ok = yaffs2_CheckpointTnodeWorker(in, - tn->internal[i], - level - 1, - (chunkOffset< + internal + [i], + level - + 1, + (chunk_offset + << + YAFFS_TNODES_INTERNAL_BITS) + + i); } } } else if (level == 0) { - __u32 baseOffset = chunkOffset << YAFFS_TNODES_LEVEL0_BITS; - ok = (yaffs2_CheckpointWrite(dev, &baseOffset, sizeof(baseOffset)) == sizeof(baseOffset)); + u32 base_offset = + chunk_offset << YAFFS_TNODES_LEVEL0_BITS; + ok = (yaffs2_checkpt_wr + (dev, &base_offset, + sizeof(base_offset)) == sizeof(base_offset)); if (ok) - ok = (yaffs2_CheckpointWrite(dev, tn, dev->tnodeSize) == dev->tnodeSize); + ok = (yaffs2_checkpt_wr + (dev, tn, + dev->tnode_size) == dev->tnode_size); } } @@ -481,142 +497,158 @@ static int yaffs2_CheckpointTnodeWorker(yaffs_Object *in, yaffs_Tnode *tn, } -static int yaffs2_WriteCheckpointTnodes(yaffs_Object *obj) +static int yaffs2_wr_checkpt_tnodes(struct yaffs_obj *obj) { - __u32 endMarker = ~0; + u32 end_marker = ~0; int ok = 1; - if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) { - ok = yaffs2_CheckpointTnodeWorker(obj, - obj->variant.fileVariant.top, - obj->variant.fileVariant.topLevel, - 0); + if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) { + ok = yaffs2_checkpt_tnode_worker(obj, + obj->variant.file_variant.top, + obj->variant.file_variant. + top_level, 0); if (ok) - ok = (yaffs2_CheckpointWrite(obj->myDev, &endMarker, sizeof(endMarker)) == - sizeof(endMarker)); + ok = (yaffs2_checkpt_wr + (obj->my_dev, &end_marker, + sizeof(end_marker)) == sizeof(end_marker)); } return ok ? 1 : 0; } -static int yaffs2_ReadCheckpointTnodes(yaffs_Object *obj) +static int yaffs2_rd_checkpt_tnodes(struct yaffs_obj *obj) { - __u32 baseChunk; + u32 base_chunk; int ok = 1; - yaffs_Device *dev = obj->myDev; - yaffs_FileStructure *fileStructPtr = &obj->variant.fileVariant; - yaffs_Tnode *tn; + struct yaffs_dev *dev = obj->my_dev; + struct yaffs_file_var *file_stuct_ptr = &obj->variant.file_variant; + struct yaffs_tnode *tn; int nread = 0; - ok = (yaffs2_CheckpointRead(dev, &baseChunk, sizeof(baseChunk)) == sizeof(baseChunk)); + ok = (yaffs2_checkpt_rd(dev, &base_chunk, sizeof(base_chunk)) == + sizeof(base_chunk)); - while (ok && (~baseChunk)) { + while (ok && (~base_chunk)) { nread++; /* Read level 0 tnode */ - - tn = yaffs_GetTnode(dev); - if (tn){ - ok = (yaffs2_CheckpointRead(dev, tn, dev->tnodeSize) == dev->tnodeSize); + tn = yaffs_get_tnode(dev); + if (tn) { + ok = (yaffs2_checkpt_rd(dev, tn, dev->tnode_size) == + dev->tnode_size); } else ok = 0; if (tn && ok) - ok = yaffs_AddOrFindLevel0Tnode(dev, - fileStructPtr, - baseChunk, - tn) ? 1 : 0; + ok = yaffs_add_find_tnode_0(dev, + file_stuct_ptr, + base_chunk, tn) ? 1 : 0; if (ok) - ok = (yaffs2_CheckpointRead(dev, &baseChunk, sizeof(baseChunk)) == sizeof(baseChunk)); + ok = (yaffs2_checkpt_rd + (dev, &base_chunk, + sizeof(base_chunk)) == sizeof(base_chunk)); } - T(YAFFS_TRACE_CHECKPOINT, ( - TSTR("Checkpoint read tnodes %d records, last %d. ok %d" TENDSTR), - nread, baseChunk, ok)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("Checkpoint read tnodes %d records, last %d. ok %d" TENDSTR), + nread, base_chunk, ok)); return ok ? 1 : 0; } - -static int yaffs2_WriteCheckpointObjects(yaffs_Device *dev) +static int yaffs2_wr_checkpt_objs(struct yaffs_dev *dev) { - yaffs_Object *obj; - yaffs_CheckpointObject cp; + struct yaffs_obj *obj; + struct yaffs_checkpt_obj cp; int i; int ok = 1; - struct ylist_head *lh; - + struct list_head *lh; /* Iterate through the objects in each hash entry, * dumping them to the checkpointing stream. */ - for (i = 0; ok && i < YAFFS_NOBJECT_BUCKETS; i++) { - ylist_for_each(lh, &dev->objectBucket[i].list) { + for (i = 0; ok && i < YAFFS_NOBJECT_BUCKETS; i++) { + list_for_each(lh, &dev->obj_bucket[i].list) { if (lh) { - obj = ylist_entry(lh, yaffs_Object, hashLink); - if (!obj->deferedFree) { - yaffs2_ObjectToCheckpointObject(&cp, obj); - cp.structType = sizeof(cp); + obj = + list_entry(lh, struct yaffs_obj, hash_link); + if (!obj->defered_free) { + yaffs2_obj_checkpt_obj(&cp, obj); + cp.struct_type = sizeof(cp); - T(YAFFS_TRACE_CHECKPOINT, ( - TSTR("Checkpoint write object %d parent %d type %d chunk %d obj addr %p" TENDSTR), - cp.objectId, cp.parentId, cp.variantType, cp.hdrChunk, obj)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR + ("Checkpoint write object %d parent %d type %d chunk %d obj addr %p" + TENDSTR), cp.obj_id, cp.parent_id, + cp.variant_type, cp.hdr_chunk, obj)); - ok = (yaffs2_CheckpointWrite(dev, &cp, sizeof(cp)) == sizeof(cp)); + ok = (yaffs2_checkpt_wr + (dev, &cp, + sizeof(cp)) == sizeof(cp)); - if (ok && obj->variantType == YAFFS_OBJECT_TYPE_FILE) - ok = yaffs2_WriteCheckpointTnodes(obj); + if (ok + && obj->variant_type == + YAFFS_OBJECT_TYPE_FILE) + ok = yaffs2_wr_checkpt_tnodes + (obj); } } } } /* Dump end of list */ - memset(&cp, 0xFF, sizeof(yaffs_CheckpointObject)); - cp.structType = sizeof(cp); + memset(&cp, 0xFF, sizeof(struct yaffs_checkpt_obj)); + cp.struct_type = sizeof(cp); if (ok) - ok = (yaffs2_CheckpointWrite(dev, &cp, sizeof(cp)) == sizeof(cp)); + ok = (yaffs2_checkpt_wr(dev, &cp, sizeof(cp)) == sizeof(cp)); return ok ? 1 : 0; } -static int yaffs2_ReadCheckpointObjects(yaffs_Device *dev) +static int yaffs2_rd_checkpt_objs(struct yaffs_dev *dev) { - yaffs_Object *obj; - yaffs_CheckpointObject cp; + struct yaffs_obj *obj; + struct yaffs_checkpt_obj cp; int ok = 1; int done = 0; - yaffs_Object *hardList = NULL; + struct yaffs_obj *hard_list = NULL; while (ok && !done) { - ok = (yaffs2_CheckpointRead(dev, &cp, sizeof(cp)) == sizeof(cp)); - if (cp.structType != sizeof(cp)) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("struct size %d instead of %d ok %d"TENDSTR), - cp.structType, (int)sizeof(cp), ok)); + ok = (yaffs2_checkpt_rd(dev, &cp, sizeof(cp)) == sizeof(cp)); + if (cp.struct_type != sizeof(cp)) { + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("struct size %d instead of %d ok %d" TENDSTR), + cp.struct_type, (int)sizeof(cp), ok)); ok = 0; } - T(YAFFS_TRACE_CHECKPOINT, (TSTR("Checkpoint read object %d parent %d type %d chunk %d " TENDSTR), - cp.objectId, cp.parentId, cp.variantType, cp.hdrChunk)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR + ("Checkpoint read object %d parent %d type %d chunk %d " + TENDSTR), cp.obj_id, cp.parent_id, cp.variant_type, + cp.hdr_chunk)); - if (ok && cp.objectId == ~0) + if (ok && cp.obj_id == ~0) done = 1; else if (ok) { - obj = yaffs_FindOrCreateObjectByNumber(dev, cp.objectId, cp.variantType); + obj = + yaffs_find_or_create_by_number(dev, cp.obj_id, + cp.variant_type); if (obj) { - ok = yaffs2_CheckpointObjectToObject(obj, &cp); + ok = taffs2_checkpt_obj_to_obj(obj, &cp); if (!ok) break; - if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) { - ok = yaffs2_ReadCheckpointTnodes(obj); - } else if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) { - obj->hardLinks.next = - (struct ylist_head *) hardList; - hardList = obj; + if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) { + ok = yaffs2_rd_checkpt_tnodes(obj); + } else if (obj->variant_type == + YAFFS_OBJECT_TYPE_HARDLINK) { + obj->hard_links.next = + (struct list_head *)hard_list; + hard_list = obj; } } else ok = 0; @@ -624,19 +656,20 @@ static int yaffs2_ReadCheckpointObjects(yaffs_Device *dev) } if (ok) - yaffs_HardlinkFixup(dev, hardList); + yaffs_link_fixup(dev, hard_list); return ok ? 1 : 0; } -static int yaffs2_WriteCheckpointSum(yaffs_Device *dev) +static int yaffs2_wr_checkpt_sum(struct yaffs_dev *dev) { - __u32 checkpointSum; + u32 checkpt_sum; int ok; - yaffs2_GetCheckpointSum(dev, &checkpointSum); + yaffs2_get_checkpt_sum(dev, &checkpt_sum); - ok = (yaffs2_CheckpointWrite(dev, &checkpointSum, sizeof(checkpointSum)) == sizeof(checkpointSum)); + ok = (yaffs2_checkpt_wr(dev, &checkpt_sum, sizeof(checkpt_sum)) == + sizeof(checkpt_sum)); if (!ok) return 0; @@ -644,354 +677,371 @@ static int yaffs2_WriteCheckpointSum(yaffs_Device *dev) return 1; } -static int yaffs2_ReadCheckpointSum(yaffs_Device *dev) +static int yaffs2_rd_checkpt_sum(struct yaffs_dev *dev) { - __u32 checkpointSum0; - __u32 checkpointSum1; + u32 checkpt_sum0; + u32 checkpt_sum1; int ok; - yaffs2_GetCheckpointSum(dev, &checkpointSum0); + yaffs2_get_checkpt_sum(dev, &checkpt_sum0); - ok = (yaffs2_CheckpointRead(dev, &checkpointSum1, sizeof(checkpointSum1)) == sizeof(checkpointSum1)); + ok = (yaffs2_checkpt_rd(dev, &checkpt_sum1, sizeof(checkpt_sum1)) == + sizeof(checkpt_sum1)); if (!ok) return 0; - if (checkpointSum0 != checkpointSum1) + if (checkpt_sum0 != checkpt_sum1) return 0; return 1; } - -static int yaffs2_WriteCheckpointData(yaffs_Device *dev) +static int yaffs2_wr_checkpt_data(struct yaffs_dev *dev) { int ok = 1; - if (!yaffs2_CheckpointRequired(dev)) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("skipping checkpoint write" TENDSTR))); + if (!yaffs2_checkpt_required(dev)) { + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("skipping checkpoint write" TENDSTR))); ok = 0; } if (ok) - ok = yaffs2_CheckpointOpen(dev, 1); + ok = yaffs2_checkpt_open(dev, 1); if (ok) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint validity" TENDSTR))); - ok = yaffs2_WriteCheckpointValidityMarker(dev, 1); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("write checkpoint validity" TENDSTR))); + ok = yaffs2_wr_checkpt_validity_marker(dev, 1); } if (ok) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint device" TENDSTR))); - ok = yaffs2_WriteCheckpointDevice(dev); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("write checkpoint device" TENDSTR))); + ok = yaffs2_wr_checkpt_dev(dev); } if (ok) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint objects" TENDSTR))); - ok = yaffs2_WriteCheckpointObjects(dev); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("write checkpoint objects" TENDSTR))); + ok = yaffs2_wr_checkpt_objs(dev); } if (ok) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint validity" TENDSTR))); - ok = yaffs2_WriteCheckpointValidityMarker(dev, 0); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("write checkpoint validity" TENDSTR))); + ok = yaffs2_wr_checkpt_validity_marker(dev, 0); } if (ok) - ok = yaffs2_WriteCheckpointSum(dev); + ok = yaffs2_wr_checkpt_sum(dev); - if (!yaffs2_CheckpointClose(dev)) + if (!yaffs_checkpt_close(dev)) ok = 0; if (ok) - dev->isCheckpointed = 1; + dev->is_checkpointed = 1; else - dev->isCheckpointed = 0; + dev->is_checkpointed = 0; - return dev->isCheckpointed; + return dev->is_checkpointed; } -static int yaffs2_ReadCheckpointData(yaffs_Device *dev) +static int yaffs2_rd_checkpt_data(struct yaffs_dev *dev) { int ok = 1; - - if(!dev->param.isYaffs2) + + if (!dev->param.is_yaffs2) ok = 0; - if (ok && dev->param.skipCheckpointRead) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("skipping checkpoint read" TENDSTR))); + if (ok && dev->param.skip_checkpt_rd) { + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("skipping checkpoint read" TENDSTR))); ok = 0; } if (ok) - ok = yaffs2_CheckpointOpen(dev, 0); /* open for read */ + ok = yaffs2_checkpt_open(dev, 0); /* open for read */ if (ok) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint validity" TENDSTR))); - ok = yaffs2_ReadCheckpointValidityMarker(dev, 1); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("read checkpoint validity" TENDSTR))); + ok = yaffs2_rd_checkpt_validity_marker(dev, 1); } if (ok) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint device" TENDSTR))); - ok = yaffs2_ReadCheckpointDevice(dev); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("read checkpoint device" TENDSTR))); + ok = yaffs2_rd_checkpt_dev(dev); } if (ok) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint objects" TENDSTR))); - ok = yaffs2_ReadCheckpointObjects(dev); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("read checkpoint objects" TENDSTR))); + ok = yaffs2_rd_checkpt_objs(dev); } if (ok) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint validity" TENDSTR))); - ok = yaffs2_ReadCheckpointValidityMarker(dev, 0); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("read checkpoint validity" TENDSTR))); + ok = yaffs2_rd_checkpt_validity_marker(dev, 0); } if (ok) { - ok = yaffs2_ReadCheckpointSum(dev); - T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint checksum %d" TENDSTR), ok)); + ok = yaffs2_rd_checkpt_sum(dev); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("read checkpoint checksum %d" TENDSTR), ok)); } - if (!yaffs2_CheckpointClose(dev)) + if (!yaffs_checkpt_close(dev)) ok = 0; if (ok) - dev->isCheckpointed = 1; + dev->is_checkpointed = 1; else - dev->isCheckpointed = 0; + dev->is_checkpointed = 0; return ok ? 1 : 0; } -void yaffs2_InvalidateCheckpoint(yaffs_Device *dev) +void yaffs2_checkpt_invalidate(struct yaffs_dev *dev) { - if (dev->isCheckpointed || - dev->blocksInCheckpoint > 0) { - dev->isCheckpointed = 0; - yaffs2_CheckpointInvalidateStream(dev); + if (dev->is_checkpointed || dev->blocks_in_checkpt > 0) { + dev->is_checkpointed = 0; + yaffs2_checkpt_invalidate_stream(dev); } - if (dev->param.markSuperBlockDirty) - dev->param.markSuperBlockDirty(dev); + if (dev->param.sb_dirty_fn) + dev->param.sb_dirty_fn(dev); } - -int yaffs_CheckpointSave(yaffs_Device *dev) +int yaffs_checkpoint_save(struct yaffs_dev *dev) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("save entry: isCheckpointed %d"TENDSTR), dev->isCheckpointed)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("save entry: is_checkpointed %d" TENDSTR), + dev->is_checkpointed)); - yaffs_VerifyObjects(dev); - yaffs_VerifyBlocks(dev); - yaffs_VerifyFreeChunks(dev); + yaffs_verify_objects(dev); + yaffs_verify_blocks(dev); + yaffs_verify_free_chunks(dev); - if (!dev->isCheckpointed) { - yaffs2_InvalidateCheckpoint(dev); - yaffs2_WriteCheckpointData(dev); + if (!dev->is_checkpointed) { + yaffs2_checkpt_invalidate(dev); + yaffs2_wr_checkpt_data(dev); } - T(YAFFS_TRACE_ALWAYS, (TSTR("save exit: isCheckpointed %d"TENDSTR), dev->isCheckpointed)); + T(YAFFS_TRACE_ALWAYS, + (TSTR("save exit: is_checkpointed %d" TENDSTR), + dev->is_checkpointed)); - return dev->isCheckpointed; + return dev->is_checkpointed; } -int yaffs2_CheckpointRestore(yaffs_Device *dev) +int yaffs2_checkpt_restore(struct yaffs_dev *dev) { int retval; - T(YAFFS_TRACE_CHECKPOINT, (TSTR("restore entry: isCheckpointed %d"TENDSTR), dev->isCheckpointed)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("restore entry: is_checkpointed %d" TENDSTR), + dev->is_checkpointed)); - retval = yaffs2_ReadCheckpointData(dev); + retval = yaffs2_rd_checkpt_data(dev); - if (dev->isCheckpointed) { - yaffs_VerifyObjects(dev); - yaffs_VerifyBlocks(dev); - yaffs_VerifyFreeChunks(dev); + if (dev->is_checkpointed) { + yaffs_verify_objects(dev); + yaffs_verify_blocks(dev); + yaffs_verify_free_chunks(dev); } - T(YAFFS_TRACE_CHECKPOINT, (TSTR("restore exit: isCheckpointed %d"TENDSTR), dev->isCheckpointed)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("restore exit: is_checkpointed %d" TENDSTR), + dev->is_checkpointed)); return retval; } -int yaffs2_HandleHole(yaffs_Object *obj, loff_t newSize) +int yaffs2_handle_hole(struct yaffs_obj *obj, loff_t new_size) { - /* if newsSize > oldFileSize. + /* if new_size > old_file_size. * We're going to be writing a hole. * If the hole is small then write zeros otherwise write a start of hole marker. */ - - loff_t oldFileSize; + loff_t old_file_size; int increase; - int smallHole ; + int small_hole; int result = YAFFS_OK; - yaffs_Device *dev = NULL; + struct yaffs_dev *dev = NULL; - __u8 *localBuffer = NULL; - - int smallIncreaseOk = 0; - - if(!obj) + u8 *local_buffer = NULL; + + int small_increase_ok = 0; + + if (!obj) return YAFFS_FAIL; - if(obj->variantType != YAFFS_OBJECT_TYPE_FILE) + if (obj->variant_type != YAFFS_OBJECT_TYPE_FILE) return YAFFS_FAIL; - - dev = obj->myDev; - + + dev = obj->my_dev; + /* Bail out if not yaffs2 mode */ - if(!dev->param.isYaffs2) + if (!dev->param.is_yaffs2) return YAFFS_OK; - oldFileSize = obj->variant.fileVariant.fileSize; + old_file_size = obj->variant.file_variant.file_size; - if (newSize <= oldFileSize) + if (new_size <= old_file_size) return YAFFS_OK; - increase = newSize - oldFileSize; + increase = new_size - old_file_size; - if(increase < YAFFS_SMALL_HOLE_THRESHOLD * dev->nDataBytesPerChunk && - yaffs_CheckSpaceForAllocation(dev, YAFFS_SMALL_HOLE_THRESHOLD + 1)) - smallHole = 1; + if (increase < YAFFS_SMALL_HOLE_THRESHOLD * dev->data_bytes_per_chunk && + yaffs_check_alloc_available(dev, YAFFS_SMALL_HOLE_THRESHOLD + 1)) + small_hole = 1; else - smallHole = 0; + small_hole = 0; - if(smallHole) - localBuffer= yaffs_GetTempBuffer(dev, __LINE__); - - if(localBuffer){ + if (small_hole) + local_buffer = yaffs_get_temp_buffer(dev, __LINE__); + + if (local_buffer) { /* fill hole with zero bytes */ - int pos = oldFileSize; - int thisWrite; + int pos = old_file_size; + int this_write; int written; - memset(localBuffer,0,dev->nDataBytesPerChunk); - smallIncreaseOk = 1; + memset(local_buffer, 0, dev->data_bytes_per_chunk); + small_increase_ok = 1; - while(increase > 0 && smallIncreaseOk){ - thisWrite = increase; - if(thisWrite > dev->nDataBytesPerChunk) - thisWrite = dev->nDataBytesPerChunk; - written = yaffs_DoWriteDataToFile(obj,localBuffer,pos,thisWrite,0); - if(written == thisWrite){ - pos += thisWrite; - increase -= thisWrite; + while (increase > 0 && small_increase_ok) { + this_write = increase; + if (this_write > dev->data_bytes_per_chunk) + this_write = dev->data_bytes_per_chunk; + written = + yaffs_do_file_wr(obj, local_buffer, pos, this_write, + 0); + if (written == this_write) { + pos += this_write; + increase -= this_write; } else - smallIncreaseOk = 0; + small_increase_ok = 0; } - yaffs_ReleaseTempBuffer(dev,localBuffer,__LINE__); + yaffs_release_temp_buffer(dev, local_buffer, __LINE__); - /* If we were out of space then reverse any chunks we've added */ - if(!smallIncreaseOk) - yaffs_ResizeDown(obj, oldFileSize); + /* If we were out of space then reverse any chunks we've added */ + if (!small_increase_ok) + yaffs_resize_file_down(obj, old_file_size); } - - if (!smallIncreaseOk && - obj->parent && - obj->parent->objectId != YAFFS_OBJECTID_UNLINKED && - obj->parent->objectId != YAFFS_OBJECTID_DELETED){ + + if (!small_increase_ok && + obj->parent && + obj->parent->obj_id != YAFFS_OBJECTID_UNLINKED && + obj->parent->obj_id != YAFFS_OBJECTID_DELETED) { /* Write a hole start header with the old file size */ - yaffs_UpdateObjectHeader(obj, NULL, 0, 1, 0, NULL); + yaffs_update_oh(obj, NULL, 0, 1, 0, NULL); } return result; } - -typedef struct { +struct yaffs_block_index { int seq; int block; -} yaffs_BlockIndex; - +}; static int yaffs2_ybicmp(const void *a, const void *b) { - register int aseq = ((yaffs_BlockIndex *)a)->seq; - register int bseq = ((yaffs_BlockIndex *)b)->seq; - register int ablock = ((yaffs_BlockIndex *)a)->block; - register int bblock = ((yaffs_BlockIndex *)b)->block; + int aseq = ((struct yaffs_block_index *)a)->seq; + int bseq = ((struct yaffs_block_index *)b)->seq; + int ablock = ((struct yaffs_block_index *)a)->block; + int bblock = ((struct yaffs_block_index *)b)->block; if (aseq == bseq) return ablock - bblock; else return aseq - bseq; } -int yaffs2_ScanBackwards(yaffs_Device *dev) +int yaffs2_scan_backwards(struct yaffs_dev *dev) { - yaffs_ExtendedTags tags; + struct yaffs_ext_tags tags; int blk; - int blockIterator; - int startIterator; - int endIterator; - int nBlocksToScan = 0; + int block_iter; + int start_iter; + int end_iter; + int n_to_scan = 0; int chunk; int result; int c; int deleted; - yaffs_BlockState state; - yaffs_Object *hardList = NULL; - yaffs_BlockInfo *bi; - __u32 sequenceNumber; - yaffs_ObjectHeader *oh; - yaffs_Object *in; - yaffs_Object *parent; - int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1; - int itsUnlinked; - __u8 *chunkData; + enum yaffs_block_state state; + struct yaffs_obj *hard_list = NULL; + struct yaffs_block_info *bi; + u32 seq_number; + struct yaffs_obj_hdr *oh; + struct yaffs_obj *in; + struct yaffs_obj *parent; + int n_blocks = dev->internal_end_block - dev->internal_start_block + 1; + int is_unlinked; + u8 *chunk_data; - int fileSize; - int isShrink; - int foundChunksInBlock; - int equivalentObjectId; + int file_size; + int is_shrink; + int found_chunks; + int equiv_id; int alloc_failed = 0; - - yaffs_BlockIndex *blockIndex = NULL; - int altBlockIndex = 0; + struct yaffs_block_index *block_index = NULL; + int alt_block_index = 0; T(YAFFS_TRACE_SCAN, (TSTR - ("yaffs2_ScanBackwards starts intstartblk %d intendblk %d..." - TENDSTR), dev->internalStartBlock, dev->internalEndBlock)); + ("yaffs2_scan_backwards starts intstartblk %d intendblk %d..." + TENDSTR), dev->internal_start_block, dev->internal_end_block)); + dev->seq_number = YAFFS_LOWEST_SEQUENCE_NUMBER; - dev->sequenceNumber = YAFFS_LOWEST_SEQUENCE_NUMBER; + block_index = YMALLOC(n_blocks * sizeof(struct yaffs_block_index)); - blockIndex = YMALLOC(nBlocks * sizeof(yaffs_BlockIndex)); - - if (!blockIndex) { - blockIndex = YMALLOC_ALT(nBlocks * sizeof(yaffs_BlockIndex)); - altBlockIndex = 1; + if (!block_index) { + block_index = + YMALLOC_ALT(n_blocks * sizeof(struct yaffs_block_index)); + alt_block_index = 1; } - if (!blockIndex) { + if (!block_index) { T(YAFFS_TRACE_SCAN, - (TSTR("yaffs2_ScanBackwards() could not allocate block index!" TENDSTR))); + (TSTR + ("yaffs2_scan_backwards() could not allocate block index!" + TENDSTR))); return YAFFS_FAIL; } - dev->blocksInCheckpoint = 0; + dev->blocks_in_checkpt = 0; - chunkData = yaffs_GetTempBuffer(dev, __LINE__); + chunk_data = yaffs_get_temp_buffer(dev, __LINE__); /* Scan all the blocks to determine their state */ - bi = dev->blockInfo; - for (blk = dev->internalStartBlock; blk <= dev->internalEndBlock; blk++) { - yaffs_ClearChunkBits(dev, blk); - bi->pagesInUse = 0; - bi->softDeletions = 0; + bi = dev->block_info; + for (blk = dev->internal_start_block; blk <= dev->internal_end_block; + blk++) { + yaffs_clear_chunk_bits(dev, blk); + bi->pages_in_use = 0; + bi->soft_del_pages = 0; - yaffs_QueryInitialBlockState(dev, blk, &state, &sequenceNumber); + yaffs_query_init_block_state(dev, blk, &state, &seq_number); - bi->blockState = state; - bi->sequenceNumber = sequenceNumber; + bi->block_state = state; + bi->seq_number = seq_number; - if (bi->sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA) - bi->blockState = state = YAFFS_BLOCK_STATE_CHECKPOINT; - if (bi->sequenceNumber == YAFFS_SEQUENCE_BAD_BLOCK) - bi->blockState = state = YAFFS_BLOCK_STATE_DEAD; + if (bi->seq_number == YAFFS_SEQUENCE_CHECKPOINT_DATA) + bi->block_state = state = YAFFS_BLOCK_STATE_CHECKPOINT; + if (bi->seq_number == YAFFS_SEQUENCE_BAD_BLOCK) + bi->block_state = state = YAFFS_BLOCK_STATE_DEAD; T(YAFFS_TRACE_SCAN_DEBUG, (TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk, - state, sequenceNumber)); - + state, seq_number)); if (state == YAFFS_BLOCK_STATE_CHECKPOINT) { - dev->blocksInCheckpoint++; + dev->blocks_in_checkpt++; } else if (state == YAFFS_BLOCK_STATE_DEAD) { T(YAFFS_TRACE_BAD_BLOCKS, @@ -999,27 +1049,27 @@ int yaffs2_ScanBackwards(yaffs_Device *dev) } else if (state == YAFFS_BLOCK_STATE_EMPTY) { T(YAFFS_TRACE_SCAN_DEBUG, (TSTR("Block empty " TENDSTR))); - dev->nErasedBlocks++; - dev->nFreeChunks += dev->param.nChunksPerBlock; + dev->n_erased_blocks++; + dev->n_free_chunks += dev->param.chunks_per_block; } else if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) { /* Determine the highest sequence number */ - if (sequenceNumber >= YAFFS_LOWEST_SEQUENCE_NUMBER && - sequenceNumber < YAFFS_HIGHEST_SEQUENCE_NUMBER) { + if (seq_number >= YAFFS_LOWEST_SEQUENCE_NUMBER && + seq_number < YAFFS_HIGHEST_SEQUENCE_NUMBER) { - blockIndex[nBlocksToScan].seq = sequenceNumber; - blockIndex[nBlocksToScan].block = blk; + block_index[n_to_scan].seq = seq_number; + block_index[n_to_scan].block = blk; - nBlocksToScan++; + n_to_scan++; - if (sequenceNumber >= dev->sequenceNumber) - dev->sequenceNumber = sequenceNumber; + if (seq_number >= dev->seq_number) + dev->seq_number = seq_number; } else { /* TODO: Nasty sequence number! */ T(YAFFS_TRACE_SCAN, (TSTR ("Block scanning block %d has bad sequence number %d" - TENDSTR), blk, sequenceNumber)); + TENDSTR), blk, seq_number)); } } @@ -1027,45 +1077,43 @@ int yaffs2_ScanBackwards(yaffs_Device *dev) } T(YAFFS_TRACE_SCAN, - (TSTR("%d blocks to be sorted..." TENDSTR), nBlocksToScan)); - - + (TSTR("%d blocks to be sorted..." TENDSTR), n_to_scan)); YYIELD(); - /* Sort the blocks by sequence number*/ - yaffs_qsort(blockIndex, nBlocksToScan, sizeof(yaffs_BlockIndex), yaffs2_ybicmp); + /* Sort the blocks by sequence number */ + yaffs_sort(block_index, n_to_scan, sizeof(struct yaffs_block_index), + yaffs2_ybicmp); YYIELD(); T(YAFFS_TRACE_SCAN, (TSTR("...done" TENDSTR))); /* Now scan the blocks looking at the data. */ - startIterator = 0; - endIterator = nBlocksToScan - 1; + start_iter = 0; + end_iter = n_to_scan - 1; T(YAFFS_TRACE_SCAN_DEBUG, - (TSTR("%d blocks to be scanned" TENDSTR), nBlocksToScan)); + (TSTR("%d blocks to be scanned" TENDSTR), n_to_scan)); /* For each block.... backwards */ - for (blockIterator = endIterator; !alloc_failed && blockIterator >= startIterator; - blockIterator--) { + for (block_iter = end_iter; !alloc_failed && block_iter >= start_iter; + block_iter--) { /* Cooperative multitasking! This loop can run for so long that watchdog timers expire. */ YYIELD(); /* get the block to scan in the correct order */ - blk = blockIndex[blockIterator].block; + blk = block_index[block_iter].block; - bi = yaffs_GetBlockInfo(dev, blk); + bi = yaffs_get_block_info(dev, blk); - - state = bi->blockState; + state = bi->block_state; deleted = 0; /* For each chunk in each block that needs scanning.... */ - foundChunksInBlock = 0; - for (c = dev->param.nChunksPerBlock - 1; + found_chunks = 0; + for (c = dev->param.chunks_per_block - 1; !alloc_failed && c >= 0 && (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING || state == YAFFS_BLOCK_STATE_ALLOCATING); c--) { @@ -1073,14 +1121,14 @@ int yaffs2_ScanBackwards(yaffs_Device *dev) * Read the tags and decide what to do */ - chunk = blk * dev->param.nChunksPerBlock + c; + chunk = blk * dev->param.chunks_per_block + c; - result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL, - &tags); + result = yaffs_rd_chunk_tags_nand(dev, chunk, NULL, + &tags); /* Let's have a good look at this chunk... */ - if (!tags.chunkUsed) { + if (!tags.chunk_used) { /* An unassigned chunk in the block. * If there are used chunks after this one, then * it is a chunk that was skipped due to failing the erased @@ -1090,16 +1138,19 @@ int yaffs2_ScanBackwards(yaffs_Device *dev) * this is the one being allocated from */ - if (foundChunksInBlock) { + if (found_chunks) { /* This is a chunk that was skipped due to failing the erased check */ } else if (c == 0) { /* We're looking at the first chunk in the block so the block is unused */ state = YAFFS_BLOCK_STATE_EMPTY; - dev->nErasedBlocks++; + dev->n_erased_blocks++; } else { - if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING || - state == YAFFS_BLOCK_STATE_ALLOCATING) { - if (dev->sequenceNumber == bi->sequenceNumber) { + if (state == + YAFFS_BLOCK_STATE_NEEDS_SCANNING + || state == + YAFFS_BLOCK_STATE_ALLOCATING) { + if (dev->seq_number == + bi->seq_number) { /* this is the block being allocated from */ T(YAFFS_TRACE_SCAN, @@ -1107,134 +1158,154 @@ int yaffs2_ScanBackwards(yaffs_Device *dev) (" Allocating from %d %d" TENDSTR), blk, c)); - state = YAFFS_BLOCK_STATE_ALLOCATING; - dev->allocationBlock = blk; - dev->allocationPage = c; - dev->allocationBlockFinder = blk; + state = + YAFFS_BLOCK_STATE_ALLOCATING; + dev->alloc_block = blk; + dev->alloc_page = c; + dev-> + alloc_block_finder = + blk; } else { /* This is a partially written block that is not * the current allocation block. */ - T(YAFFS_TRACE_SCAN, - (TSTR("Partially written block %d detected" TENDSTR), - blk)); + T(YAFFS_TRACE_SCAN, + (TSTR + ("Partially written block %d detected" + TENDSTR), blk)); } } } - dev->nFreeChunks++; + dev->n_free_chunks++; - } else if (tags.eccResult == YAFFS_ECC_RESULT_UNFIXED) { + } else if (tags.ecc_result == YAFFS_ECC_RESULT_UNFIXED) { T(YAFFS_TRACE_SCAN, - (TSTR(" Unfixed ECC in chunk(%d:%d), chunk ignored"TENDSTR), - blk, c)); + (TSTR + (" Unfixed ECC in chunk(%d:%d), chunk ignored" + TENDSTR), blk, c)); - dev->nFreeChunks++; + dev->n_free_chunks++; - } else if (tags.objectId > YAFFS_MAX_OBJECT_ID || - tags.chunkId > YAFFS_MAX_CHUNK_ID || - (tags.chunkId > 0 && tags.byteCount > dev->nDataBytesPerChunk) || - tags.sequenceNumber != bi->sequenceNumber ) { + } else if (tags.obj_id > YAFFS_MAX_OBJECT_ID || + tags.chunk_id > YAFFS_MAX_CHUNK_ID || + (tags.chunk_id > 0 + && tags.n_bytes > dev->data_bytes_per_chunk) + || tags.seq_number != bi->seq_number) { T(YAFFS_TRACE_SCAN, - (TSTR("Chunk (%d:%d) with bad tags:obj = %d, chunkId = %d, byteCount = %d, ignored"TENDSTR), - blk, c,tags.objectId, tags.chunkId, tags.byteCount)); + (TSTR + ("Chunk (%d:%d) with bad tags:obj = %d, chunk_id = %d, n_bytes = %d, ignored" + TENDSTR), blk, c, tags.obj_id, + tags.chunk_id, tags.n_bytes)); - dev->nFreeChunks++; + dev->n_free_chunks++; - } else if (tags.chunkId > 0) { - /* chunkId > 0 so it is a data chunk... */ + } else if (tags.chunk_id > 0) { + /* chunk_id > 0 so it is a data chunk... */ unsigned int endpos; - __u32 chunkBase = - (tags.chunkId - 1) * dev->nDataBytesPerChunk; + u32 chunk_base = + (tags.chunk_id - + 1) * dev->data_bytes_per_chunk; - foundChunksInBlock = 1; + found_chunks = 1; + yaffs_set_chunk_bit(dev, blk, c); + bi->pages_in_use++; - yaffs_SetChunkBit(dev, blk, c); - bi->pagesInUse++; - - in = yaffs_FindOrCreateObjectByNumber(dev, - tags. - objectId, - YAFFS_OBJECT_TYPE_FILE); + in = yaffs_find_or_create_by_number(dev, + tags.obj_id, + YAFFS_OBJECT_TYPE_FILE); if (!in) { /* Out of memory */ alloc_failed = 1; } if (in && - in->variantType == YAFFS_OBJECT_TYPE_FILE - && chunkBase < in->variant.fileVariant.shrinkSize) { + in->variant_type == YAFFS_OBJECT_TYPE_FILE + && chunk_base < + in->variant.file_variant.shrink_size) { /* This has not been invalidated by a resize */ - if (!yaffs_PutChunkIntoFile(in, tags.chunkId, chunk, -1)) { + if (!yaffs_put_chunk_in_file + (in, tags.chunk_id, chunk, -1)) { alloc_failed = 1; } /* File size is calculated by looking at the data chunks if we have not * seen an object header yet. Stop this practice once we find an object header. */ - endpos = chunkBase + tags.byteCount; + endpos = chunk_base + tags.n_bytes; if (!in->valid && /* have not got an object header yet */ - in->variant.fileVariant.scannedFileSize < endpos) { - in->variant.fileVariant.scannedFileSize = endpos; - in->variant.fileVariant.fileSize = endpos; + in->variant.file_variant. + scanned_size < endpos) { + in->variant.file_variant. + scanned_size = endpos; + in->variant.file_variant. + file_size = endpos; } } else if (in) { /* This chunk has been invalidated by a resize, or a past file deletion * so delete the chunk*/ - yaffs_DeleteChunk(dev, chunk, 1, __LINE__); + yaffs_chunk_del(dev, chunk, 1, + __LINE__); } } else { - /* chunkId == 0, so it is an ObjectHeader. + /* chunk_id == 0, so it is an ObjectHeader. * Thus, we read in the object header and make the object */ - foundChunksInBlock = 1; + found_chunks = 1; - yaffs_SetChunkBit(dev, blk, c); - bi->pagesInUse++; + yaffs_set_chunk_bit(dev, blk, c); + bi->pages_in_use++; oh = NULL; in = NULL; - if (tags.extraHeaderInfoAvailable) { - in = yaffs_FindOrCreateObjectByNumber(dev, - tags.objectId, - tags.extraObjectType); + if (tags.extra_available) { + in = yaffs_find_or_create_by_number(dev, + tags. + obj_id, + tags. + extra_obj_type); if (!in) alloc_failed = 1; } if (!in || - (!in->valid && dev->param.disableLazyLoad) || - tags.extraShadows || - (!in->valid && - (tags.objectId == YAFFS_OBJECTID_ROOT || - tags.objectId == YAFFS_OBJECTID_LOSTNFOUND))) { + (!in->valid && dev->param.disable_lazy_load) + || tags.extra_shadows || (!in->valid + && (tags.obj_id == + YAFFS_OBJECTID_ROOT + || tags. + obj_id == + YAFFS_OBJECTID_LOSTNFOUND))) + { /* If we don't have valid info then we need to read the chunk * TODO In future we can probably defer reading the chunk and * living with invalid data until needed. */ - result = yaffs_ReadChunkWithTagsFromNAND(dev, - chunk, - chunkData, - NULL); + result = yaffs_rd_chunk_tags_nand(dev, + chunk, + chunk_data, + NULL); - oh = (yaffs_ObjectHeader *) chunkData; + oh = (struct yaffs_obj_hdr *)chunk_data; - if (dev->param.inbandTags) { + if (dev->param.inband_tags) { /* Fix up the header if they got corrupted by inband tags */ - oh->shadowsObject = oh->inbandShadowsObject; - oh->isShrink = oh->inbandIsShrink; + oh->shadows_obj = + oh->inband_shadowed_obj_id; + oh->is_shrink = + oh->inband_is_shrink; } if (!in) { - in = yaffs_FindOrCreateObjectByNumber(dev, tags.objectId, oh->type); + in = yaffs_find_or_create_by_number(dev, tags.obj_id, oh->type); if (!in) alloc_failed = 1; } @@ -1246,7 +1317,7 @@ int yaffs2_ScanBackwards(yaffs_Device *dev) T(YAFFS_TRACE_ERROR, (TSTR ("yaffs tragedy: Could not make object for object %d at chunk %d during scan" - TENDSTR), tags.objectId, chunk)); + TENDSTR), tags.obj_id, chunk)); continue; } @@ -1256,61 +1327,80 @@ int yaffs2_ScanBackwards(yaffs_Device *dev) * we first have to suck out resize info if it is a file. */ - if ((in->variantType == YAFFS_OBJECT_TYPE_FILE) && - ((oh && - oh->type == YAFFS_OBJECT_TYPE_FILE) || - (tags.extraHeaderInfoAvailable && - tags.extraObjectType == YAFFS_OBJECT_TYPE_FILE))) { - __u32 thisSize = - (oh) ? oh->fileSize : tags. - extraFileLength; - __u32 parentObjectId = + if ((in->variant_type == + YAFFS_OBJECT_TYPE_FILE) && ((oh + && + oh-> + type + == + YAFFS_OBJECT_TYPE_FILE) + || + (tags. + extra_available + && + tags. + extra_obj_type + == + YAFFS_OBJECT_TYPE_FILE))) + { + u32 this_size = (oh) ? oh-> - parentObjectId : tags. - extraParentObjectId; + file_size : + tags.extra_length; + u32 parent_obj_id = + (oh) ? oh->parent_obj_id : + tags.extra_parent_id; - - isShrink = - (oh) ? oh->isShrink : tags. - extraIsShrinkHeader; + is_shrink = + (oh) ? oh-> + is_shrink : + tags.extra_is_shrink; /* If it is deleted (unlinked at start also means deleted) * we treat the file size as being zeroed at this point. */ - if (parentObjectId == + if (parent_obj_id == YAFFS_OBJECTID_DELETED - || parentObjectId == + || parent_obj_id == YAFFS_OBJECTID_UNLINKED) { - thisSize = 0; - isShrink = 1; + this_size = 0; + is_shrink = 1; } - if (isShrink && in->variant.fileVariant.shrinkSize > thisSize) - in->variant.fileVariant.shrinkSize = thisSize; + if (is_shrink + && in->variant.file_variant. + shrink_size > this_size) + in->variant. + file_variant. + shrink_size = + this_size; - if (isShrink) - bi->hasShrinkHeader = 1; + if (is_shrink) + bi->has_shrink_hdr = 1; } /* Use existing - destroy this one. */ - yaffs_DeleteChunk(dev, chunk, 1, __LINE__); + yaffs_chunk_del(dev, chunk, 1, + __LINE__); } - if (!in->valid && in->variantType != - (oh ? oh->type : tags.extraObjectType)) - T(YAFFS_TRACE_ERROR, ( - TSTR("yaffs tragedy: Bad object type, " - TCONT("%d != %d, for object %d at chunk ") + if (!in->valid && in->variant_type != + (oh ? oh->type : tags.extra_obj_type)) + T(YAFFS_TRACE_ERROR, + (TSTR + ("yaffs tragedy: Bad object type, " + TCONT + ("%d != %d, for object %d at chunk ") TCONT("%d during scan") - TENDSTR), oh ? - oh->type : tags.extraObjectType, - in->variantType, tags.objectId, - chunk)); + TENDSTR), oh ? + oh->type : tags.extra_obj_type, + in->variant_type, tags.obj_id, + chunk)); if (!in->valid && - (tags.objectId == YAFFS_OBJECTID_ROOT || - tags.objectId == + (tags.obj_id == YAFFS_OBJECTID_ROOT || + tags.obj_id == YAFFS_OBJECTID_LOSTNFOUND)) { /* We only load some info, don't fiddle with directory structure */ in->valid = 1; @@ -1318,83 +1408,54 @@ int yaffs2_ScanBackwards(yaffs_Device *dev) if (oh) { in->yst_mode = oh->yst_mode; -#ifdef CONFIG_YAFFS_WINCE - in->win_atime[0] = oh->win_atime[0]; - in->win_ctime[0] = oh->win_ctime[0]; - in->win_mtime[0] = oh->win_mtime[0]; - in->win_atime[1] = oh->win_atime[1]; - in->win_ctime[1] = oh->win_ctime[1]; - in->win_mtime[1] = oh->win_mtime[1]; -#else - in->yst_uid = oh->yst_uid; - in->yst_gid = oh->yst_gid; - in->yst_atime = oh->yst_atime; - in->yst_mtime = oh->yst_mtime; - in->yst_ctime = oh->yst_ctime; - in->yst_rdev = oh->yst_rdev; - - in->lazyLoaded = 0; - -#endif + yaffs_load_attribs(in, oh); + in->lazy_loaded = 0; } else - in->lazyLoaded = 1; + in->lazy_loaded = 1; - in->hdrChunk = chunk; + in->hdr_chunk = chunk; } else if (!in->valid) { /* we need to load this info */ in->valid = 1; - in->hdrChunk = chunk; + in->hdr_chunk = chunk; if (oh) { - in->variantType = oh->type; + in->variant_type = oh->type; in->yst_mode = oh->yst_mode; -#ifdef CONFIG_YAFFS_WINCE - in->win_atime[0] = oh->win_atime[0]; - in->win_ctime[0] = oh->win_ctime[0]; - in->win_mtime[0] = oh->win_mtime[0]; - in->win_atime[1] = oh->win_atime[1]; - in->win_ctime[1] = oh->win_ctime[1]; - in->win_mtime[1] = oh->win_mtime[1]; -#else - in->yst_uid = oh->yst_uid; - in->yst_gid = oh->yst_gid; - in->yst_atime = oh->yst_atime; - in->yst_mtime = oh->yst_mtime; - in->yst_ctime = oh->yst_ctime; - in->yst_rdev = oh->yst_rdev; -#endif + yaffs_load_attribs(in, oh); - if (oh->shadowsObject > 0) - yaffs_HandleShadowedObject(dev, - oh-> - shadowsObject, - 1); - + if (oh->shadows_obj > 0) + yaffs_handle_shadowed_obj + (dev, + oh->shadows_obj, + 1); - - yaffs_SetObjectNameFromOH(in, oh); + yaffs_set_obj_name_from_oh(in, + oh); parent = - yaffs_FindOrCreateObjectByNumber - (dev, oh->parentObjectId, - YAFFS_OBJECT_TYPE_DIRECTORY); + yaffs_find_or_create_by_number + (dev, oh->parent_obj_id, + YAFFS_OBJECT_TYPE_DIRECTORY); - fileSize = oh->fileSize; - isShrink = oh->isShrink; - equivalentObjectId = oh->equivalentObjectId; + file_size = oh->file_size; + is_shrink = oh->is_shrink; + equiv_id = oh->equiv_id; } else { - in->variantType = tags.extraObjectType; + in->variant_type = + tags.extra_obj_type; parent = - yaffs_FindOrCreateObjectByNumber - (dev, tags.extraParentObjectId, - YAFFS_OBJECT_TYPE_DIRECTORY); - fileSize = tags.extraFileLength; - isShrink = tags.extraIsShrinkHeader; - equivalentObjectId = tags.extraEquivalentObjectId; - in->lazyLoaded = 1; + yaffs_find_or_create_by_number + (dev, tags.extra_parent_id, + YAFFS_OBJECT_TYPE_DIRECTORY); + file_size = tags.extra_length; + is_shrink = + tags.extra_is_shrink; + equiv_id = tags.extra_equiv_id; + in->lazy_loaded = 1; } in->dirty = 0; @@ -1406,16 +1467,17 @@ int yaffs2_ScanBackwards(yaffs_Device *dev) * hook up to parent */ - if (parent && parent->variantType == + if (parent && parent->variant_type == YAFFS_OBJECT_TYPE_UNKNOWN) { /* Set up as a directory */ - parent->variantType = - YAFFS_OBJECT_TYPE_DIRECTORY; - YINIT_LIST_HEAD(&parent->variant. - directoryVariant. - children); - } else if (!parent || parent->variantType != - YAFFS_OBJECT_TYPE_DIRECTORY) { + parent->variant_type = + YAFFS_OBJECT_TYPE_DIRECTORY; + INIT_LIST_HEAD(&parent-> + variant.dir_variant.children); + } else if (!parent + || parent->variant_type != + YAFFS_OBJECT_TYPE_DIRECTORY) + { /* Hoosterman, another problem.... * We're trying to use a non-directory as a directory */ @@ -1424,17 +1486,17 @@ int yaffs2_ScanBackwards(yaffs_Device *dev) (TSTR ("yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found." TENDSTR))); - parent = dev->lostNFoundDir; + parent = dev->lost_n_found; } - yaffs_AddObjectToDirectory(parent, in); + yaffs_add_obj_to_dir(parent, in); - itsUnlinked = (parent == dev->deletedDir) || - (parent == dev->unlinkedDir); + is_unlinked = (parent == dev->del_dir) + || (parent == dev->unlinked_dir); - if (isShrink) { - /* Mark the block as having a shrinkHeader */ - bi->hasShrinkHeader = 1; + if (is_shrink) { + /* Mark the block as having a shrink header */ + bi->has_shrink_hdr = 1; } /* Note re hardlinks. @@ -1444,35 +1506,47 @@ int yaffs2_ScanBackwards(yaffs_Device *dev) * through this list and fix up all the chains. */ - switch (in->variantType) { + switch (in->variant_type) { case YAFFS_OBJECT_TYPE_UNKNOWN: /* Todo got a problem */ break; case YAFFS_OBJECT_TYPE_FILE: - if (in->variant.fileVariant. - scannedFileSize < fileSize) { + if (in->variant. + file_variant.scanned_size < + file_size) { /* This covers the case where the file size is greater * than where the data is * This will happen if the file is resized to be larger * than its current data extents. */ - in->variant.fileVariant.fileSize = fileSize; - in->variant.fileVariant.scannedFileSize = fileSize; + in->variant. + file_variant. + file_size = + file_size; + in->variant. + file_variant. + scanned_size = + file_size; } - if (in->variant.fileVariant.shrinkSize > fileSize) - in->variant.fileVariant.shrinkSize = fileSize; - + if (in->variant.file_variant. + shrink_size > file_size) + in->variant. + file_variant. + shrink_size = + file_size; break; case YAFFS_OBJECT_TYPE_HARDLINK: - if (!itsUnlinked) { - in->variant.hardLinkVariant.equivalentObjectId = - equivalentObjectId; - in->hardLinks.next = - (struct ylist_head *) hardList; - hardList = in; + if (!is_unlinked) { + in->variant. + hardlink_variant. + equiv_id = equiv_id; + in->hard_links.next = + (struct list_head *) + hard_list; + hard_list = in; } break; case YAFFS_OBJECT_TYPE_DIRECTORY: @@ -1483,10 +1557,16 @@ int yaffs2_ScanBackwards(yaffs_Device *dev) break; case YAFFS_OBJECT_TYPE_SYMLINK: if (oh) { - in->variant.symLinkVariant.alias = - yaffs_CloneString(oh->alias); - if (!in->variant.symLinkVariant.alias) - alloc_failed = 1; + in->variant. + symlink_variant. + alias = + yaffs_clone_str(oh-> + alias); + if (!in->variant. + symlink_variant. + alias) + alloc_failed = + 1; } break; } @@ -1495,46 +1575,44 @@ int yaffs2_ScanBackwards(yaffs_Device *dev) } - } /* End of scanning for each chunk */ + } /* End of scanning for each chunk */ if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) { /* If we got this far while scanning, then the block is fully allocated. */ state = YAFFS_BLOCK_STATE_FULL; } - - bi->blockState = state; + bi->block_state = state; /* Now let's see if it was dirty */ - if (bi->pagesInUse == 0 && - !bi->hasShrinkHeader && - bi->blockState == YAFFS_BLOCK_STATE_FULL) { - yaffs_BlockBecameDirty(dev, blk); + if (bi->pages_in_use == 0 && + !bi->has_shrink_hdr && + bi->block_state == YAFFS_BLOCK_STATE_FULL) { + yaffs_block_became_dirty(dev, blk); } } - - yaffs_SkipRestOfBlock(dev); - if (altBlockIndex) - YFREE_ALT(blockIndex); + yaffs_skip_rest_of_block(dev); + + if (alt_block_index) + YFREE_ALT(block_index); else - YFREE(blockIndex); + YFREE(block_index); /* Ok, we've done all the scanning. * Fix up the hard link chains. * We should now have scanned all the objects, now it's time to add these * hardlinks. */ - yaffs_HardlinkFixup(dev, hardList); + yaffs_link_fixup(dev, hard_list); - - yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__); + yaffs_release_temp_buffer(dev, chunk_data, __LINE__); if (alloc_failed) return YAFFS_FAIL; - T(YAFFS_TRACE_SCAN, (TSTR("yaffs2_ScanBackwards ends" TENDSTR))); + T(YAFFS_TRACE_SCAN, (TSTR("yaffs2_scan_backwards ends" TENDSTR))); return YAFFS_OK; } diff --git a/fs/yaffs2/yaffs_yaffs2.h b/fs/yaffs2/yaffs_yaffs2.h index 67dc8f15..e1a9287f 100644 --- a/fs/yaffs2/yaffs_yaffs2.h +++ b/fs/yaffs2/yaffs_yaffs2.h @@ -1,5 +1,5 @@ /* - * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. * * Copyright (C) 2002-2010 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering @@ -7,8 +7,10 @@ * Created by Charles Manning * * 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 + * it under the terms of the GNU Lesser General Public License version 2.1 as * published by the Free Software Foundation. + * + * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. */ #ifndef __YAFFS_YAFFS2_H__ @@ -16,21 +18,22 @@ #include "yaffs_guts.h" -void yaffs2_CalcOldestDirtySequence(yaffs_Device *dev); -void yaffs2_FindOldestDirtySequence(yaffs_Device *dev); -void yaffs2_ClearOldestDirtySequence(yaffs_Device *dev, yaffs_BlockInfo *bi); -void yaffs2_UpdateOldestDirtySequence(yaffs_Device *dev, unsigned blockNo, yaffs_BlockInfo *bi); -int yaffs2_BlockNotDisqualifiedFromGC(yaffs_Device *dev, yaffs_BlockInfo *bi); -__u32 yaffs2_FindRefreshBlock(yaffs_Device *dev); -int yaffs2_CheckpointRequired(yaffs_Device *dev); -int yaffs2_CalcCheckpointBlocksRequired(yaffs_Device *dev); +void yaffs_calc_oldest_dirty_seq(struct yaffs_dev *dev); +void yaffs2_find_oldest_dirty_seq(struct yaffs_dev *dev); +void yaffs2_clear_oldest_dirty_seq(struct yaffs_dev *dev, + struct yaffs_block_info *bi); +void yaffs2_update_oldest_dirty_seq(struct yaffs_dev *dev, unsigned block_no, + struct yaffs_block_info *bi); +int yaffs_block_ok_for_gc(struct yaffs_dev *dev, struct yaffs_block_info *bi); +u32 yaffs2_find_refresh_block(struct yaffs_dev *dev); +int yaffs2_checkpt_required(struct yaffs_dev *dev); +int yaffs_calc_checkpt_blocks_required(struct yaffs_dev *dev); +void yaffs2_checkpt_invalidate(struct yaffs_dev *dev); +int yaffs2_checkpt_save(struct yaffs_dev *dev); +int yaffs2_checkpt_restore(struct yaffs_dev *dev); -void yaffs2_InvalidateCheckpoint(yaffs_Device *dev); -int yaffs2_CheckpointSave(yaffs_Device *dev); -int yaffs2_CheckpointRestore(yaffs_Device *dev); - -int yaffs2_HandleHole(yaffs_Object *obj, loff_t newSize); -int yaffs2_ScanBackwards(yaffs_Device *dev); +int yaffs2_handle_hole(struct yaffs_obj *obj, loff_t new_size); +int yaffs2_scan_backwards(struct yaffs_dev *dev); #endif diff --git a/fs/yaffs2/yaffsinterface.h b/fs/yaffs2/yaffsinterface.h deleted file mode 100644 index ca36cfc4..00000000 --- a/fs/yaffs2/yaffsinterface.h +++ /dev/null @@ -1,21 +0,0 @@ -/* - * YAFFS: Yet another Flash File System . A NAND-flash specific file system. - * - * Copyright (C) 2002-2010 Aleph One Ltd. - * for Toby Churchill Ltd and Brightstar Engineering - * - * Created by Charles Manning - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License version 2.1 as - * published by the Free Software Foundation. - * - * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. - */ - -#ifndef __YAFFSINTERFACE_H__ -#define __YAFFSINTERFACE_H__ - -int yaffs_Initialise(unsigned nBlocks); - -#endif diff --git a/fs/yaffs2/yportenv.h b/fs/yaffs2/yportenv.h index 83203c88..ec43fd58 100644 --- a/fs/yaffs2/yportenv.h +++ b/fs/yaffs2/yportenv.h @@ -13,7 +13,6 @@ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. */ - #ifndef __YPORTENV_H__ #define __YPORTENV_H__ @@ -41,7 +40,7 @@ #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)) #include #endif - +#include #include #include #include @@ -49,6 +48,11 @@ #include #include #include +#include +#include +#include +#include +#include #define YCHAR char #define YUCHAR unsigned char @@ -60,6 +64,7 @@ #define yaffs_strnlen(s,m) strnlen(s,m) #define yaffs_sprintf sprintf #define yaffs_toupper(a) toupper(a) +#define yaffs_sort(base, n, sz, cmp_fn) sort(base, n, sz, cmp_fn, NULL) #define Y_INLINE __inline__ @@ -87,7 +92,7 @@ #define Y_TIME_CONVERT(x) (x) #endif -#define yaffs_SumCompare(x, y) ((x) == (y)) +#define yaffs_sum_cmp(x, y) ((x) == (y)) #define yaffs_strcmp(a, b) strcmp(a, b) #define TENDSTR "\n" @@ -113,7 +118,6 @@ #include "stdio.h" #include "string.h" - #define YMALLOC(x) malloc(x) #define YFREE(x) free(x) #define YMALLOC_ALT(x) malloc(x) @@ -145,7 +149,7 @@ #define YAFFS_ROOT_MODE 0755 #define YAFFS_LOSTNFOUND_MODE 0700 -#define yaffs_SumCompare(x, y) ((x) == (y)) +#define yaffs_sum_cmp(x, y) ((x) == (y)) #define yaffs_strcmp(a, b) strcmp(a, b) #else @@ -170,7 +174,7 @@ #define O_RDWR 02 #endif -#ifndef O_CREAT +#ifndef O_CREAT #define O_CREAT 0100 #endif @@ -210,6 +214,10 @@ #define EINVAL 22 #endif +#ifndef ENFILE +#define ENFILE 23 +#endif + #ifndef EBADF #define EBADF 9 #endif @@ -218,7 +226,7 @@ #define EACCES 13 #endif -#ifndef EXDEV +#ifndef EXDEV #define EXDEV 18 #endif @@ -262,7 +270,6 @@ #define EISDIR 21 #endif - // Mode flags #ifndef S_IFMT @@ -281,7 +288,7 @@ #define S_IFREG 0100000 #endif -#ifndef S_IREAD +#ifndef S_IREAD #define S_IREAD 0000400 #endif @@ -329,5 +336,4 @@ } while (0) #endif - #endif From d929bed06cfe0d844b83312a7296e169222b9c57 Mon Sep 17 00:00:00 2001 From: Markinus Date: Thu, 11 Nov 2010 18:12:44 +0100 Subject: [PATCH 02/10] camera: added desire autofocus stuff, is working now with the enabled 720p code. Increased clock for higher frame rates. --- drivers/media/video/msm/s5k3e2fx.c | 54 +++++++++++++++++++++--------- 1 file changed, 39 insertions(+), 15 deletions(-) diff --git a/drivers/media/video/msm/s5k3e2fx.c b/drivers/media/video/msm/s5k3e2fx.c index abe64fa7..7770c05a 100644 --- a/drivers/media/video/msm/s5k3e2fx.c +++ b/drivers/media/video/msm/s5k3e2fx.c @@ -22,8 +22,9 @@ static uint16_t g_usModuleVersion; /*0: rev.4, 1: rev.5 */ #ifdef CONFIG_MACH_PASSIONC #define REG_PLL_MULTIPLIER_LSB_VALUE 0xA0 #else -#define REG_PLL_MULTIPLIER_LSB_VALUE 0x90 +#define REG_PLL_MULTIPLIER_LSB_VALUE 0xA6 #endif +/* 0xA6 for PCLK=83MHz */ /* 0xA0 for PCLK=80MHz */ /* 0x90 for PCLK=72MHz */ @@ -3082,7 +3083,9 @@ static int s5k3e2fx_set_default_focus(void) return rc; } -static int s5k3e2fx_move_focus(int direction, int num_steps) +static int s5k3e2fx_move_focus( + int direction, int num_steps,int coarse_delay,int fine_delay, + int step_dir, int init_code_offset_max) { int rc = 0; int i; @@ -3093,11 +3096,30 @@ static int s5k3e2fx_move_focus(int direction, int num_steps) uint8_t next_pos_msb, next_pos_lsb; int16_t s_move[5]; uint32_t gain; /* Q10 format */ + int16_t step_direction_pre_define; + int16_t init_code_offset_pre_define; + int16_t coarse_search_delay; + int16_t fine_search_delay; + + if (g_usModuleVersion == 1) { /* EVT5 */ + step_direction_pre_define = step_dir; + init_code_offset_pre_define = init_code_offset_max; + /*fine search delay time is turnable*/ + coarse_search_delay = coarse_delay; + fine_search_delay = fine_delay; + } else { + step_direction_pre_define = 20; + init_code_offset_pre_define = 738; + coarse_search_delay = 6; + fine_search_delay = 4; + } + +pr_info("%s step_direction_pre_define %d\n", __func__, step_direction_pre_define); if (direction == MOVE_NEAR) - step_direction = 20; + step_direction = step_direction_pre_define; else if (direction == MOVE_FAR) - step_direction = -20; + step_direction = 0 - step_direction_pre_define; else { pr_err("s5k3e2fx_move_focus failed at line %d ...\n", __LINE__); return -EINVAL; @@ -3122,8 +3144,8 @@ static int s5k3e2fx_move_focus(int direction, int num_steps) for (i = 0; i <= 4; i++) { next_pos = (int16_t) (pos_offset + s_move[i]); - if (next_pos > (738 + init_code)) - next_pos = 738 + init_code; + if (next_pos > (init_code_offset_max + init_code)) + next_pos = init_code_offset_pre_define + init_code; else if (next_pos < 0) next_pos = 0; @@ -3147,10 +3169,11 @@ static int s5k3e2fx_move_focus(int direction, int num_steps) pos_offset = next_pos; s5k3e2fx_ctrl->curr_lens_pos = pos_offset - init_code; - if (num_steps > 1) - mdelay(6); + + if(num_steps > 1) + mdelay(coarse_search_delay); else - mdelay(4); + mdelay(fine_search_delay); } return rc; @@ -3375,8 +3398,8 @@ static ssize_t sensor_read_node(struct device *dev, } static DEVICE_ATTR(htcwc, 0777, htcwc_get, htcwc_set); -static DEVICE_ATTR(sensor, 0444, sensor_vendor_show, NULL); static DEVICE_ATTR(node, 0444, sensor_read_node, NULL); +static DEVICE_ATTR(sensor, 0444, sensor_vendor_show, NULL); static struct kobject *android_s5k3e2fx; static struct kobject *android_s5k3e2fx_des; @@ -3399,7 +3422,7 @@ static int s5k3e2fx_sysfs_init(void) "failed\n"); kobject_del(android_s5k3e2fx_des); } - + android_s5k3e2fx = kobject_create_and_add("android_camera2", NULL); if (android_s5k3e2fx == NULL) { pr_info("s5k3e2fx_sysfs_init: subsystem_register " \ @@ -3414,13 +3437,11 @@ static int s5k3e2fx_sysfs_init(void) "failed\n"); kobject_del(android_s5k3e2fx); } - ret = sysfs_create_file(android_s5k3e2fx, &dev_attr_htcwc.attr); if (ret) { pr_info("ov9665_sysfs_init: sysfs_create_file htcwc failed\n"); kobject_del(android_s5k3e2fx); } - ret = sysfs_create_file(android_s5k3e2fx, &dev_attr_node.attr); if (ret) { pr_info("ov9665_sysfs_init: dev_attr_node failed\n"); @@ -3517,7 +3538,11 @@ static int s5k3e2fx_sensor_config(void __user *argp) case CFG_MOVE_FOCUS: rc = s5k3e2fx_move_focus(cdata.cfg.focus.dir, - cdata.cfg.focus.steps); + cdata.cfg.focus.steps, + cdata.cfg.focus.coarse_delay, + cdata.cfg.focus.fine_delay, + cdata.cfg.focus.step_dir, + cdata.cfg.focus.init_code_offset_max); break; case CFG_SET_DEFAULT_FOCUS: @@ -3558,7 +3583,6 @@ static int s5k3e2fx_sensor_probe(struct msm_camera_sensor_info *info, } msm_camio_clk_rate_set(S5K3E2FX_DEF_MCLK); - sensor_probe_node = s->node; msleep(20); rc = s5k3e2fx_probe_init_sensor(info); From a4242d53485b4fbef496c6106f03c167ab9106ec Mon Sep 17 00:00:00 2001 From: Markinus Date: Thu, 11 Nov 2010 20:09:06 +0100 Subject: [PATCH 03/10] htcleo: cleanups --- drivers/net/msm_rmnet_wince.c | 5 ----- 1 file changed, 5 deletions(-) diff --git a/drivers/net/msm_rmnet_wince.c b/drivers/net/msm_rmnet_wince.c index 7085d17b..ad1d1c93 100644 --- a/drivers/net/msm_rmnet_wince.c +++ b/drivers/net/msm_rmnet_wince.c @@ -87,11 +87,6 @@ static int count_this_packet(void *_hdr, int len) static int in_suspend; static unsigned long timeout_us; static struct workqueue_struct *rmnet_wq; -extern int smd_read(smd_channel_t *ch, void *data, int len); -extern int smd_open(const char *name, smd_channel_t **_ch, - void *priv, void (*notify)(void *, unsigned)); -extern int smd_write_atomic(smd_channel_t *ch, const void *data, int len); -extern int smd_read_avail(smd_channel_t *ch); static void do_check_active(struct work_struct *work) { From 4d523a124b9653b8a917cf3c58fc3895dab9686f Mon Sep 17 00:00:00 2001 From: Markinus Date: Sun, 14 Nov 2010 16:39:41 +0100 Subject: [PATCH 04/10] Revert "battery driver: reduce dmesg verbosity for normal use" This reverts commit bb612364fc92222e48349530daae9b0ac69f6887. --- drivers/power/ds2746_battery.c | 16 ---------------- drivers/power/ds2746_param.c | 2 -- 2 files changed, 18 deletions(-) diff --git a/drivers/power/ds2746_battery.c b/drivers/power/ds2746_battery.c index 931191b4..56fbcc66 100644 --- a/drivers/power/ds2746_battery.c +++ b/drivers/power/ds2746_battery.c @@ -580,9 +580,7 @@ static void __update_capacity(void) { INT32 next_capacity_01p; -#if HTC_BATTERY_DS2746_DEBUG_ENABLE pr_info("ds2746_batt:__update_capacity start\n"); -#endif if (poweralg.charge_state == CHARGE_STATE_PREDICTION || poweralg.charge_state == CHARGE_STATE_UNKNOWN){ @@ -791,7 +789,6 @@ BOOL do_power_alg(BOOL is_event_triggered) /*powerlog_to_file(&poweralg); update_os_batt_status(&poweralg);*/ -#if HTC_BATTERY_DS2746_DEBUG_ENABLE printk(DRIVER_ZONE "[%d] P=%d cable=%d%d flags=%d%d%d debug=%d%d%d%d fst_discharge=%d/%d [%u]\n", poweralg.charge_state, poweralg.capacity_01p, @@ -807,7 +804,6 @@ BOOL do_power_alg(BOOL is_event_triggered) poweralg.fst_discharge_capacity_01p, poweralg.fst_discharge_acr_mAh, BAHW_MyGetMSecs()); -#endif return TRUE; } @@ -885,9 +881,7 @@ void power_alg_preinit(void) static BLOCKING_NOTIFIER_HEAD(ds2746_notifier_list); int ds2746_register_notifier(struct notifier_block *nb) { -#if HTC_BATTERY_DS2746_DEBUG_ENABLE pr_info("%s\n", __func__); -#endif return blocking_notifier_chain_register(&ds2746_notifier_list, nb); } @@ -900,9 +894,7 @@ int ds2746_unregister_notifier(struct notifier_block *nb) int ds2746_blocking_notify(unsigned long val, void *v) { int chg_ctl; -#if HTC_BATTERY_DS2746_DEBUG_ENABLE pr_info("%s\n", __func__); -#endif if (val == DS2784_CHARGING_CONTROL){ chg_ctl = *(int *) v; @@ -1052,23 +1044,17 @@ void ds2746_charger_control(int type) else if (htc_batt_info.rep.battery_full) pr_info("batt: charging OFF [FULL]\n"); else*/ -#if HTC_BATTERY_DS2746_DEBUG_ENABLE pr_info("batt: charging OFF\n"); -#endif break; case CHARGE_SLOW: chg_ctl = ENABLE_SLOW_CHG; ds2746_blocking_notify(DS2784_CHARGING_CONTROL, &chg_ctl); -#if HTC_BATTERY_DS2746_DEBUG_ENABLE pr_info("batt: charging SLOW\n"); -#endif break; case CHARGE_FAST: chg_ctl = ENABLE_FAST_CHG; ds2746_blocking_notify(DS2784_CHARGING_CONTROL, &chg_ctl); -#if HTC_BATTERY_DS2746_DEBUG_ENABLE pr_info("batt: charging FAST\n"); -#endif break; } } @@ -1091,9 +1077,7 @@ static void ds2746_battery_work(struct work_struct *work) struct ds2746_device_info, monitor_work); unsigned long flags; -#if HTC_BATTERY_DS2746_DEBUG_ENABLE pr_info("[ds2746_batt] ds2746_battery_work*\n"); -#endif do_power_alg(0); get_state_check_interval_min_sec(); di->last_poll = alarm_get_elapsed_realtime(); diff --git a/drivers/power/ds2746_param.c b/drivers/power/ds2746_param.c index 7744465c..714bc7ad 100644 --- a/drivers/power/ds2746_param.c +++ b/drivers/power/ds2746_param.c @@ -507,7 +507,6 @@ static BOOL __ds2746_battery_adc_udpate(struct battery_type *battery) return FALSE; } -#if HTC_ENABLE_POWER_DEBUG printk(DRIVER_ZONE " [x0]%x [x8]%x %x %x %x %x %x %x %x %x %x\n", reg[0], reg[2], @@ -520,7 +519,6 @@ static BOOL __ds2746_battery_adc_udpate(struct battery_type *battery) reg[9], reg[10], reg[11]); -#endif if (!(reg[0] & DS2746_STATUS_AIN0) || !(reg[0] & DS2746_STATUS_AIN1)) { printk(DRIVER_ZONE " AIN not ready...\n"); From 9b7f42ceee93ee57fc969d16d82e9612c94c657d Mon Sep 17 00:00:00 2001 From: Markinus Date: Sun, 14 Nov 2010 16:39:53 +0100 Subject: [PATCH 05/10] Revert "htcleo: add new battery temperature table" This reverts commit 53a7287c1b52667b8e3f236e69e55c7b68a5373b. --- arch/arm/mach-msm/board-htcleo.c | 2 +- drivers/power/ds2746_param.c | 5 +---- include/linux/ds2746_param_config.h | 12 ------------ 3 files changed, 2 insertions(+), 17 deletions(-) diff --git a/arch/arm/mach-msm/board-htcleo.c b/arch/arm/mach-msm/board-htcleo.c index 0fe32396..8cfdc3ec 100644 --- a/arch/arm/mach-msm/board-htcleo.c +++ b/arch/arm/mach-msm/board-htcleo.c @@ -739,7 +739,7 @@ static struct platform_device htc_battery_pdev = { static int get_thermal_id(void) { - return THERMAL_600; + return THERMAL_300; } static struct ds2746_platform_data ds2746_pdev_data = { diff --git a/drivers/power/ds2746_param.c b/drivers/power/ds2746_param.c index 714bc7ad..db462c66 100644 --- a/drivers/power/ds2746_param.c +++ b/drivers/power/ds2746_param.c @@ -843,10 +843,7 @@ void battery_param_init(struct battery_type *battery) if (battery->thermal_id == THERMAL_1000) { TEMP_MAP = TEMP_MAP_1000K; printk(DRIVER_ZONE "Use 1000 Kohm thermal resistance"); - } else if (battery->thermal_id == THERMAL_600) { - TEMP_MAP = TEMP_MAP_600K; - printk(DRIVER_ZONE "Use 600 Kohm thermal resistance"); - } else { + } else { printk(DRIVER_ZONE "Use default(300 Kohm) thermal resistance"); } diff --git a/include/linux/ds2746_param_config.h b/include/linux/ds2746_param_config.h index eea2b3e2..ff77356e 100644 --- a/include/linux/ds2746_param_config.h +++ b/include/linux/ds2746_param_config.h @@ -71,17 +71,6 @@ UINT32 TEMP_MAP_300K[] = 1406, 1433, 2047, }; -UINT32 TEMP_MAP_600K[] = -{ -0,56,59,60,63,65,68,70,73,75,78,81,84,87,91,94,98, -102,105,110,114,118,123,128,133,138,144,149,156,161, -168,175,181,189,197,205,213,222,231,240,250,260,270, -281,293,304,317,329,343,356,371,385,401,417,433,450, -467,486,504,523,543,563,584,616,628,650,674,697,721, -746,772,798,824,851,878,906,934,962,991,1020, -1050,1079,2047, -}; - UINT32 TEMP_MAP_1000K[] = { 0, 30, 31, 32, 34, 35, 36, 38, 39, 40, @@ -95,7 +84,6 @@ UINT32 TEMP_MAP_1000K[] = 812, 843, 2047, }; - UINT32 *TEMP_MAP = TEMP_MAP_300K; UINT32 FL_25[] = From d71283a773be4674adbebab48ed3e4ce83fb20f5 Mon Sep 17 00:00:00 2001 From: Markinus Date: Sun, 14 Nov 2010 18:21:06 +0100 Subject: [PATCH 06/10] Revert "htcleo: add new battery driver" This reverts commit 55ca1d277a7b7a99ed02e8e14b5e36f0c5e9e86d. Conflicts: arch/arm/configs/htcleo_defconfig arch/arm/mach-msm/board-htcleo.c arch/arm/mach-msm/htc_battery.c include/linux/ds2746_battery.h --- arch/arm/configs/htcleo_defconfig | 4 +- arch/arm/mach-msm/Makefile | 4 +- arch/arm/mach-msm/board-htcleo-battery.c | 728 ++++++++++ arch/arm/mach-msm/board-htcleo-power.c | 214 +++ arch/arm/mach-msm/board-htcleo.c | 50 +- arch/arm/mach-msm/htc_battery.c | 238 +--- arch/arm/mach-msm/include/mach/htc_battery.h | 14 +- drivers/power/ds2746_battery.c | 1248 ------------------ drivers/power/ds2746_param.c | 852 ------------ include/linux/ds2746_battery.h | 148 --- include/linux/ds2746_battery_config.h | 44 - include/linux/ds2746_param.h | 70 - include/linux/ds2746_param_config.h | 274 ---- include/linux/tps65200.h | 23 - include/linux/wrapper_types.h | 92 -- 15 files changed, 996 insertions(+), 3007 deletions(-) create mode 100644 arch/arm/mach-msm/board-htcleo-battery.c create mode 100644 arch/arm/mach-msm/board-htcleo-power.c delete mode 100644 drivers/power/ds2746_battery.c delete mode 100644 drivers/power/ds2746_param.c delete mode 100644 include/linux/ds2746_battery.h delete mode 100644 include/linux/ds2746_battery_config.h delete mode 100644 include/linux/ds2746_param.h delete mode 100644 include/linux/ds2746_param_config.h delete mode 100644 include/linux/tps65200.h delete mode 100644 include/linux/wrapper_types.h diff --git a/arch/arm/configs/htcleo_defconfig b/arch/arm/configs/htcleo_defconfig index 1aa391ba..7620dcce 100644 --- a/arch/arm/configs/htcleo_defconfig +++ b/arch/arm/configs/htcleo_defconfig @@ -237,8 +237,8 @@ CONFIG_MACH_HTCLEO=y # CONFIG_MACH_INCREDIBLE is not set # CONFIG_MACH_INCREDIBLEC is not set # CONFIG_MACH_SUPERSONIC is not set -CONFIG_HTC_BATTCHG=y # CONFIG_HTC_BATTCHG_SMEM is not set +# CONFIG_HTC_BATTCHG is not set # CONFIG_HTC_PWRSINK is not set CONFIG_HTC_SLEEP_MODE_GPIO_DUMP=y # CONFIG_HTC_POWER_COLLAPSE_MAGIC is not set @@ -1192,7 +1192,7 @@ CONFIG_POWER_SUPPLY=y # CONFIG_BATTERY_DS2760 is not set # CONFIG_BATTERY_DS2782 is not set # CONFIG_BATTERY_DS2784 is not set -CONFIG_BATTERY_DS2746=y +# CONFIG_BATTERY_DS2746 is not set # CONFIG_BATTERY_BQ27x00 is not set # CONFIG_BATTERY_MAX17040 is not set # CONFIG_HWMON is not set diff --git a/arch/arm/mach-msm/Makefile b/arch/arm/mach-msm/Makefile index 5f3a5b58..847d9811 100644 --- a/arch/arm/mach-msm/Makefile +++ b/arch/arm/mach-msm/Makefile @@ -115,9 +115,9 @@ obj-$(CONFIG_MACH_BRAVOC) += board-bravoc-wifi.o htc_awb_cal.o obj-$(CONFIG_MACH_BRAVOC) += board-bravoc-microp.o clock.o obj-$(CONFIG_MACH_HTCLEO) += board-htcleo.o board-htcleo-panel.o board-htcleo-keypad.o -obj-$(CONFIG_MACH_HTCLEO) += board-htcleo-ts.o board-htcleo-mmc.o ieee754-df.o +obj-$(CONFIG_MACH_HTCLEO) += board-htcleo-ts.o board-htcleo-mmc.o ieee754-df.o board-htcleo-power.o -obj-$(CONFIG_MACH_HTCLEO) += board-htcleo-audio.o board-htcleo-acoustic.o +obj-$(CONFIG_MACH_HTCLEO) += board-htcleo-battery.o board-htcleo-log.o board-htcleo-audio.o board-htcleo-acoustic.o obj-$(CONFIG_MACH_HTCLEO) += board-htcleo-rfkill.o board-htcleo-wifi.o board-htcleo-microp.o obj-$(CONFIG_MACH_HTCLEO) += board-htcleo-proximity.o board-htcleo-leds.o board-htcleo-ls.o obj-$(CONFIG_MACH_HTCLEO) += clock-wince.o diff --git a/arch/arm/mach-msm/board-htcleo-battery.c b/arch/arm/mach-msm/board-htcleo-battery.c new file mode 100644 index 00000000..20488aa9 --- /dev/null +++ b/arch/arm/mach-msm/board-htcleo-battery.c @@ -0,0 +1,728 @@ +/* arch/arm/mach-msm/board-htcleo-battery.h +* +* Copyright (C) 2010 Markinus +* Copyright (C) 2009 HTC Corporation +* Copyright (C) 2009 Google, Inc. +* +* This software is licensed under the terms of the GNU General Public +* License version 2, as published by the Free Software Foundation, and +* may be copied, distributed, and modified under those terms. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +*/ + +/* + +actually this file called "board-htcleo-battery.c", so it's HTC LEO specific only +most values are hard coded here really. +this driver designed for android. + +proper ds2745 driver located at "driver/i2c/chips/ds2745.c" +I don't want and have not resources to support any "proper" linux drivers coding. +("proper" for them, not for me ofcourse) + +my primary target was to make high quality battery support in Android for HTC LEO. kefir with us! + +*/ +//#define DEBUG + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "gpio_chip.h" +#include "board-htcleo.h" + +static enum power_supply_property battery_properties[] = +{ + POWER_SUPPLY_PROP_STATUS, + POWER_SUPPLY_PROP_HEALTH, + POWER_SUPPLY_PROP_PRESENT, + POWER_SUPPLY_PROP_TECHNOLOGY, + POWER_SUPPLY_PROP_CAPACITY, + POWER_SUPPLY_PROP_VOLTAGE_NOW, + POWER_SUPPLY_PROP_TEMP, + POWER_SUPPLY_PROP_CURRENT_NOW, + POWER_SUPPLY_PROP_CURRENT_AVG, + POWER_SUPPLY_PROP_CHARGE_COUNTER, +}; + +static int battery_get_property(struct power_supply *psy, enum power_supply_property psp, union power_supply_propval *val); +static void htcleo_program_alarm(struct htcleo_device_info *di, int seconds); +static void battery_ext_power_changed(struct power_supply *psy); + +#define BATTERY_LOG_MAX 1024 +#define BATTERY_LOG_MASK (BATTERY_LOG_MAX - 1) + +static DEFINE_MUTEX(battery_log_lock); +static struct battery_status battery_log[BATTERY_LOG_MAX]; +static unsigned battery_log_head; +static unsigned battery_log_tail; + +void battery_log_status(struct battery_status *s) +{ + unsigned n; + mutex_lock(&battery_log_lock); + n = battery_log_head; + memcpy(battery_log + n, s, sizeof(struct battery_status)); + n = (n + 1) & BATTERY_LOG_MASK; + if (n == battery_log_tail) + battery_log_tail = (battery_log_tail + 1) & BATTERY_LOG_MASK; + battery_log_head = n; + mutex_unlock(&battery_log_lock); +} + +static const char *battery_source[3] = { "none", " usb", " ac" }; +static const char *battery_mode[4] = { " off", "slow", "fast", "full" }; + +static int battery_log_print(struct seq_file *sf, void *private) +{ + unsigned n; + mutex_lock(&battery_log_lock); + seq_printf(sf, "timestamp mV mA avg mA uAh dC %% src mode reg full\n"); + for (n = battery_log_tail; n != battery_log_head; n = (n + 1) & BATTERY_LOG_MASK) + { + struct battery_status *s = battery_log + n; + seq_printf(sf, "%9d %5d %6d %6d %8d %4d %3d %s %s 0x%02x %d\n", + s->timestamp, s->voltage_uV / 1000, + s->current_uA / 1000, s->current_avg_uA / 1000, + s->charge_uAh, s->temp_C, + s->percentage, + battery_source[s->charge_source], + battery_mode[s->charge_mode], + s->status_reg, s->battery_full); + } + mutex_unlock(&battery_log_lock); + return 0; +} + +static int I2C_Read_Status(struct htcleo_device_info *di) +{ + uint8_t i2c_msg[1]; + uint8_t i2c_data[2]; + + i2c_msg[0] = 0x01; //status reg + + i2c_master_send(di->client, i2c_msg, 1); + i2c_master_recv(di->client, i2c_data, 2); + + dev_dbg(&di->client->dev, "I2C_Read_Status() = %08X!\n", i2c_data[0]); + di->raw_status = i2c_data[0]; + return 0; +} + +static int I2C_Read_Data(struct htcleo_device_info *di) +{ + uint8_t i2c_msg[1]; + uint8_t i2c_data[10]; + + i2c_msg[0] = 0x08; // AUX0 AUX1 VOLTAGE CURRENT ACR + + i2c_master_send(di->client, i2c_msg, 1); + i2c_master_recv(di->client, i2c_data, 10); + + dev_dbg(&di->client->dev, "I2C_Read_Data() %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X!\n", + i2c_data[0], i2c_data[1], i2c_data[2], i2c_data[3], i2c_data[4], + i2c_data[5], i2c_data[6], i2c_data[7], i2c_data[8], i2c_data[9]); + memcpy(di->raw, i2c_data, 10); + return 0; +} + +static int I2C_Write_ACR(struct htcleo_device_info *di, uint16_t val) +{ + uint8_t i2c_msg[3]; + + i2c_msg[0] = 0x10; + i2c_msg[1] = (val >> 8) & 0xFF; + i2c_msg[2] = (val >> 0) & 0xFF; + +// dev_dbg(&di->client->dev, "I2C_Write_ACR() = %04X!\n", val); + i2c_master_send(di->client, i2c_msg, 3); + return 0; +} + +////////////////////////////////////////////////////////////////////////// + +static int htcleo_charge(int on, int fast) +{ + gpio_direction_output(HTCLEO_GPIO_BATTERY_CHARGER_CURRENT, !!fast); + gpio_direction_output(HTCLEO_GPIO_BATTERY_CHARGER_ENABLE, !on); + return 0; +} + +static void htcleo_parse_data(uint32_t raw_status, u8 *raw, struct battery_status *s) +{ + short n; + uint32_t n32; + uint32_t FL, ACR, ACR_EMPTY; + + /* Get status reg */ + s->status_reg = raw_status; + + /* Get Level */ + // TODO: FL too wrong (?) + ACR = ((raw[8] << 8) | raw[9]); + FL = (LEO_BATTERY_CAPACITY * 1570) / 625; + ACR_EMPTY = (LEO_BATTERY_EMPTY * 1570) / 625; + s->percentage = (100 * (ACR - ACR_EMPTY)) / FL; + + s->charge_uAh = 1000 * (((ACR - ACR_EMPTY) * 625) / 1570); + + if (s->percentage < 0 ) s->percentage = 0; + if (s->percentage > 100 ) s->percentage = 100; + + + /* Get Voltage */ + n32 = (((raw[4] << 8) | raw[5]) / 16); + //s->voltage_uV = (n32 * 244) / 100; + s->voltage_uV = 1000 * ((n32 * 312) >> 7); // div to 128 + + /* Get Current */ + n = ((raw[6]) << 8) | raw[7]; + s->current_uA = 1000 * (((n/4) * 625) / 1570); + + printk("ACR=%d CURR=%d VOL=%d RAAC=%d\n", ACR, s->current_uA, s->voltage_uV, s->percentage); + + // average current not supported by DS2746 + s->current_avg_uA = s->current_uA; + + /* Get Temperature */ + n = ((raw[0] << 8) | (raw[1])); + n /= 16; + + // printk("temp = %x\n", n); + if (n > 2047 || n == 0) + { + s->temp_C = 250; + } + else + { + double v = 0.021277 * (300.0 / (2047.0 / n - 1.0)); + s->temp_C = 10 * (1.0 / ((log(v) * 0.000290698) + 0.003354016) - 273.15); + } + if (s->temp_C < -250) + { + s->temp_C = -250; + } +} + +static int htcleo_battery_read_status(struct htcleo_device_info *di) +{ + // read status + I2C_Read_Status(di); + I2C_Read_Data(di); + + // printk("status = %04X\n", di->raw_status); + htcleo_parse_data(di->raw_status, di->raw, &di->status); + + dev_dbg(&di->client->dev, "batt: %3d%%, %d mV, %d mA (%d avg), %d.%d C, %d mAh\n", + di->status.percentage, + di->status.voltage_uV / 1000, di->status.current_uA / 1000, + di->status.current_avg_uA / 1000, + di->status.temp_C / 10, di->status.temp_C % 10, + di->status.charge_uAh / 1000); + + return 0; +} + +////////////////////////////////////////////////////////////////////////// + +static int htcleo_set_cc(struct htcleo_device_info *di, bool enable) +{ + // not supported for DS2745, there no CE bit + return 0; +} + + +static int battery_get_property(struct power_supply *psy, enum power_supply_property psp, union power_supply_propval *val) +{ + struct htcleo_device_info *di = psy_to_dev_info(psy); + + switch (psp) + { + case POWER_SUPPLY_PROP_STATUS: + switch (di->status.charge_source) + { + case CHARGE_OFF: + val->intval = POWER_SUPPLY_STATUS_DISCHARGING; + break; + case CHARGE_FAST: + case CHARGE_SLOW: + if (di->status.battery_full) + val->intval = POWER_SUPPLY_STATUS_FULL; + else if (di->status.charge_mode == CHARGE_OFF) + val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING; + else + val->intval = POWER_SUPPLY_STATUS_CHARGING; + break; + default: + val->intval = POWER_SUPPLY_STATUS_UNKNOWN; + break; + } + break; + case POWER_SUPPLY_PROP_HEALTH: + if (di->status.temp_C >= TEMP_HOT) + val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; + else + val->intval = POWER_SUPPLY_HEALTH_GOOD; + break; + case POWER_SUPPLY_PROP_PRESENT: + /* XXX todo */ + val->intval = 1; + break; + case POWER_SUPPLY_PROP_TECHNOLOGY: + if (di->dummy) + val->intval = POWER_SUPPLY_TECHNOLOGY_UNKNOWN; + else + val->intval = POWER_SUPPLY_TECHNOLOGY_LION; + break; + case POWER_SUPPLY_PROP_CAPACITY: + if (di->dummy) + val->intval = 75; + else + val->intval = di->status.percentage; + break; + case POWER_SUPPLY_PROP_VOLTAGE_NOW: + val->intval = di->status.voltage_uV; + break; + case POWER_SUPPLY_PROP_TEMP: + val->intval = di->status.temp_C; + break; + case POWER_SUPPLY_PROP_CURRENT_NOW: + val->intval = di->status.current_uA; + break; + case POWER_SUPPLY_PROP_CURRENT_AVG: + val->intval = di->status.current_avg_uA; + break; + case POWER_SUPPLY_PROP_CHARGE_COUNTER: + val->intval = di->status.charge_uAh; + break; + default: + return -EINVAL; + } + + return 0; +} + +static void htcleo_battery_update_status(struct htcleo_device_info *di) +{ + u8 last_level; + last_level = di->status.percentage; + + htcleo_battery_read_status(di); + + // CotullaTODO: add ACR = FL at top point here + + if ((last_level != di->status.percentage) || (di->status.temp_C > 450)) + { + power_supply_changed(&di->bat); + } +} + +static DEFINE_MUTEX(charge_state_lock); + +static bool check_timeout(ktime_t now, ktime_t last, int seconds) +{ + ktime_t timeout = ktime_add(last, ktime_set(seconds, 0)); + return ktime_sub(timeout, now).tv64 < 0; +} + +static int battery_adjust_charge_state(struct htcleo_device_info *di) +{ + unsigned source; + int rc = 0; + int temp, volt, curr, perc; + int ovp; + u8 charge_mode; + bool charge_timeout = false; + static int lastval=0xffff; + const int min_curr=5000; + + mutex_lock(&charge_state_lock); + + curr = di->status.current_uA; + perc = di->status.percentage; + temp = di->status.temp_C; + volt = di->status.voltage_uV / 1000; + + source = di->status.charge_source; + + /* initially our charge mode matches our source: + * NONE:OFF, USB:SLOW, AC:FAST + */ + charge_mode = source; + + // Check whether the bat is full and change the ACR to right 100% value + if(curr >=0 && curr < min_curr && lastval < min_curr && perc > 95 && source) { + uint32_t FL = (LEO_BATTERY_CAPACITY * 1570) / 625; + uint32_t ACR_EMPTY = (LEO_BATTERY_EMPTY * 1570) / 625; + I2C_Write_ACR(di, FL+ACR_EMPTY); + di->status.battery_full = 1; + di->status.percentage = 100; + charge_mode = CHARGE_OFF; + } + else { + di->status.battery_full = 0; + } + if(curr >=0) lastval=curr; + else lastval=0xffff; + + ovp = gpio_get_value(HTCLEO_GPIO_BATTERY_OVER_CHG); + if (ovp) + { + printk("Battery overpowered!\n"); + } + + if (temp >= TEMP_HOT || ovp) + { + if (temp >= TEMP_CRITICAL) + { + charge_mode = CHARGE_OFF; + } + + /* once we charge to max voltage when hot, disable + * charging until the temp drops or the voltage drops + */ + if (volt >= TEMP_HOT_MAX_MV) + { + di->status.cooldown = 1; + } + } + + /* when the battery is warm, only charge in slow charge mode */ + if ((temp >= TEMP_WARM) && (charge_mode == CHARGE_FAST)) + charge_mode = CHARGE_SLOW; + + if (di->status.cooldown) + { + if ((temp < TEMP_WARM) || (volt <= TEMP_HOT_MIN_MV)) + di->status.cooldown = 0; + else + charge_mode = CHARGE_OFF; + } + + if (di->status.current_uA > 1024) + { + di->last_charge_seen = di->last_poll; + } + else if (di->last_charge_mode != CHARGE_OFF && check_timeout(di->last_poll, di->last_charge_seen, 60 * 60)) + { + /* The charger has probably stopped charging. Turn it + * off until the next sample period. + */ + charge_timeout = true; + charge_mode = CHARGE_OFF; + } + + if (source == CHARGE_OFF) + charge_mode = CHARGE_OFF; + + + if (di->last_charge_mode == charge_mode) + goto done; + + di->last_charge_mode = charge_mode; + di->status.charge_mode = charge_mode; + + switch (charge_mode) + { + case CHARGE_OFF: + htcleo_charge(0, 0); + htcleo_set_cc(di, true); + if (temp >= TEMP_CRITICAL) + pr_info("batt: charging OFF [OVERTEMP]\n"); + else if (di->status.cooldown) + pr_info("batt: charging OFF [COOLDOWN]\n"); + else if (di->status.battery_full) + pr_info("batt: charging OFF [FULL]\n"); + else if (charge_timeout) + pr_info("batt: charging OFF [TIMEOUT]\n"); + else + pr_info("batt: charging OFF\n"); + break; + case CHARGE_SLOW: + di->last_charge_seen = di->last_poll; + htcleo_set_cc(di, true); + htcleo_charge(1, 0); + pr_info("batt: charging SLOW\n"); + break; + case CHARGE_FAST: + di->last_charge_seen = di->last_poll; + htcleo_set_cc(di, true); + htcleo_charge(1, 1); + pr_info("batt: charging FAST\n"); + break; + } + rc = 1; + done: + mutex_unlock(&charge_state_lock); + return rc; +} + + + +static void htcleo_battery_work(struct work_struct *work) +{ + struct htcleo_device_info *di = container_of(work, struct htcleo_device_info, monitor_work); + struct timespec ts; + unsigned long flags; + + htcleo_battery_update_status(di); + + di->last_poll = alarm_get_elapsed_realtime(); + + if (battery_adjust_charge_state(di)) + { + power_supply_changed(&di->bat); + } + + ts = ktime_to_timespec(di->last_poll); + di->status.timestamp = ts.tv_sec; + battery_log_status(&di->status); + + /* prevent suspend before starting the alarm */ + local_irq_save(flags); + wake_unlock(&di->work_wake_lock); + htcleo_program_alarm(di, FAST_POLL); + local_irq_restore(flags); +} + +////////////////////////////////////////////////////////////////////////// + +static void htcleo_program_alarm(struct htcleo_device_info *di, int seconds) +{ + ktime_t low_interval = ktime_set(seconds - 10, 0); + ktime_t slack = ktime_set(20, 0); + ktime_t next; + + next = ktime_add(di->last_poll, low_interval); + + alarm_start_range(&di->alarm, next, ktime_add(next, slack)); +} + +static void htcleo_battery_alarm(struct alarm *alarm) +{ + struct htcleo_device_info *di = container_of(alarm, struct htcleo_device_info, alarm); + wake_lock(&di->work_wake_lock); + queue_work(di->monitor_wqueue, &di->monitor_work); +} + +static void battery_ext_power_changed(struct power_supply *psy) +{ + struct htcleo_device_info *di; + int got_power; + + di = psy_to_dev_info(psy); + got_power = power_supply_am_i_supplied(psy); + + if (got_power) + { + if (is_ac_power_supplied()) + di->status.charge_source = SOURCE_AC; + else + di->status.charge_source = SOURCE_USB; + wake_lock(&vbus_wake_lock); + } + else + { + di->status.charge_source = SOURCE_NONE; + /* give userspace some time to see the uevent and update + * LED state or whatnot... + */ + wake_lock_timeout(&vbus_wake_lock, HZ / 2); + } + battery_adjust_charge_state(di); + power_supply_changed(psy); +} + +static int htcleo_battery_probe(struct i2c_client *client, const struct i2c_device_id *id) +{ + int rc; + struct htcleo_device_info *di; + + printk("%s\n", __func__); + if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE)) + { + return -EIO; + } + + di = kzalloc(sizeof(*di), GFP_KERNEL); + if (!di) + { + return -ENOMEM; + } + + mydi=di; + + di->client = client; + + i2c_set_clientdata(client, di); + + gpio_request(HTCLEO_GPIO_BATTERY_CHARGER_CURRENT, "charger_current"); + gpio_request(HTCLEO_GPIO_BATTERY_CHARGER_ENABLE, "charger_enable"); + gpio_request(HTCLEO_GPIO_BATTERY_OVER_CHG, "charger_over_chg"); + + gpio_direction_output(HTCLEO_GPIO_BATTERY_CHARGER_CURRENT, 1); + gpio_direction_output(HTCLEO_GPIO_BATTERY_CHARGER_ENABLE, 1); + gpio_direction_input(HTCLEO_GPIO_BATTERY_OVER_CHG); + + + di->bat.name = "battery"; + di->bat.type = POWER_SUPPLY_TYPE_BATTERY; + di->bat.properties = battery_properties; + di->bat.num_properties = ARRAY_SIZE(battery_properties); + di->bat.external_power_changed = battery_ext_power_changed; + di->bat.get_property = battery_get_property; + di->last_charge_mode = 0xff; + + rc = power_supply_register(&client->dev, &di->bat); + if (rc) + { + goto fail_register; + } + + INIT_WORK(&di->monitor_work, htcleo_battery_work); + di->monitor_wqueue = create_freezeable_workqueue(dev_name(&client->dev)); + + /* init to something sane */ + di->last_poll = alarm_get_elapsed_realtime(); + + if (!di->monitor_wqueue) + { + rc = -ESRCH; + goto fail_workqueue; + } + wake_lock_init(&di->work_wake_lock, WAKE_LOCK_SUSPEND, "htcleo-battery"); + printk("alarm init\n"); + alarm_init(&di->alarm, ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP, htcleo_battery_alarm); + wake_lock(&di->work_wake_lock); + queue_work(di->monitor_wqueue, &di->monitor_work); + printk("%s: done!\n", __func__); + return 0; + + fail_workqueue: + power_supply_unregister(&di->bat); + fail_register: + + + gpio_free(HTCLEO_GPIO_BATTERY_CHARGER_CURRENT); + gpio_free(HTCLEO_GPIO_BATTERY_CHARGER_ENABLE); + gpio_free(HTCLEO_GPIO_BATTERY_OVER_CHG); + + kfree(di); + return rc; +} + +static int htcleo_suspend(struct device *dev) +{ + struct htcleo_device_info *di = dev_get_drvdata(dev); + + /* If we are on battery, reduce our update rate until + * we next resume. + */ + if (di->status.charge_source == SOURCE_NONE) + { + htcleo_program_alarm(di, SLOW_POLL); + di->slow_poll = 1; + } + return 0; +} + +static int htcleo_resume(struct device *dev) +{ + struct htcleo_device_info *di = dev_get_drvdata(dev); + + /* We might be on a slow sample cycle. If we're + * resuming we should resample the battery state + * if it's been over a minute since we last did + * so, and move back to sampling every minute until + * we suspend again. + */ + if (di->slow_poll) + { + htcleo_program_alarm(di, FAST_POLL); + di->slow_poll = 0; + } + return 0; +} + +static struct dev_pm_ops htcleo_pm_ops = +{ + .suspend = htcleo_suspend, + .resume = htcleo_resume, +}; + + +static const struct i2c_device_id htcleo_battery_id[] = +{ + { "htcleo-battery", 0 }, + { } +}; + + +static struct i2c_driver htcleo_battery_driver = +{ + .driver = + { + .name = "htcleo-battery", + .owner = THIS_MODULE, + .pm = &htcleo_pm_ops, + }, + .id_table = htcleo_battery_id, + .probe = htcleo_battery_probe, +#ifndef CONFIG_HAS_EARLYSUSPEND + /* .suspend = htcleo_suspend, + .resume = htcleo_resume,*/ +#endif +}; + +static int battery_log_open(struct inode *inode, struct file *file) +{ + return single_open(file, battery_log_print, NULL); +} + +static struct file_operations battery_log_fops = +{ + .open = battery_log_open, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, +}; + +static int __init htcleo_battery_init(void) +{ + debugfs_create_file("battery_log", 0444, NULL, NULL, &battery_log_fops); + wake_lock_init(&vbus_wake_lock, WAKE_LOCK_SUSPEND, "vbus_present"); + return i2c_add_driver(&htcleo_battery_driver); +} + +//module_init(htcleo_battery_init); +late_initcall(htcleo_battery_init); + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Cotulla"); +MODULE_DESCRIPTION("htcleo battery driver"); +// END OF FILE diff --git a/arch/arm/mach-msm/board-htcleo-power.c b/arch/arm/mach-msm/board-htcleo-power.c new file mode 100644 index 00000000..fcb9d8da --- /dev/null +++ b/arch/arm/mach-msm/board-htcleo-power.c @@ -0,0 +1,214 @@ +/* arch/arm/mach-msm/board-htcleo-power.c +* +* Copyright (C) 2010 Cotulla +* Copyright (C) 2008 HTC Corporation. +* Copyright (C) 2008 Google, Inc. +* +* This software is licensed under the terms of the GNU General Public +* License version 2, as published by the Free Software Foundation, and +* may be copied, distributed, and modified under those terms. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +*/ + +// +// calls seq: +// +// notify_vbus_change_intr -> vbus_work_func -> msm_hsusb_set_vbus_state -> USB -> notify_usb_connected +// + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "board-htcleo.h" + +static char *supply_list[] = +{ + "battery", +}; + +static int inited; +static int vbus_present; +static int usb_status; +static struct work_struct vbus_work; + +#ifdef CONFIG_USB_ANDROID +void notify_usb_connected(int status); +static struct t_usb_status_notifier usb_status_notifier = { + .name = "htc_battery", + .func = notify_usb_connected, +}; +#endif + +static int power_get_property(struct power_supply *psy, + enum power_supply_property psp, + union power_supply_propval *val) +{ + if (psp != POWER_SUPPLY_PROP_ONLINE) + return -EINVAL; + + if (psy->type == POWER_SUPPLY_TYPE_MAINS) + { + val->intval = (usb_status == 2); + } + else + { + val->intval = vbus_present; + } + return 0; +} + +static enum power_supply_property power_properties[] = +{ + POWER_SUPPLY_PROP_ONLINE, +}; + +static struct power_supply ac_supply = +{ + .name = "ac", + .type = POWER_SUPPLY_TYPE_MAINS, + .supplied_to = supply_list, + .num_supplicants = ARRAY_SIZE(supply_list), + .properties = power_properties, + .num_properties = ARRAY_SIZE(power_properties), + .get_property = power_get_property, +}; + +static struct power_supply usb_supply = +{ + .name = "usb", + .type = POWER_SUPPLY_TYPE_USB, + .supplied_to = supply_list, + .num_supplicants = ARRAY_SIZE(supply_list), + .properties = power_properties, + .num_properties = ARRAY_SIZE(power_properties), + .get_property = power_get_property, +}; + +static int get_vbus_state(void) +{ + if (readl(MSM_SHARED_RAM_BASE + 0xEF20C)) + return 1; + else + return 0; +} + +void notify_cable_status(int status) +{ + pr_info("### notify_cable_status(%d) ###\n", status); + vbus_present = status; + msm_hsusb_set_vbus_state(vbus_present); + power_supply_changed(&ac_supply); + power_supply_changed(&usb_supply); + if(mydi) + power_supply_changed(&mydi->bat); +} + +// called from USB driver +void notify_usb_connected(int status) +{ + if (!inited) return; + pr_info("### notify_usb_connected(%d) ###\n", status); + usb_status = status; + power_supply_changed(&ac_supply); + power_supply_changed(&usb_supply); + if(mydi) + power_supply_changed(&mydi->bat); +} + +// called from DEX intrrupt +void notify_vbus_change_intr(void) +{ + if (!inited) return; + schedule_work(&vbus_work); +} + +// used by battery driver +int is_ac_power_supplied(void) +{ + return (usb_status == 2); +} + +static void vbus_work_func(struct work_struct *work) +{ + int vbus = get_vbus_state(); + printk(" new vbus = %d\n", vbus); + #ifdef CONFIG_USB_EHCI_HCD + if (vbus) + return 0; + else + return 0; + #else + if (vbus) + gpio_set_value(HTCLEO_GPIO_POWER_USB, 0); + else + gpio_set_value(HTCLEO_GPIO_POWER_USB, 1); + #endif + notify_cable_status(vbus); +} + + +static int htcleo_power_probe(struct platform_device *pdev) +{ + printk("$$$ htcleo_power_probe $$$\n"); + + INIT_WORK(&vbus_work, vbus_work_func); + + gpio_request(HTCLEO_GPIO_POWER_USB, "power_usb"); + gpio_direction_output(HTCLEO_GPIO_POWER_USB, 0); + + power_supply_register(&pdev->dev, &ac_supply); + power_supply_register(&pdev->dev, &usb_supply); + + inited = 1; + // init VBUS state + notify_vbus_change_intr(); + return 0; +} + +//#define APP_BATT_PDEV_NAME "rs30100001:00000000" +#define APP_BATT_PDEV_NAME "htcleo_power" + +static struct platform_driver htcleo_power_driver = +{ + .probe = htcleo_power_probe, + .driver = + { + .name = APP_BATT_PDEV_NAME, + .owner = THIS_MODULE, + }, +}; + +static int __init htcleo_power_init(void) +{ + printk("htcleo_power_init\n"); + platform_driver_register(&htcleo_power_driver); + #ifdef CONFIG_USB_ANDROID + usb_register_notifier(&usb_status_notifier); + #endif + return 0; +} + +//module_init(htcleo_power_init); +late_initcall(htcleo_power_init); +MODULE_DESCRIPTION("HTCLEO Power Driver"); +MODULE_LICENSE("GPL"); diff --git a/arch/arm/mach-msm/board-htcleo.c b/arch/arm/mach-msm/board-htcleo.c index 8cfdc3ec..47632913 100644 --- a/arch/arm/mach-msm/board-htcleo.c +++ b/arch/arm/mach-msm/board-htcleo.c @@ -34,7 +34,6 @@ #endif #include #include <../../../drivers/staging/android/timed_gpio.h> -#include #include #include @@ -232,6 +231,9 @@ static struct microp_i2c_platform_data microp_data = { static struct i2c_board_info base_i2c_devices[] = { + { + I2C_BOARD_INFO("htcleo-battery", 0x26), + }, { I2C_BOARD_INFO(LEO_TOUCH_DRV_NAME, 0), }, @@ -714,46 +716,11 @@ static struct platform_device ram_console_device = { // Power/Battery /////////////////////////////////////////////////////////////////////// -static struct htc_battery_platform_data htc_battery_pdev_data = { - .func_show_batt_attr = htc_battery_show_attr, - .gpio_mbat_in = -1, - .gpio_mchg_en_n = HTCLEO_GPIO_BATTERY_CHARGER_ENABLE, - .gpio_iset = HTCLEO_GPIO_BATTERY_CHARGER_CURRENT, - .gpio_power = HTCLEO_GPIO_POWER_USB, - .guage_driver = GUAGE_DS2746, - .charger = LINEAR_CHARGER, - .m2a_cable_detect = 0, - .force_no_rpc = 1, - .int_data = { - .chg_int = HTCLEO_GPIO_BATTERY_OVER_CHG, - }, -}; - -static struct platform_device htc_battery_pdev = { - .name = "htc_battery", - .id = -1, - .dev = { - .platform_data = &htc_battery_pdev_data, - }, -}; - -static int get_thermal_id(void) +static struct platform_device htcleo_power = { - return THERMAL_300; -} - -static struct ds2746_platform_data ds2746_pdev_data = { - .func_get_thermal_id = get_thermal_id, -}; - -static struct platform_device ds2746_battery_pdev = { - .name = "ds2746-battery", + .name = "htcleo_power", .id = -1, - .dev = { - .platform_data = &ds2746_pdev_data, - }, }; - /////////////////////////////////////////////////////////////////////// // Real Time Clock /////////////////////////////////////////////////////////////////////// @@ -784,11 +751,10 @@ static struct platform_device *devices[] __initdata = &android_pmem_adsp_device, &android_pmem_venc_device, &msm_device_i2c, - &ds2746_battery_pdev, - &htc_battery_pdev, &msm_kgsl_device, &msm_camera_sensor_s5k3e2fx, &htcleo_flashlight_device, + &htcleo_power, &qsd_device_spi, &htc_headset_mgr, &htc_headset_gpio, @@ -939,6 +905,10 @@ static void __init htcleo_init(void) platform_device_register(&htcleo_timed_gpios); +#ifdef CONFIG_USB_ANDROID + msm_hsusb_set_vbus_state(htcleo_get_vbus_state()); +#endif + /* Blink the camera LED shortly to show that we're alive! */ #ifdef CONFIG_HTCLEO_BLINK_AT_BOOT bank6_in = (unsigned int*)(MSM_GPIO1_BASE + 0x0864); diff --git a/arch/arm/mach-msm/htc_battery.c b/arch/arm/mach-msm/htc_battery.c index 3519d568..fbb717a8 100644 --- a/arch/arm/mach-msm/htc_battery.c +++ b/arch/arm/mach-msm/htc_battery.c @@ -30,23 +30,21 @@ #include /* Jay, to register display notifier */ #include #include -#include -#include #ifdef CONFIG_HTC_BATTCHG_SMEM #include "smd_private.h" #endif -#include -#include #if defined(CONFIG_TROUT_BATTCHG_DOCK) #include #endif #ifdef CONFIG_BATTERY_DS2784 #include -#elif defined(CONFIG_BATTERY_DS2746) +#elif CONFIG_BATTERY_DS2746 #include #endif +#include + static struct wake_lock vbus_wake_lock; enum { @@ -117,7 +115,6 @@ struct htc_battery_info { int gpio_power; int guage_driver; int m2a_cable_detect; - int force_no_rpc; int charger; }; @@ -208,37 +205,6 @@ int unregister_notifier_cable_status(struct notifier_block *nb) return blocking_notifier_chain_unregister(&cable_status_notifier_list, nb); } -/* -------------------------------------------------------------------------- */ -/* HTCLeo Dex Functions. */ -#if defined(CONFIG_MACH_HTCLEO) - -static int get_vbus_state(void) -{ - if (readl(MSM_SHARED_RAM_BASE + 0xEF20C)) - return 1; - else - return 0; -} - -void notify_cable_status(int status) -{ - pr_info("notify_cable_status(%d)\n", status); - msm_hsusb_set_vbus_state(status); - power_supply_changed(&htc_power_supplies[CHARGER_USB]); - power_supply_changed(&htc_power_supplies[CHARGER_AC]); - power_supply_changed(&htc_power_supplies[CHARGER_BATTERY]); -} - -// called from DEX intrrupt -void notify_vbus_change_intr(void) -{ - int vbus; - if (!htc_battery_initial) return; - vbus = get_vbus_state(); - notify_cable_status(vbus); -} - -#endif /* -------------------------------------------------------------------------- */ /* For sleep charging screen. */ static int zcharge_enabled; @@ -363,6 +329,7 @@ device_initcall(batt_debug_init); static int init_batt_gpio(void) { + if (htc_batt_info.gpio_mbat_in > 0 && gpio_request(htc_batt_info.gpio_mbat_in, "batt_detect") < 0) goto gpio_failed; @@ -399,6 +366,7 @@ int battery_charging_ctrl(enum batt_ctl_t ctl) { int result = 0; if (!htc_battery_initial) return 0; + switch (ctl) { case DISABLE: BATT_LOG("charger OFF"); @@ -655,13 +623,9 @@ static void usb_status_notifier_func(int online) blocking_notifier_call_chain(&cable_status_notifier_list, htc_batt_info.rep.charging_source, NULL); - if (htc_battery_initial) { - power_supply_changed(&htc_power_supplies[CHARGER_AC]); - power_supply_changed(&htc_power_supplies[CHARGER_USB]); - power_supply_changed(&htc_power_supplies[CHARGER_BATTERY]); - } else { - pr_err("\n\n ### htc_battery_code is not inited yet! ###\n\n"); - } + power_supply_changed(&htc_power_supplies[CHARGER_AC]); + power_supply_changed(&htc_power_supplies[CHARGER_USB]); + power_supply_changed(&htc_power_supplies[CHARGER_BATTERY]); update_wake_lock(htc_batt_info.rep.charging_source); #else mutex_lock(&htc_batt_info.lock); @@ -1029,17 +993,13 @@ static int htc_battery_get_charging_status(void) break; case CHARGER_USB: case CHARGER_AC: -#if !defined(CONFIG_BATTERY_DS2746) if ((htc_charge_full) && (htc_batt_info.rep.full_level == 100)) { htc_batt_info.rep.level = 100; } -#endif + level = htc_batt_info.rep.level; if (level == 100){ htc_charge_full = 1;} - else - htc_charge_full = 0; - if (htc_charge_full) ret = POWER_SUPPLY_STATUS_FULL; else if (htc_batt_info.rep.charging_enabled != 0) @@ -1066,20 +1026,12 @@ static int htc_battery_get_property(struct power_supply *psy, break; case POWER_SUPPLY_PROP_HEALTH: val->intval = POWER_SUPPLY_HEALTH_GOOD; - if (machine_is_paradise()) { - if (htc_batt_info.rep.batt_temp >= 500 || - htc_batt_info.rep.batt_temp <= 0) - val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; - } else if (machine_is_spade()) { - if (htc_batt_info.rep.batt_temp >= 450 || - htc_batt_info.rep.batt_temp <= 0) - val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; - } else { - if (htc_batt_info.rep.batt_temp >= 480 || - htc_batt_info.rep.batt_temp <= 0) - val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; - } - + if (machine_is_paradise() && (htc_batt_info.rep.batt_temp >= 500 || + htc_batt_info.rep.batt_temp <= 0)) + val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; + else if (!machine_is_paradise() && (htc_batt_info.rep.batt_temp >= 480 || + htc_batt_info.rep.batt_temp <= 0)) + val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; if (htc_batt_debug_mask & HTC_BATT_DEBUG_USER_QUERY) BATT_LOG("%s: %s: health=%d", __func__, psy->name, val->intval); break; @@ -1130,8 +1082,9 @@ static struct device_attribute htc_battery_attrs[] = { #ifdef CONFIG_HTC_BATTCHG_SMEM __ATTR(smem_raw, S_IRUGO, htc_battery_show_smem, NULL), __ATTR(smem_text, S_IRUGO, htc_battery_show_smem, NULL), -#endif +#else __ATTR(batt_attr_text, S_IRUGO, htc_battery_show_batt_attr, NULL), +#endif }; enum { @@ -1253,6 +1206,7 @@ static ssize_t htc_battery_set_full_level(struct device *dev, { int rc = 0; unsigned long percent = 100; + unsigned long param = 0; percent = simple_strtoul(buf, NULL, 10); @@ -1272,8 +1226,9 @@ static ssize_t htc_battery_set_full_level(struct device *dev, mutex_lock(&htc_batt_info.lock); htc_full_level_flag = 1; htc_batt_info.rep.full_level = percent; + param = percent; blocking_notifier_call_chain(&cable_status_notifier_list, - 0xff, (void *) &htc_batt_info.rep.full_level); + 0xff, (void *) ¶m); mutex_unlock(&htc_batt_info.lock); } rc = 0; @@ -1345,7 +1300,7 @@ static int update_batt_info(void) ret = -1; } break; -#elif defined(CONFIG_BATTERY_DS2746) +#elif CONFIG_BATTERY_DS2746 case GUAGE_DS2746: if (ds2746_get_battery_info(&htc_batt_info.rep)) { BATT_ERR("%s: ds2746 read failed!!!", __func__); @@ -1435,93 +1390,10 @@ dont_need_update: return i; } -static irqreturn_t tps65200_int_detection(int irq, void *data) -{ - struct htc_battery_tps65200_int *ip = data; - - BATT_LOG("%s: over voltage is detected.", __func__); - - disable_irq_nosync(ip->chg_int); - - ip->tps65200_reg = 0; - - schedule_delayed_work(&ip->int_work, msecs_to_jiffies(200)); - - return IRQ_HANDLED; -} - -static void htc_battery_tps65200_int_func(struct work_struct *work) -{ - struct htc_battery_tps65200_int *ip; - int fault_bit; - ip = container_of(work, struct htc_battery_tps65200_int, - int_work.work); - - switch (ip->tps65200_reg) { - case CHECK_INT1: - /* read twice. First read to trigger TPS65200 clear fault bit - on INT1. Second read to make sure that fault bit is cleared - and call off ovp function.*/ - fault_bit = tps_set_charger_ctrl(CHECK_INT1); - BATT_LOG("INT1 value: %d", fault_bit); - fault_bit = tps_set_charger_ctrl(CHECK_INT1); - - if (fault_bit) { -#ifdef CONFIG_HTC_BATTCHG_SMEM - smem_batt_info->over_vchg = 1; -#else - htc_batt_info.rep.over_vchg = 1; -#endif - power_supply_changed(&htc_power_supplies[CHARGER_BATTERY]); - schedule_delayed_work(&ip->int_work, - msecs_to_jiffies(5000)); - BATT_LOG("OVER_VOLTAGE: " - "over voltage fault bit on TPS65200 is raised:" - " %d", fault_bit); - } else { -#ifdef CONFIG_HTC_BATTCHG_SMEM - smem_batt_info->over_vchg = 0; -#else - htc_batt_info.rep.over_vchg = 0; -#endif - cancel_delayed_work(&ip->int_work); - enable_irq(ip->chg_int); - } - break; - default: - fault_bit = tps_set_charger_ctrl(CHECK_INT2); - BATT_LOG("Read TPS65200 INT2 register value: %x", fault_bit); - if (fault_bit) { - fault_bit = tps_set_charger_ctrl(CHECK_INT2); - BATT_LOG("Read TPS65200 INT2 register value: %x" - , fault_bit); - fault_bit = tps_set_charger_ctrl(CHECK_INT2); - BATT_LOG("Read TPS65200 INT2 register value: %x" - , fault_bit); - fault_bit = tps_set_charger_ctrl(CHECK_CONTROL); -#ifdef CONFIG_HTC_BATTCHG_SMEM - smem_batt_info->reserve4 = 1; -#endif - cancel_delayed_work(&ip->int_work); - enable_irq(ip->chg_int); - } else { - fault_bit = tps_set_charger_ctrl(CHECK_INT1); - BATT_LOG("Read TPS65200 INT1 register value: %x" - , fault_bit); - if (fault_bit) { - ip->tps65200_reg = CHECK_INT1; - schedule_delayed_work(&ip->int_work, - msecs_to_jiffies(200)); - } - } - break; - } -} - static int htc_battery_core_probe(struct platform_device *pdev) { int i, rc; - pr_info("%s\n", __func__); + /* init battery gpio */ if (htc_batt_info.charger == LINEAR_CHARGER) { if ((rc = init_batt_gpio()) < 0) { @@ -1537,14 +1409,12 @@ static int htc_battery_core_probe(struct platform_device *pdev) */ htc_batt_info.present = 1; - if(!htc_batt_info.force_no_rpc) { - /* init rpc */ - endpoint = msm_rpc_connect(APP_BATT_PROG, APP_BATT_VER, 0); - if (IS_ERR(endpoint)) { - BATT_ERR("%s: init rpc failed! rc = %ld", - __func__, PTR_ERR(endpoint)); - return -EINVAL; - } + /* init rpc */ + endpoint = msm_rpc_connect(APP_BATT_PROG, APP_BATT_VER, 0); + if (IS_ERR(endpoint)) { + BATT_ERR("%s: init rpc failed! rc = %ld", + __func__, PTR_ERR(endpoint)); + return -EINVAL; } /* init power supplier framework */ @@ -1561,21 +1431,16 @@ static int htc_battery_core_probe(struct platform_device *pdev) * the battery status in case of we lost some info */ htc_battery_initial = 1; - - if(htc_batt_info.force_no_rpc) { - update_batt_info(); - } - else { - mutex_lock(&htc_batt_info.rpc_lock); - htc_batt_info.rep.charging_source = CHARGER_BATTERY; - if (htc_get_batt_info(&htc_batt_info.rep) < 0) - BATT_ERR("%s: get info failed", __func__); - if (htc_rpc_set_delta(1) < 0) - BATT_ERR("%s: set delta failed", __func__); - htc_batt_info.update_time = jiffies; - mutex_unlock(&htc_batt_info.rpc_lock); - } + mutex_lock(&htc_batt_info.rpc_lock); + htc_batt_info.rep.charging_source = CHARGER_BATTERY; + if (htc_get_batt_info(&htc_batt_info.rep) < 0) + BATT_ERR("%s: get info failed", __func__); + + if (htc_rpc_set_delta(1) < 0) + BATT_ERR("%s: set delta failed", __func__); + htc_batt_info.update_time = jiffies; + mutex_unlock(&htc_batt_info.rpc_lock); return 0; } @@ -1673,6 +1538,7 @@ static int ds2784_notifier_func(struct notifier_block *nfb, unsigned long action, void *param) { u8 arg = 0; + if (param) arg = *(u8 *)param; @@ -1706,7 +1572,6 @@ static struct notifier_block ds2784_notifier = { static int htc_battery_probe(struct platform_device *pdev) { - int rc = 0; struct htc_battery_platform_data *pdata = pdev->dev.platform_data; htc_batt_info.device_id = pdev->id; @@ -1714,7 +1579,6 @@ static int htc_battery_probe(struct platform_device *pdev) htc_batt_info.gpio_power = pdata->gpio_power; htc_batt_info.guage_driver = pdata->guage_driver; htc_batt_info.m2a_cable_detect = pdata->m2a_cable_detect; - htc_batt_info.force_no_rpc = pdata->force_no_rpc; htc_batt_info.func_show_batt_attr = pdata->func_show_batt_attr; htc_batt_info.charger = pdata->charger; htc_batt_info.rep.full_level = 100; @@ -1731,35 +1595,11 @@ static int htc_battery_probe(struct platform_device *pdev) #ifdef CONFIG_BATTERY_DS2784 if (pdata->guage_driver == GUAGE_DS2784) ds2784_register_notifier(&ds2784_notifier); -#elif defined(CONFIG_BATTERY_DS2746) +#elif CONFIG_BATTERY_DS2746 if (pdata->guage_driver == GUAGE_DS2746) ds2746_register_notifier(&ds2784_notifier); #endif - if (system_rev >= 1 || machine_is_htcleo()) { - if (pdata->int_data.chg_int) { - BATT_LOG("init over voltage interrupt detection."); - INIT_DELAYED_WORK(&pdata->int_data.int_work, - htc_battery_tps65200_int_func); - - rc = request_irq(pdata->int_data.chg_int, - tps65200_int_detection, - IRQF_TRIGGER_LOW, - "over_voltage_interrupt", - &pdata->int_data); - - if (rc) { - BATT_LOG("request irq failed"); - return rc; - } - } - } -#if defined(CONFIG_MACH_HTCLEO) - if(pdata->force_no_rpc) { - htc_battery_core_probe(pdev); - htc_cable_status_update(get_vbus_state()); - } -#endif return 0; } diff --git a/arch/arm/mach-msm/include/mach/htc_battery.h b/arch/arm/mach-msm/include/mach/htc_battery.h index a820efc4..7a7edc5f 100644 --- a/arch/arm/mach-msm/include/mach/htc_battery.h +++ b/arch/arm/mach-msm/include/mach/htc_battery.h @@ -22,10 +22,7 @@ #define SET_ICL500 0X65 #define SET_ICL100 0X66 #define CHECK_INT2 0X67 -#define OVERTEMP_VREG_4060 0XC8 -#define NORMALTEMP_VREG_4200 0XC9 -#define CHECK_INT1 0XCA -#define CHECK_CONTROL 0xCB + /* information about the system we're running on */ extern unsigned int system_rev; @@ -70,13 +67,6 @@ struct battery_info_reply { u32 over_vchg; /* 0:normal, 1:over voltage charger */ s32 eval_current; /* System loading current from ADC */ }; - -struct htc_battery_tps65200_int { - int chg_int; - int tps65200_reg; - struct delayed_work int_work; -}; - struct htc_battery_platform_data { int (*func_show_batt_attr)(struct device_attribute *attr, char *buf); @@ -88,8 +78,6 @@ struct htc_battery_platform_data { int guage_driver; int m2a_cable_detect; int charger; - struct htc_battery_tps65200_int int_data; - int force_no_rpc; }; #if CONFIG_HTC_BATTCHG diff --git a/drivers/power/ds2746_battery.c b/drivers/power/ds2746_battery.c deleted file mode 100644 index 56fbcc66..00000000 --- a/drivers/power/ds2746_battery.c +++ /dev/null @@ -1,1248 +0,0 @@ -/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - -Copyright (c) 2010 High Tech Computer Corporation - -Module Name: - - ds2746_battery.c - -Abstract: - - This module implements the power algorithm, including below concepts: - 1. Charging function control. - 2. Charging full condition. - 3. Recharge control. - 4. Battery capacity maintainance. - 5. Battery full capacity calibration. - -Original Auther: - - Andy.YS Wang June-01-2010 ----------------------------------------------------------------------------------*/ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -/*#include */ -#include -#include -#include -#include -#include "../../arch/arm/mach-msm/proc_comm.h" -#include /* for i2c_adapter, i2c_client define*/ -/*#include "../w1/w1.h"*/ -/*#include "../w1/slaves/w1_ds2784.h"*/ -#include -#include - -struct ds2746_device_info { - - struct device *dev; - struct device *w1_dev; - struct workqueue_struct *monitor_wqueue; - struct work_struct monitor_work; - /* lock to protect the battery info */ - struct mutex lock; - /* DS2784 data, valid after calling ds2784_battery_read_status() */ - unsigned long update_time; /* jiffies when data read */ - struct alarm alarm; - struct wake_lock work_wake_lock; - u8 slow_poll; - ktime_t last_poll; -}; -static struct wake_lock vbus_wake_lock; - -/*======================================================================================== - -HTC power algorithm helper member and functions - -========================================================================================*/ - -static struct poweralg_type poweralg = {0}; -static struct poweralg_config_type config = {0}; -static struct poweralg_config_type debug_config = {0}; - -#define FAST_POLL (1 * 60) -#define SLOW_POLL (10 * 60) -#define PREDIC_POLL 20 - -#define SOURCE_NONE 0 -#define SOURCE_USB 1 -#define SOURCE_AC 2 - -#define CHARGE_OFF 0 -#define CHARGE_SLOW 1 -#define CHARGE_FAST 2 - -#define BATTERY_ID_UNKNOWN 0 -#define HTC_BATTERY_DS2746_DEBUG_ENABLE 0 - -/* DS2746 I2C BUS*/ -#define DS2746_I2C_BUS_ID 0 -#define DS2746_I2C_SLAVE_ADDR 0x26 - -/*======================================================================================== - -IC dependent defines - -========================================================================================*/ - -/* DS2746 I2C register address*/ -#define DS2746_STATUS_REG 0x01 -#define DS2746_AUX0_MSB 0x08 -#define DS2746_AUX0_LSB 0x09 -#define DS2746_AUX1_MSB 0x0A -#define DS2746_AUX1_LSB 0x0B -#define DS2746_VOLT_MSB 0x0C -#define DS2746_VOLT_LSB 0x0D -#define DS2746_CURRENT_MSB 0x0E -#define DS2746_CURRENT_LSB 0x0F -#define DS2746_ACR_MSB 0x10 -#define DS2746_ACR_LSB 0x11 - -/* DS2746 I2C I/O*/ -static struct i2c_adapter *i2c2 = NULL; -static struct i2c_client *ds2746_i2c = NULL; -static int htc_battery_initial = 0; - -int ds2746_i2c_write_u8(u8 value, u8 reg) -{ - int ret; - u8 buf[2]; - struct i2c_msg *msg; - struct i2c_msg xfer_msg[1]; - - /* [MSG1] fill the register address data and fill the data Tx buffer */ - msg = &xfer_msg[0]; - msg->addr = ds2746_i2c->addr; - msg->len = 2; - msg->flags = 0; /* Read the register value */ - msg->buf = buf; - - buf[0] = reg; - buf[1] = value; - - ret = i2c_transfer(ds2746_i2c->adapter, xfer_msg, 1); - if (ret <= 0){ - printk(DRIVER_ZONE "[%s] fail.\n", __func__); - } - -#if HTC_BATTERY_DS2746_DEBUG_ENABLE - printk(DRIVER_ZONE "[%s] ds2746[0x%x]<-0x%x.\n", __func__, reg, value); -#endif - - return ret; -} - -int ds2746_i2c_read_u8(u8 *value, u8 reg) -{ - int ret; - struct i2c_msg *msg; - struct i2c_msg xfer_msg[2]; - - /* [MSG1] fill the register address data */ - msg = &xfer_msg[0]; - msg->addr = ds2746_i2c->addr; - msg->len = 1; - msg->flags = 0; /* Read the register value */ - msg->buf = ® - /* [MSG2] fill the data rx buffer */ - msg = &xfer_msg[1]; - msg->addr = ds2746_i2c->addr; - msg->len = 1; - msg->flags = I2C_M_RD; /* Read the register value */ - msg->buf = value; - - ret = i2c_transfer(ds2746_i2c->adapter, xfer_msg, 2); - if (ret <= 0){ - printk(DRIVER_ZONE "[%s] fail.\n", __func__); - } - -#if HTC_BATTERY_DS2746_DEBUG_ENABLE - printk(DRIVER_ZONE "[%s] ds2746[0x%x]=0x%x.\n", __func__, reg, *value); -#endif - - return ret; -} - -static void ds2746_i2c_exit(void) -{ - if (ds2746_i2c != NULL){ - kfree(ds2746_i2c); - ds2746_i2c = NULL; - } - - if (i2c2 != NULL){ - i2c_put_adapter(i2c2); - i2c2 = NULL; - } -} - -static int ds2746_i2c_init(void) -{ - i2c2 = i2c_get_adapter(DS2746_I2C_BUS_ID); - ds2746_i2c = kzalloc(sizeof(*ds2746_i2c), GFP_KERNEL); - - if (i2c2 == NULL || ds2746_i2c == NULL){ - printk(DRIVER_ZONE "[%s] fail (0x%x, 0x%x).\n", - __func__, - (int) i2c2, - (int) ds2746_i2c); - ds2746_i2c_exit(); - return -ENOMEM; - } - - ds2746_i2c->adapter = i2c2; - ds2746_i2c->addr = DS2746_I2C_SLAVE_ADDR; - - return 0; -} - -/*======================================================================================== - - HTC supporting MFG testing member and functions - -=========================================================================================*/ - -static BOOL b_is_charge_off_by_bounding = FALSE; -static void bounding_fullly_charged_level(int upperbd) -{ - static int pingpong = 1; - int lowerbd; - int current_level; - b_is_charge_off_by_bounding = FALSE; - if (upperbd <= 0) - return; /* doesn't activated this function */ - lowerbd = upperbd - 5; /* 5% range */ - - if (lowerbd < 0) - lowerbd = 0; - current_level = CEILING(poweralg.capacity_01p, 10); - - if (pingpong == 1 && upperbd <= current_level) { - printk(DRIVER_ZONE "MFG: lowerbd=%d, upperbd=%d, current=%d, pingpong:1->0 turn off\n", lowerbd, upperbd, current_level); - b_is_charge_off_by_bounding = TRUE; - pingpong = 0; - } else if (pingpong == 0 && lowerbd < current_level) { - printk(DRIVER_ZONE "MFG: lowerbd=%d, upperbd=%d, current=%d, toward 0, turn off\n", lowerbd, upperbd, current_level); - b_is_charge_off_by_bounding = TRUE; - } else if (pingpong == 0 && current_level <= lowerbd) { - printk(DRIVER_ZONE "MFG: lowerbd=%d, upperbd=%d, current=%d, pingpong:0->1 turn on\n", lowerbd, upperbd, current_level); - pingpong = 1; - } else { - printk(DRIVER_ZONE "MFG: lowerbd=%d, upperbd=%d, current=%d, toward %d, turn on\n", lowerbd, upperbd, current_level, pingpong); - } - -} - -static BOOL is_charge_off_by_bounding_condition(void) -{ - return b_is_charge_off_by_bounding; -} - -void calibrate_id_ohm(struct battery_type *battery) -{ - if (!poweralg.charging_source || !poweralg.charging_enable){ - battery->id_ohm += 500; /* If device is in discharge mode, Rid=Rid_1 + 0.5Kohm*/ - } - else if (poweralg.charging_source == 2 && battery->current_mA >= 400 && battery->id_ohm >= 1500){ - battery->id_ohm -= 1500; /* If device is in charge mode and ISET=1 (charge current is <800mA), Rid=Rid_1 - 1.5Kohm*/ - } - else if (battery->id_ohm >= 700){ - battery->id_ohm -= 700; /* If device is in charge mode and ISET=0 (charge current is <400mA), Rid=Rid_1 - 0.7Kohm*/ - } -} - -static BOOL is_charging_avaiable(void) -{ - if (poweralg.is_software_charger_timeout) return FALSE; - if (!poweralg.protect_flags.is_charging_enable_available)return FALSE; - if (!poweralg.is_cable_in) return FALSE; - if (poweralg.charge_state == CHARGE_STATE_PENDING) return FALSE; - if (poweralg.charge_state == CHARGE_STATE_FULL_PENDING) return FALSE; - if (poweralg.charge_state == CHARGE_STATE_PREDICTION) return FALSE; - if (is_charge_off_by_bounding_condition()) return FALSE; - return TRUE; /* CHARGE_STATE_UNKNOWN, SET_LED_BATTERY_CHARGING is available to be charged by default*/ -} - -static BOOL is_high_current_charging_avaialable(void) -{ - if (!poweralg.protect_flags.is_charging_high_current_avaialble) return FALSE; - if (!poweralg.is_china_ac_in) return FALSE; - if (poweralg.charge_state == CHARGE_STATE_UNKNOWN) return FALSE; - return TRUE; -} - -static void update_next_charge_state(void) -{ - static UINT32 count_charging_full_condition; - static UINT32 count_charge_over_load; - int next_charge_state; - int i; - - /* unknown -> prediction -> unknown -> discharge/charging/pending - charging -> full-wait-stable -> full-charging -> full-pending - full-pending -> full-charging -> charging - *(cable in group) -> discharge, charge-pending, dead - *(cable out group), full-wait-stable, charge-pending, dead -> charging*/ - - for (i = 0; i < 25; i++) /* maximun 25 times state transition to prevent from busy loop; ideally the transition time shall be less than 5 times.*/ - { - next_charge_state = poweralg.charge_state; - - /* 0. enter prediction state or not*/ - if (poweralg.charge_state == CHARGE_STATE_UNKNOWN){ - if (poweralg.battery.is_power_on_reset || config.debug_always_predict){ - if (poweralg.protect_flags.is_battery_dead){ - /* keep poweralg.charge_state unchanged, set capacity to 0% directly*/ - printk(DRIVER_ZONE " dead battery, \ - p=0%%\n"); - poweralg.capacity_01p = 0; - battery_capacity_update(&poweralg.battery, poweralg.capacity_01p); - - poweralg.fst_discharge_capacity_01p = poweralg.capacity_01p; - poweralg.fst_discharge_acr_mAh = poweralg.battery.charge_counter_mAh; - } - else{ - /* battery replaced, recalculate capacity based on battery voltage*/ - printk(DRIVER_ZONE " start predict discharge...\n"); - next_charge_state = CHARGE_STATE_PREDICTION; - } - - config.debug_always_predict = FALSE; - } - } - - if (next_charge_state == poweralg.charge_state){ - /*---------------------------------------------------------------------------------------------------*/ - /* 1. cable in group*/ - if (poweralg.charge_state == CHARGE_STATE_UNKNOWN || - poweralg.charge_state == CHARGE_STATE_CHARGING || - poweralg.charge_state == CHARGE_STATE_PENDING || - poweralg.charge_state == CHARGE_STATE_FULL_WAIT_STABLE || - poweralg.charge_state == CHARGE_STATE_FULL_CHARGING || - poweralg.charge_state == CHARGE_STATE_FULL_PENDING){ - if (!poweralg.is_cable_in){ - next_charge_state = CHARGE_STATE_DISCHARGE; - } - else if (!poweralg.protect_flags.is_charging_enable_available){ - next_charge_state = CHARGE_STATE_PENDING; - } - } - - /*---------------------------------------------------------------------------------------------------*/ - /* 2. cable out group*/ - if (poweralg.charge_state == CHARGE_STATE_UNKNOWN || - poweralg.charge_state == CHARGE_STATE_DISCHARGE){ - if (poweralg.is_cable_in){ - next_charge_state = CHARGE_STATE_CHARGING; - } - } - } - - /*---------------------------------------------------------------------------------------------------*/ - /* 3. state handler/transition, if the charge state is not changed due to cable/protect flags*/ - if (next_charge_state == poweralg.charge_state){ - switch (poweralg.charge_state){ - case CHARGE_STATE_PREDICTION: - { - UINT32 end_time_ms = BAHW_MyGetMSecs(); - - if (end_time_ms - poweralg.state_start_time_ms >= - config.predict_timeout_sec * 1000){ - - printk(DRIVER_ZONE "predict done [%d->%d]\n", poweralg.state_start_time_ms, - end_time_ms); - next_charge_state = CHARGE_STATE_UNKNOWN; - } - } - break; - case CHARGE_STATE_CHARGING: - if (!poweralg.battery.is_power_on_reset){ - /* -> full-charging, pending, dead*/ - if (poweralg.capacity_01p > 990){ - /* only ever charge-full, the capacity can be larger than 99.0%*/ - next_charge_state = CHARGE_STATE_FULL_CHARGING; - } - else if (poweralg.battery.voltage_mV >= config.full_charging_mv && - poweralg.battery.current_mA >= 0 && - poweralg.battery.current_mA <= config.full_charging_ma){ - /* meet charge full terminate condition, check again*/ - next_charge_state = CHARGE_STATE_FULL_WAIT_STABLE; - } - } - - if (poweralg.battery.current_mA <= 0){ - /* count_charge_over_load is 5 as max*/ - if (count_charge_over_load < 5) - count_charge_over_load++; - else - poweralg.is_charge_over_load = TRUE; - } - else{ - count_charge_over_load = 0; - poweralg.is_charge_over_load = FALSE; - } - - /* is_software_charger_timeout: only triggered when AC adapter in*/ - if (config.software_charger_timeout_sec && poweralg.is_china_ac_in){ - /* software charger timer is enabled; for AC charge only*/ - UINT32 end_time_ms = BAHW_MyGetMSecs(); - - if (end_time_ms - poweralg.state_start_time_ms >= - config.software_charger_timeout_sec * 1000){ - - printk(DRIVER_ZONE "software charger timer timeout [%d->%d]\n", - poweralg.state_start_time_ms, - end_time_ms); - poweralg.is_software_charger_timeout = TRUE; - } - } - break; - case CHARGE_STATE_FULL_WAIT_STABLE: - { - /* -> full-charging, pending, dead*/ - if (poweralg.battery.voltage_mV >= config.full_charging_mv && - poweralg.battery.current_mA >= 0 && - poweralg.battery.current_mA <= config.full_charging_ma){ - - count_charging_full_condition++; - } - else{ - count_charging_full_condition = 0; - next_charge_state = CHARGE_STATE_CHARGING; - } - - if (count_charging_full_condition >= 3){ - - poweralg.capacity_01p = 1000; - battery_capacity_update(&poweralg.battery, poweralg.capacity_01p); - - next_charge_state = CHARGE_STATE_FULL_CHARGING; - } - } - break; - case CHARGE_STATE_FULL_CHARGING: - { - /* -> full-pending, charging*/ - UINT32 end_time_ms = BAHW_MyGetMSecs(); - - if (poweralg.battery.voltage_mV < config.voltage_exit_full_mv){ - if (poweralg.capacity_01p > 990) - poweralg.capacity_01p = 990; - next_charge_state = CHARGE_STATE_CHARGING; - } - else if (config.full_pending_ma != 0 && - poweralg.battery.current_mA >= 0 && - poweralg.battery.current_mA <= config.full_pending_ma){ - - printk(DRIVER_ZONE " charge-full pending(%dmA)(%d:%d)\n", - poweralg.battery.current_mA, - poweralg.state_start_time_ms, - end_time_ms); - - next_charge_state = CHARGE_STATE_FULL_PENDING; - } - else if (end_time_ms - poweralg.state_start_time_ms >= - config.full_charging_timeout_sec * 1000){ - - printk(DRIVER_ZONE " charge-full (expect:%dsec)(%d:%d)\n", - config.full_charging_timeout_sec, - poweralg.state_start_time_ms, - end_time_ms); - next_charge_state = CHARGE_STATE_FULL_PENDING; - } - } - break; - case CHARGE_STATE_FULL_PENDING: - if ((poweralg.battery.voltage_mV >= 0 && - poweralg.battery.voltage_mV < config.voltage_recharge_mv) || - (poweralg.battery.RARC_01p >= 0 && - poweralg.battery.RARC_01p <= config.capacity_recharge_p * 10)){ - /* -> full-charging*/ - next_charge_state = CHARGE_STATE_FULL_CHARGING; - } - break; - case CHARGE_STATE_PENDING: - case CHARGE_STATE_DISCHARGE: - { - UINT32 end_time_ms = BAHW_MyGetMSecs(); - - if (!poweralg.is_voltage_stable){ - if (end_time_ms - poweralg.state_start_time_ms >= - config.wait_votlage_statble_sec * 1000){ - - printk(DRIVER_ZONE " voltage stable\n"); - poweralg.is_voltage_stable = TRUE; - } - } - } - - if (poweralg.is_cable_in && - poweralg.protect_flags.is_charging_enable_available){ - /* -> charging*/ - next_charge_state = CHARGE_STATE_CHARGING; - } - break; - } - } - - /*---------------------------------------------------------------------------------------------------*/ - /* 4. state transition*/ - if (next_charge_state != poweralg.charge_state){ - /* state exit*/ - switch (poweralg.charge_state){ - case CHARGE_STATE_UNKNOWN: - poweralg.capacity_01p = poweralg.battery.RARC_01p; - if (poweralg.capacity_01p > 990) - poweralg.capacity_01p = 990; - if (poweralg.capacity_01p < 0) - poweralg.capacity_01p = 0; - - poweralg.fst_discharge_capacity_01p = poweralg.capacity_01p; - poweralg.fst_discharge_acr_mAh = poweralg.battery.charge_counter_mAh; - break; - case CHARGE_STATE_PREDICTION: - battery_param_update(&poweralg.battery, - &poweralg.protect_flags); - - poweralg.capacity_01p = poweralg.battery.KADC_01p; - if (poweralg.capacity_01p > 990) - poweralg.capacity_01p = 990; - if (poweralg.capacity_01p < 0) - poweralg.capacity_01p = 0; - battery_capacity_update(&poweralg.battery, - poweralg.capacity_01p); - - poweralg.fst_discharge_capacity_01p = poweralg.capacity_01p; - poweralg.fst_discharge_acr_mAh = poweralg.battery.charge_counter_mAh; - break; - } - - /* state init*/ - poweralg.state_start_time_ms = BAHW_MyGetMSecs(); - - switch (next_charge_state){ - case CHARGE_STATE_DISCHARGE: - case CHARGE_STATE_PENDING: - /*! star_lee 20100426 - always set ACR=FULL when discharge starts and ACR>FULL*/ - if (poweralg.battery.RARC_01p > 1000) - battery_capacity_update(&poweralg.battery, 1000); - - poweralg.is_need_calibrate_at_49p = TRUE; - poweralg.is_need_calibrate_at_14p = TRUE; - poweralg.fst_discharge_capacity_01p = poweralg.capacity_01p; - poweralg.fst_discharge_acr_mAh = poweralg.battery.charge_counter_mAh; - poweralg.is_voltage_stable = FALSE; - - break; - case CHARGE_STATE_CHARGING: - poweralg.is_software_charger_timeout = FALSE; /* reset software charger timer every time when charging re-starts*/ - poweralg.is_charge_over_load = FALSE; - count_charge_over_load = 0; - poweralg.battery.charge_full_real_mAh = poweralg.battery.charge_full_design_mAh; - battery_capacity_update(&poweralg.battery, poweralg.capacity_01p); - break; - case CHARGE_STATE_FULL_WAIT_STABLE: - /* set to 0 first; the cournter will be add to 1 soon in CHARGE_STATE_FULL_WAIT_STABLE state handler*/ - count_charging_full_condition = 0; - break; - } - - printk(DRIVER_ZONE " state change(%d->%d), full count=%d, over load count=%d [%d]\n", - poweralg.charge_state, - next_charge_state, - count_charging_full_condition, - count_charge_over_load, - poweralg.state_start_time_ms); - - poweralg.charge_state = next_charge_state; - continue; - } - - break; - } -} - -static void __update_capacity(void) -{ - INT32 next_capacity_01p; - - pr_info("ds2746_batt:__update_capacity start\n"); - if (poweralg.charge_state == CHARGE_STATE_PREDICTION || - poweralg.charge_state == CHARGE_STATE_UNKNOWN){ - - /*! star_lee 20100429 - return 99%~25% when in prediction mode*/ - poweralg.capacity_01p = max(min(990, poweralg.battery.KADC_01p), 250); - printk(DRIVER_ZONE "fake percentage (%d) during prediction.\n", - poweralg.capacity_01p); - } - else if (poweralg.charge_state == CHARGE_STATE_FULL_CHARGING || - poweralg.charge_state == CHARGE_STATE_FULL_PENDING){ - - poweralg.capacity_01p = 1000; - } - else if (!is_charging_avaiable() && poweralg.is_voltage_stable){ - /* DISCHARGE ALG: capacity is based on KADC/RARC; only do this after cable in 3 minutes later*/ - if (poweralg.battery.KADC_01p <= 0){ - if (poweralg.capacity_01p > 0) - poweralg.capacity_01p -= 10; - if (poweralg.capacity_01p > 0){ - /* capacity is still not 0 when KADC is 0; record capacity for next boot time*/ - battery_capacity_update(&poweralg.battery, poweralg.capacity_01p); - } - } - else{ - if ((config.enable_weight_percentage) && (poweralg.capacity_01p <150 || - poweralg.battery.RARC_01p> poweralg.battery.KADC_01p)){ - -#define Padc 200 -#define Pw 5 -/* 500= 1000) - next_capacity_01p = 1000; - if (next_capacity_01p < 0) - next_capacity_01p = 0; - - if (next_capacity_01p < poweralg.capacity_01p){ - poweralg.capacity_01p -= min(10, poweralg.capacity_01p-next_capacity_01p); - } - } - - if (config.enable_full_calibration){ - if (poweralg.is_need_calibrate_at_49p && - poweralg.capacity_01p <= 500 && - poweralg.fst_discharge_capacity_01p >= 600){ - - poweralg.battery.charge_full_real_mAh = (poweralg.fst_discharge_acr_mAh-poweralg.battery.charge_counter_mAh)*1000/ - (poweralg.fst_discharge_capacity_01p-poweralg.capacity_01p); - - battery_capacity_update(&poweralg.battery, poweralg.capacity_01p); - - poweralg.is_need_calibrate_at_49p = FALSE; - poweralg.fst_discharge_capacity_01p = poweralg.capacity_01p; - poweralg.fst_discharge_acr_mAh = poweralg.battery.charge_counter_mAh; - - printk(DRIVER_ZONE " 1.full calibrate: full=%d\n", - poweralg.battery.charge_full_real_mAh); - } - else if (poweralg.is_need_calibrate_at_14p && - poweralg.capacity_01p <= 150 && - poweralg.fst_discharge_capacity_01p >= 250){ - poweralg.battery.charge_full_real_mAh = (poweralg.fst_discharge_acr_mAh-poweralg.battery.charge_counter_mAh)*1000/ - (poweralg.fst_discharge_capacity_01p - poweralg.capacity_01p); - - battery_capacity_update(&poweralg.battery, poweralg.capacity_01p); - - poweralg.is_need_calibrate_at_14p = FALSE; - poweralg.fst_discharge_capacity_01p = poweralg.capacity_01p; - poweralg.fst_discharge_acr_mAh = poweralg.battery.charge_counter_mAh; - - printk(DRIVER_ZONE " 2.full calibrate: full=%d\n", - poweralg.battery.charge_full_real_mAh); - } - } - } - else{ - /* CHARGE ALG: capacity is always based on ACR - 1. plus 1% as max when charge, if the orignal capacity is <= 99%, the result is no more than 99% - 2. minus 1% as max when discharge, not less than 0%*/ - next_capacity_01p = poweralg.battery.RARC_01p; - - if (next_capacity_01p > 1000) - next_capacity_01p = 1000; - if (next_capacity_01p < 0) - next_capacity_01p = 0; - - if (next_capacity_01p > poweralg.capacity_01p){ - /* charge case*/ - next_capacity_01p = poweralg.capacity_01p + min(next_capacity_01p - poweralg.capacity_01p, 10); - if (poweralg.capacity_01p > 990) - poweralg.capacity_01p = next_capacity_01p; - else - poweralg.capacity_01p = min(next_capacity_01p, 990); - } - else if (next_capacity_01p < poweralg.capacity_01p){ - /* discharge case*/ - poweralg.capacity_01p -= min(poweralg.capacity_01p - next_capacity_01p, 10); - if (poweralg.capacity_01p < 0) - poweralg.capacity_01p = 0; - } - } -} - -/*======================================================================================== - -HTC power algorithm implemetation - -========================================================================================*/ - -int get_state_check_interval_min_sec(void) -{ - /*the minimal check interval of each states in seconds - reserve for change polling rate - UINT32 elapse_time_ms = BAHW_MyGetMSecs() - poweralg.state_start_time_ms; - switch (poweralg.charge_state) - { - case CHARGE_STATE_FULL_WAIT_STABLE: - //! star_lee 20100429 - takes 30 seconds(10 seconds*3 times) to confirm charge full condition - return 10; - case CHARGE_STATE_PREDICTION: - return min(config.predict_timeout_sec, max((INT32)(config.predict_timeout_sec - elapse_time_ms/1000), (INT32)1)); - default: - if ( BAHW_IsChargeSourceIn() ) return config.polling_time_in_charging_sec; - else return config.polling_time_in_discharging_sec; - } - */ - return 0; -} - -BOOL do_power_alg(BOOL is_event_triggered) -{ - /* is_event_triggered - TRUE: handle event only, do not update capacity; FALSE; always update capacity*/ - static BOOL s_bFirstEntry = TRUE; - static UINT32 s_pre_time_ms; - static INT32 s_level; - - UINT32 now_time_ms = BAHW_MyGetMSecs(); - - /*------------------------------------------------------ - 1 get battery data and update charge state*/ - if (!battery_param_update(&poweralg.battery, &poweralg.protect_flags)){ - printk(DRIVER_ZONE "battery_param_update fail, please retry next time.\n"); - return FALSE; - } - - update_next_charge_state(); - - /*----------------------------------------------------- - 2 calculate battery capacity (predict if necessary)*/ - if (s_bFirstEntry || now_time_ms - s_pre_time_ms > 10000 || !is_event_triggered){ - /* DO not update capacity when plug/unplug cable less than 10 seconds*/ - __update_capacity(); - - s_bFirstEntry = FALSE; - s_pre_time_ms = now_time_ms; - } - - if (config.debug_disable_shutdown){ - if (poweralg.capacity_01p <= 0){ - poweralg.capacity_01p = 1; - } - } - - s_level = CEILING(poweralg.capacity_01p, 10); - if (CEILING(poweralg.last_capacity_01p, 10) != s_level || - poweralg.battery.last_temp_01c != poweralg.battery.temp_01c) { - - poweralg.battery.last_temp_01c = poweralg.battery.temp_01c; - poweralg.last_capacity_01p = poweralg.capacity_01p; - ds2746_blocking_notify(DS2784_LEVEL_UPDATE, &s_level); - } - - bounding_fullly_charged_level(config.full_level); - - /*------------------------------------------------------ - 3 charging function change*/ - if (is_charging_avaiable()){ - if (is_high_current_charging_avaialable()){ - ds2746_charger_control(CHARGE_FAST); - } - else{ - ds2746_charger_control(CHARGE_SLOW); - } - } - else{ - ds2746_charger_control(CHARGE_OFF); - } - - if (config.debug_disable_hw_timer && poweralg.is_charge_over_load){ - ds2746_charger_control(CHARGE_OFF); - printk(DRIVER_ZONE "Toggle charger due to HW disable charger.\n"); - } - - /*------------------------------------------------------ - 4 debug messages and update os battery status*/ - - /*powerlog_to_file(&poweralg); - update_os_batt_status(&poweralg);*/ - - printk(DRIVER_ZONE "[%d] P=%d cable=%d%d flags=%d%d%d debug=%d%d%d%d fst_discharge=%d/%d [%u]\n", - poweralg.charge_state, - poweralg.capacity_01p, - poweralg.is_cable_in, - poweralg.is_china_ac_in, - poweralg.protect_flags.is_charging_enable_available, - poweralg.protect_flags.is_charging_high_current_avaialble, - poweralg.protect_flags.is_battery_dead, - config.debug_disable_shutdown, - config.debug_fake_room_temp, - config.debug_disable_hw_timer, - config.debug_always_predict, - poweralg.fst_discharge_capacity_01p, - poweralg.fst_discharge_acr_mAh, - BAHW_MyGetMSecs()); - - return TRUE; -} - -void power_alg_init(struct poweralg_config_type *debug_config) -{ - /*------------------------------------------------------------- - 1. setup default poweralg data*/ - poweralg.charge_state = CHARGE_STATE_UNKNOWN; - poweralg.capacity_01p = 990; - poweralg.last_capacity_01p = poweralg.capacity_01p; - poweralg.fst_discharge_capacity_01p = 0; - poweralg.fst_discharge_acr_mAh = 0; - poweralg.is_need_calibrate_at_49p = TRUE; - poweralg.is_need_calibrate_at_14p = TRUE; - poweralg.is_charge_over_load = FALSE; - poweralg.is_china_ac_in = FALSE; - poweralg.is_cable_in = FALSE; - poweralg.is_voltage_stable = FALSE; - poweralg.is_software_charger_timeout = FALSE; - poweralg.state_start_time_ms = 0; - - if(get_cable_status() == SOURCE_USB) - { - poweralg.is_cable_in = TRUE; - poweralg.charging_source = SOURCE_USB; - ds2746_charger_control(CHARGE_SLOW); - } - else if (get_cable_status() == SOURCE_AC) - { - poweralg.is_cable_in = TRUE; - poweralg.is_china_ac_in = TRUE; - poweralg.charging_source = SOURCE_AC; - ds2746_charger_control(CHARGE_FAST); - } else{ - poweralg.charging_source = SOURCE_NONE; - } - /*------------------------------------------------------------- - 2. setup default config flags (board dependent)*/ - poweralg_config_init(&config); - - if (debug_config){ - config.debug_disable_shutdown = debug_config->debug_disable_shutdown; - config.debug_fake_room_temp = debug_config->debug_fake_room_temp; - config.debug_disable_hw_timer = debug_config->debug_disable_hw_timer; - config.debug_always_predict = debug_config->debug_always_predict; - } - - /* if ( BAHW_IsTestMode() ) - { - config.debug_disable_shutdown = TRUE; - config.debug_fake_room_temp = TRUE; - config.debug_disable_hw_timer = TRUE; - }*/ - - /*------------------------------------------------------------- - 3. setup default protect flags*/ - poweralg.protect_flags.is_charging_enable_available = TRUE; - poweralg.protect_flags.is_battery_dead = FALSE; - poweralg.protect_flags.is_charging_high_current_avaialble = FALSE; - poweralg.protect_flags.is_fake_room_temp = config.debug_fake_room_temp; - - /*------------------------------------------------------------- - 4. setup default battery structure*/ - battery_param_init(&poweralg.battery); - - /*pr_info("power alg inited with board name <%s>\n", HTC_BATT_BOARD_NAME);*/ -} - -void power_alg_preinit(void) -{ - /* make sure cable and battery is in when off mode charging*/ -} - -static BLOCKING_NOTIFIER_HEAD(ds2746_notifier_list); -int ds2746_register_notifier(struct notifier_block *nb) -{ - pr_info("%s\n", __func__); - return blocking_notifier_chain_register(&ds2746_notifier_list, nb); -} - -int ds2746_unregister_notifier(struct notifier_block *nb) -{ - return blocking_notifier_chain_unregister(&ds2746_notifier_list, nb); -} - - -int ds2746_blocking_notify(unsigned long val, void *v) -{ - int chg_ctl; - pr_info("%s\n", __func__); - - if (val == DS2784_CHARGING_CONTROL){ - chg_ctl = *(int *) v; - if (machine_is_passionc()){ - pr_info("[ds2746_batt] Switch charging %d\n", chg_ctl); - if (chg_ctl <= 2){ - gpio_direction_output(22, !(!!chg_ctl));/*PNC*/ - set_charger_ctrl(chg_ctl); - } - return 0; - } - else if (poweralg.battery.id_index != BATTERY_ID_UNKNOWN){ - /* only notify at changes */ - if (poweralg.charging_enable == chg_ctl) - return 0; - else - poweralg.charging_enable = chg_ctl; - } - else{ - /* poweralg.charging_enable = DISABLE; - v = DISABLE; - pr_info("[HTC_BATT] Unknow battery\n");*/ - if (poweralg.charging_enable == chg_ctl) - return 0; - else - poweralg.charging_enable = chg_ctl; - } - } - return blocking_notifier_call_chain(&ds2746_notifier_list, val, v); -} - - -int ds2746_get_battery_info(struct battery_info_reply *batt_info) -{ - batt_info->batt_id = poweralg.battery.id_index; /*Mbat ID*/ - batt_info->batt_vol = poweralg.battery.voltage_mV; /*VMbat*/ - batt_info->batt_temp = poweralg.battery.temp_01c; /*Temperature*/ - batt_info->batt_current = poweralg.battery.current_mA; /*Current*/ - batt_info->level = CEILING(poweralg.capacity_01p, 10); /*last_show%*/ - batt_info->charging_source = poweralg.charging_source; - batt_info->charging_enabled = poweralg.charging_enable; - batt_info->full_bat = poweralg.battery.charge_full_real_mAh; - return 0; -} -ssize_t htc_battery_show_attr(struct device_attribute *attr, char *buf) -{ - int len = 0; - pr_info("%s\n", __func__); - if (!strcmp(attr->attr.name, "batt_attr_text")){ - len += scnprintf(buf + - len, - PAGE_SIZE - - len, - "Percentage(%%): %d;\n" - "KADC(%%): %d;\n" - "RARC(%%): %d;\n" - "V_MBAT(mV): %d;\n" - "Main_battery_ID(Kohm): %d;\n" - "pd_M: %d;\n" - "Current(mA): %d;\n" - "Temp: %d;\n" - "Charging_source: %d;\n" - "ACR(mAh): %d;\n" - "FULL(mAh): %d;\n" - "1st_dis_percentage(%%): %d;\n" - "1st_dis_ACR: %d;\n", - CEILING(poweralg.capacity_01p, 10), - CEILING(poweralg.battery.KADC_01p, 10), - CEILING(poweralg.battery.RARC_01p, 10), - poweralg.battery.voltage_mV, - poweralg.battery.id_ohm, - poweralg.battery.pd_m, - poweralg.battery.current_mA, - CEILING(poweralg.battery.temp_01c, 10), - poweralg.charging_source, - poweralg.battery.charge_counter_mAh, - poweralg.battery.charge_full_real_mAh, - CEILING(poweralg.fst_discharge_capacity_01p, 10), - poweralg.fst_discharge_acr_mAh - ); - } - return len; -} - - -static int cable_status_handler_func(struct notifier_block *nfb, - unsigned long action, void *param) -{ - u32 cable_type = (u32) action; - pr_info("[ds2746_batt] cable change to %d\n", cable_type); - /* When the cable plug out, reset all the related flag, - Let algorithm machine to judge latest state */ - if (cable_type == 0){ - poweralg.is_cable_in = 0; - poweralg.is_china_ac_in = 0; - /*htc_batt_info.rep.OTP_Flag = 0; - htc_batt_info.rep.charging_sts_flag = 0; - htc_batt_info.full_charge_count = 0;*/ - } - else if (cable_type == 1){ - poweralg.is_cable_in = 1; - poweralg.is_china_ac_in = 0; - } - else if (cable_type == 2){ - poweralg.is_cable_in = 1; - poweralg.is_china_ac_in = 1; - } - else if (cable_type == 0xff){ - if (param) - config.full_level = *(INT32 *)param; - pr_info("[ds2746_batt] Set the full level to %d\n", config.full_level); - return NOTIFY_OK; - } - else if (cable_type == 0x10){ - poweralg.protect_flags.is_fake_room_temp = TRUE; - pr_info("[ds2746_batt] enable fake temp mode\n"); - return NOTIFY_OK; - } - - if (cable_type <= 2){ - poweralg.charging_source = cable_type; - ds2746_blocking_notify(DS2784_CHARGING_CONTROL, - &poweralg.charging_source); - } - return NOTIFY_OK; -} - -static struct notifier_block cable_status_handler = -{ - .notifier_call = cable_status_handler_func, -}; - -void ds2746_charger_control(int type) -{ - int chg_ctl = DISABLE; - int charge_type = type; - - switch (charge_type){ - case CHARGE_OFF: - /* CHARGER_EN is active low. Set to 1 to disable. */ - chg_ctl = DISABLE; - ds2746_blocking_notify(DS2784_CHARGING_CONTROL, &chg_ctl); - /*if (temp >= TEMP_CRITICAL) - pr_info("batt: charging OFF [OVERTEMP]\n"); - else if (htc_batt_info.rep.cooldown) - pr_info("batt: charging OFF [COOLDOWN]\n"); - else if (htc_batt_info.rep.battery_full) - pr_info("batt: charging OFF [FULL]\n"); - else*/ - pr_info("batt: charging OFF\n"); - break; - case CHARGE_SLOW: - chg_ctl = ENABLE_SLOW_CHG; - ds2746_blocking_notify(DS2784_CHARGING_CONTROL, &chg_ctl); - pr_info("batt: charging SLOW\n"); - break; - case CHARGE_FAST: - chg_ctl = ENABLE_FAST_CHG; - ds2746_blocking_notify(DS2784_CHARGING_CONTROL, &chg_ctl); - pr_info("batt: charging FAST\n"); - break; - } -} - -static void ds2746_program_alarm(struct ds2746_device_info *di, int seconds) -{ - ktime_t low_interval = ktime_set(seconds - 10, 0); - ktime_t slack = ktime_set(20, 0); - ktime_t next; - - next = ktime_add(di->last_poll, low_interval); - - alarm_start_range(&di->alarm, next, ktime_add(next, slack)); -} - -static void ds2746_battery_work(struct work_struct *work) -{ - if (!htc_battery_initial) return; - struct ds2746_device_info *di = container_of(work, - struct ds2746_device_info, monitor_work); - unsigned long flags; - - pr_info("[ds2746_batt] ds2746_battery_work*\n"); - do_power_alg(0); - get_state_check_interval_min_sec(); - di->last_poll = alarm_get_elapsed_realtime(); - - /* prevent suspend before starting the alarm */ - local_irq_save(flags); - - wake_unlock(&di->work_wake_lock); - if (poweralg.battery.is_power_on_reset) - ds2746_program_alarm(di, PREDIC_POLL); - else - ds2746_program_alarm(di, FAST_POLL); - - local_irq_restore(flags); -} - -static void ds2746_battery_alarm(struct alarm *alarm) -{ - if (!htc_battery_initial) return; - struct ds2746_device_info *di = container_of(alarm, struct ds2746_device_info, alarm); - wake_lock(&di->work_wake_lock); - queue_work(di->monitor_wqueue, &di->monitor_work); -} - -static int ds2746_battery_probe(struct platform_device *pdev) -{ - int rc; - struct ds2746_device_info *di; - struct ds2746_platform_data *pdata = pdev->dev.platform_data; - - pr_info("[ds2746_batt] ds2746_battery_prob\n"); - - poweralg.battery.thermal_id = pdata->func_get_thermal_id(); - - power_alg_preinit(); - power_alg_init(&debug_config); - - di = kzalloc(sizeof(*di), GFP_KERNEL); - if (!di){ - rc = -ENOMEM; - goto fail_register; - } - - di->update_time = jiffies; - platform_set_drvdata(pdev, di); - - di->dev = &pdev->dev; - - INIT_WORK(&di->monitor_work, ds2746_battery_work); - di->monitor_wqueue = create_singlethread_workqueue(dev_name(&pdev->dev)); - - /* init to something sane */ - di->last_poll = alarm_get_elapsed_realtime(); - - if (!di->monitor_wqueue){ - rc = -ESRCH; - goto fail_workqueue; - } - wake_lock_init(&di->work_wake_lock, WAKE_LOCK_SUSPEND, "ds2746-battery"); - alarm_init(&di->alarm, - ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP, - ds2746_battery_alarm); - wake_lock(&di->work_wake_lock); - queue_work(di->monitor_wqueue, &di->monitor_work); - htc_battery_initial = 1; - return 0; - - fail_workqueue : fail_register : kfree(di); - return rc; -} - - -static int ds2746_battery_remove(struct platform_device *pdev) -{ - struct ds2746_device_info *di = platform_get_drvdata(pdev); - - cancel_work_sync(&di->monitor_work); - destroy_workqueue(di->monitor_wqueue); - - return 0; -} - -/* FIXME: power down DQ master when not in use. */ -static int ds2746_suspend(struct device *dev) -{ - struct platform_device *pdev = to_platform_device(dev); - struct ds2746_device_info *di = platform_get_drvdata(pdev); - unsigned long flags; - pr_info("ds2746_batt:ds2746_suspend\n"); - /* If we are on battery, reduce our update rate until - * we next resume.*/ - if (poweralg.charging_source == SOURCE_NONE){ - local_irq_save(flags); - ds2746_program_alarm(di, SLOW_POLL); - di->slow_poll = 1; - local_irq_restore(flags); - } - /*gpio_direction_output(87, 0);*/ - return 0; -} -static void ds2746_resume(struct device *dev) -{ - struct platform_device *pdev = to_platform_device(dev); - struct ds2746_device_info *di = platform_get_drvdata(pdev); - unsigned long flags; - - /* We might be on a slow sample cycle. If we're - * resuming we should resample the battery state - * if it's been over a minute since we last did - * so, and move back to sampling every minute until - * we suspend again.*/ - /*gpio_direction_output(87, 1);*/ - ndelay(100 * 1000); - pr_info("ds2746_batt:ds2746_resume\n"); - if (di->slow_poll){ - local_irq_save(flags); - ds2746_program_alarm(di, FAST_POLL); - di->slow_poll = 0; - local_irq_restore(flags); - } -} - -static struct dev_pm_ops ds2746_pm_ops = { - .prepare = ds2746_suspend, - .complete = ds2746_resume, -}; - -MODULE_ALIAS("platform:ds2746-battery"); -static struct platform_driver ds2746_battery_driver = -{ - .driver = { - .name = "ds2746-battery", - .pm = &ds2746_pm_ops, - }, - .probe = ds2746_battery_probe, - .remove = ds2746_battery_remove, -}; - -static int __init ds2746_battery_init(void) -{ - int ret; - - pr_info("[ds2746_batt]ds2746_battery_init"); - wake_lock_init(&vbus_wake_lock, WAKE_LOCK_SUSPEND, "vbus_present"); - register_notifier_cable_status(&cable_status_handler); - - ret = ds2746_i2c_init(); - if (ret < 0){ - return ret; - } - - /*mutex_init(&htc_batt_info.lock);*/ - return platform_driver_register(&ds2746_battery_driver); -} - -static void __exit ds2746_battery_exit(void) -{ - ds2746_i2c_exit(); - platform_driver_unregister(&ds2746_battery_driver); -} - -module_init(ds2746_battery_init); -module_exit(ds2746_battery_exit); - -MODULE_LICENSE("GPL"); -MODULE_AUTHOR("Andy.YS Wang "); -MODULE_DESCRIPTION("ds2746 battery driver"); - diff --git a/drivers/power/ds2746_param.c b/drivers/power/ds2746_param.c deleted file mode 100644 index db462c66..00000000 --- a/drivers/power/ds2746_param.c +++ /dev/null @@ -1,852 +0,0 @@ -/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - -Copyright (c) 2010 High Tech Computer Corporation - -Module Name: - - ds2784_param.c - -Abstract: - - This module implements the battery formula based on power spec, including below concepts: - 1. adc converter - 2. voltage mapping to capacity - 3. over temperature algorithm - 4. id range algorithm - 5. ACR maintainance - - Add from TPE PMA: - 1. temperature index - 2. pd_m_coef_boot - 3. preserved_capacity_by_temp - Remove from TAO PMA: - 1. pd_temp - - To adapt different PMA/projects, we need to modify below tables: - 1. ID_RANGE: which battery is used in the project? - 2. FL_25: the full capacity in temp 25C. - 3. pd_m_bias_mA: the discharge current threshold to calculating pd_m - 4. M_PARAMTER_TABLE: the voltage-capacity mapping table - 5. TEMP_RANGE: how many temp condition we need to consider - 6. PD_M_COEF_TABLE(BOOT)/PD_M_RESL_TABLE(BOOT): voltage compensation based on current - 7. PD_T_COEF: voltage compensation based on temp - 8. CAPACITY_DEDUCTION_01p: the capacity deduction due to low temperature - -Original Auther: - - Andy.ys Wang June-01-2010 - ----------------------------------------------------------------------------------*/ - -#include -#include -#include -#include -#include -#include -#include - -/*======================================================================================== - -build flags - -========================================================================================*/ - -#define HTC_ENABLE_POWER_DEBUG 0 -#define HTC_ENABLE_DUMMY_BATTERY 0 - -/*======================================================================================== - -battery common parameter defines (independent on battery id yet...) - -========================================================================================*/ - -#define BATTERY_VOLTAGE_MIN 2000 -#define BATTERY_VOLTAGE_MAX 20000 - -/*======================================================================================== - -battery parameter helper functions - -========================================================================================*/ - -static INT32 get_id_index(struct battery_type *battery) -{ - int i; - - for (i = 0; i < BATTERY_ID_NUM - 1; i++) { - /* minus 1, unknown battery is not in ID_RANGE - [min, max)*/ - UINT32 resister_min = ID_RANGE[i*2]; - UINT32 resister_max = ID_RANGE[i*2 + 1]; - - if (resister_min <= battery->id_ohm && resister_max > battery->id_ohm) { - return i + 1; - } - } - - return BATTERY_ID_UNKNOWN; -} - -static INT32 get_temp_index(struct battery_type *battery) -{ - int i; - - for (i = 0; i < 255; i++) { - /* the table size shall not be greater then 255, to ensure no infinite looping - [min, max)*/ - INT32 temp = TEMP_RANGE[i]; - if (battery->temp_01c >= temp) - return i; - } - - printk(DRIVER_ZONE " invalid batt_temp (%d) or temp range mapping.\n", battery->temp_01c); - return -1; -} - -/*======================================================================================== - -temperature formula definitions - -========================================================================================*/ - -static INT32 get_temp_01c(struct battery_type *battery) -{ - int current_index = battery->temp_check_index; - int search_direction = 0; - - if (battery->last_temp_adc > battery->temp_adc) { - search_direction = -1; - } else { - search_direction = 1; - } - - while (current_index >= 0 && current_index < TEMP_NUM-1) { - - UINT32 temp_min = TEMP_MAP[current_index]; - UINT32 temp_max = TEMP_MAP[current_index + 1]; - - if (temp_max > battery->temp_adc && temp_min <= battery->temp_adc) { - battery->temp_check_index = current_index; - battery->last_temp_adc = battery->temp_adc; - return (TEMP_MAX-current_index)*10; - } - current_index += search_direction; - } - - return (TEMP_MIN-1)*10; -} - -/*======================================================================================== - -over temperature protection - -========================================================================================*/ - -static BOOL is_over_temp(struct battery_type *battery) -{ - /* stop charging*/ - if (battery->temp_01c < over_low_temp_lock_01c || battery->temp_01c >= over_high_temp_lock_01c) { - return TRUE; - } - - return FALSE; -} - -static BOOL is_not_over_temp(struct battery_type *battery) -{ - /* start charging*/ - if (battery->temp_01c >= over_low_temp_release_01c && - battery->temp_01c < over_high_temp_release_01c) { - return TRUE; - } - - return FALSE; -} - -static void __protect_flags_update(struct battery_type *battery, - struct protect_flags_type *flags) -{ - /* Flags: - is_charging_enable_available - Over temperature, need to stop charging - is_charging_high_current_avaialble - Temperature is too high so that we have to slow charge*/ - - if (is_over_temp(battery)) { - /* Ex: T<0 or T>45 */ - flags->is_charging_enable_available = FALSE; - flags->is_charging_high_current_avaialble = FALSE; -#if 0 - flags->is_battery_overtemp = TRUE; -#endif - } else if (is_not_over_temp(battery)) { - /* Ex: T<42 or T>3*/ - flags->is_charging_enable_available = TRUE; - flags->is_charging_high_current_avaialble = TRUE; -#if 0 - flags->is_battery_overtemp = FALSE; -#endif - } - - /* Flags: - is_battery_dead - If battery is dead, show special indicator for it*/ - if (battery->voltage_mV < BATTERY_DEAD_VOLTAGE_LEVEL) { - flags->is_battery_dead = TRUE; - } - else if (battery->voltage_mV > BATTERY_DEAD_VOLTAGE_RELEASE) { - flags->is_battery_dead = FALSE; - } -} - -/*======================================================================================== - -Voltage-Percentage mapping - -========================================================================================*/ - -/*------------------------------------------------------------------------ - Example: - p0 = (4200, 10000); 4.2V for 100% - p1 = (3900, 8000); 3.9V for 80% - p2 = (3700, 2000); 3.7V for 20% - p3 = (3300, 0); 3.3V for 0% - - if V = 4000, (3900<4000<4200) - P = (4000-3900) * (10000-8000)/(4200-3900) + 8000 = 8666*/ - -#define NUM_SAMPLED_POINTS_MAX 12 - -struct sampled_point_type { - - DWORD voltage; - DWORD capacity; -}; - -struct voltage_curve_translator { - - DWORD voltage_min; - DWORD voltage_max; - DWORD capacity_min; - DWORD capacity_max; - int sampled_point_count; - struct sampled_point_type sampled_points[NUM_SAMPLED_POINTS_MAX]; -}; - -static void voltage_curve_translator_init(struct voltage_curve_translator *t) -{ - memset(t, 0, sizeof(*t)); -} - -static void voltage_curve_translator_add(struct voltage_curve_translator *t, DWORD voltage, DWORD capacity) -{ - struct sampled_point_type *pt; - - if (t->sampled_point_count >= NUM_SAMPLED_POINTS_MAX) { - return; - } - - t->sampled_points[t->sampled_point_count].voltage = voltage; - t->sampled_points[t->sampled_point_count].capacity = capacity; - pt = &t->sampled_points[t->sampled_point_count]; - - t->sampled_point_count++; - - if (pt->voltage > t->voltage_max) - t->voltage_max = pt->voltage; - if (pt->voltage < t->voltage_min) - t->voltage_min = pt->voltage; - if (pt->capacity > t->capacity_max) - t->capacity_max = pt->capacity; - if (pt->capacity < t->capacity_min) - t->capacity_min = pt->capacity; - -#if HTC_ENABLE_POWER_DEBUG - printk(DRIVER_ZONE " kadc t: capacity=%d voltage=%d\n", capacity, voltage); -#endif /* HTC_ENABLE_POWER_DEBUG*/ -} - -static INT32 voltage_curve_translator_get(struct voltage_curve_translator *t, DWORD voltage) -{ - struct sampled_point_type *p0, *p1; - INT32 capacity; - int i; - - if (voltage > t->voltage_max) - voltage = t->voltage_max; - if (voltage < t->voltage_min) - voltage = t->voltage_min; - - p0 = &t->sampled_points[0]; - p1 = p0 + 1; - for (i = 0; i < t->sampled_point_count - 1 && voltage < p1->voltage; i++) { - p0++; - p1++; - } - - /* DIV ZERO check*/ - if (p0->voltage - p1->voltage == 0) { - return 0; - } - - /* INT32 overflow check: mv(4200) * capacity(10000), shall be no problem at all...*/ - capacity = (voltage - p1->voltage) * (p0->capacity - p1->capacity) / (p0->voltage - p1->voltage) + p1->capacity; - if (capacity > t->capacity_max) { - capacity = t->capacity_max; - } - if (capacity < t->capacity_min) { - capacity = t->capacity_min; - } - return capacity; -} - -/*======================================================================================== - -KADC mapping functions - -========================================================================================*/ - -static struct voltage_curve_translator __get_kadc_t; - -static INT32 get_kadc_001p(struct battery_type *battery) -{ - INT32 pd_m = 0; - INT32 pd_temp = 0; - - INT32 temp_01c = battery->temp_01c; - INT32 current_mA = battery->current_mA; - - UINT32 *m_paramtable; - - INT32 pd_m_coef; - INT32 pd_m_resl; - - INT32 capacity_deduction_01p = CAPACITY_DEDUCTION_01p[battery->temp_index]; - INT32 capacity_predict_001p; - /* 1. INT32 overflow check: assert abs(iChgCurrent_ma) <= 3000, iBattTemp_01c>-250, pd_t_coef <= 1000 - when calculating pd_temp: 0x7FFFFFFF / (500 * 3000 * 1000) =:= 1.4*/ - - if (battery->current_mA > 3000) - current_mA = 3000; - else if (battery->current_mA < -3000) - current_mA = -3000; - if (battery->temp_01c <= -250) - temp_01c = -250; - - /* 2. calculate pd_m and pd_temp*/ - - if (battery->is_power_on_reset) { - pd_m_coef = PD_M_COEF_TABLE_BOOT[battery->temp_index][battery->id_index]; - pd_m_resl = PD_M_RESL_TABLE_BOOT[battery->temp_index][battery->id_index]; - } - else{ - pd_m_coef = PD_M_COEF_TABLE[battery->temp_index][battery->id_index]; - pd_m_resl = PD_M_RESL_TABLE[battery->temp_index][battery->id_index]; - } - - if (battery->current_mA < -pd_m_bias_mA) { - /* ex: -150mA < -130mA*/ - pd_m = (abs(battery->current_mA) - pd_m_bias_mA) * pd_m_coef /pd_m_resl; - } - - if (battery->temp_01c < 250) { - pd_temp = ((250 - battery->temp_01c) * (abs(battery->current_mA) * PD_T_COEF[battery->id_index])) / (10 * 10000); - } - battery->pd_m = pd_m; - - /* 3. calculate KADC using M_PARAMTER_TABLE*/ - - m_paramtable = M_PARAMTER_TABLE[battery->id_index]; - if (m_paramtable) { - int i = 0; /* assume that m_paramtable has at least 2 items...the last capacity item must be 0 to end the loop...*/ - - voltage_curve_translator_init(&__get_kadc_t); - - while (1) { - INT32 capacity = m_paramtable[i]; - INT32 voltage = m_paramtable[i + 1]; - if (capacity == 10000) { - /* full capacity, no need to fix voltage level*/ - voltage_curve_translator_add(&__get_kadc_t, voltage, capacity); - } - else { - voltage_curve_translator_add(&__get_kadc_t, voltage - pd_temp, capacity); - } - - if (capacity == 0) - break; - - i += 2; - } - -#if HTC_ENABLE_POWER_DEBUG - printk(DRIVER_ZONE " pd_m=%d, pd_temp=%d\n", pd_m, pd_temp); -#endif /* HTC_ENABLE_POWER_DEBUG*/ - - capacity_predict_001p = voltage_curve_translator_get(&__get_kadc_t, battery->voltage_mV + pd_m); - } - else{ - capacity_predict_001p = (battery->voltage_mV - 3400) * 10000 / (4200 - 3400); - } - - return (capacity_predict_001p - capacity_deduction_01p * 10) * 10000 / (10000 - capacity_deduction_01p * 10); -} - -/*======================================================================================== - -coulomb counter+curve tracer - -========================================================================================*/ - -static INT32 get_software_acr_revise(struct battery_type *battery, UINT32 ms) -{ - INT32 kadc_01p = battery->KADC_01p; - INT32 ccbi_01p = battery->RARC_01p; - INT32 delta_01p = kadc_01p - ccbi_01p; - - DWORD C = 5; /* KADC = 15%~100%*/ - if (kadc_01p <= 150) { - C = 5; - } /* KADC = 0%~15%*/ - - if (delta_01p < 0) { - /* if KADC is less than RARC, p shall be lower*/ - return -(INT32) (C * ms * delta_01p * delta_01p) / 1000; - } - else{ - /* if KADC is larger than RARC, p shall be higher*/ - return (INT32) (C * ms * delta_01p * delta_01p) / 1000; - } -} - -/*======================================================================================== - -ds2746 gauge ic functions, to access ds2746 registers and convert ADC to battery param - -========================================================================================*/ - -static void __ds2746_clear_porf(void) -{ - UINT8 reg_data; - if (!ds2746_i2c_read_u8(®_data, 0x01)) { - printk(DRIVER_ZONE " clear porf error in read.\n"); - return; - } - - if (!ds2746_i2c_write_u8((reg_data & (~DS2746_STATUS_PORF)), 0x01)) { - printk(DRIVER_ZONE " clear porf error in write.\n"); - return; - } -} - -static void __ds2746_acr_update(struct battery_type *battery, int capacity_01p) -{ - printk(DRIVER_ZONE " acr update: P=%d, C=%d.\n", - capacity_01p, - battery->charge_counter_adc); - - ds2746_i2c_write_u8((battery->charge_counter_adc & 0xFF00) >> 8, 0x10); - ds2746_i2c_write_u8((battery->charge_counter_adc & 0x00FF), 0x11); - - if (battery->is_power_on_reset) { - __ds2746_clear_porf(); - } -} - -static void __ds2746_init_config(struct battery_type *battery) -{ - UINT8 reg_data; - - if (!ds2746_i2c_read_u8(®_data, 0x01)) { - printk(DRIVER_ZONE " init config error in read.\n"); - return; - } - - /* Erase SMOD and NBEN value in DS2746 status/config register*/ - reg_data &= ~(DS2746_STATUS_SMOD | DS2746_STATUS_NBEN); - if (!ds2746_i2c_write_u8(reg_data, 0x01)) { - printk(DRIVER_ZONE " init config error in write.\n"); - return; - } -} - -static BOOL __ds2746_get_reg_data(UINT8 *reg) -{ - memset(reg, 0, 12); - - if (!ds2746_i2c_read_u8(®[0], 0x01)) - return FALSE; - if (!ds2746_i2c_read_u8(®[2], 0x08)) - return FALSE; - if (!ds2746_i2c_read_u8(®[3], 0x09)) - return FALSE; - if (!ds2746_i2c_read_u8(®[4], 0x0a)) - return FALSE; - if (!ds2746_i2c_read_u8(®[5], 0x0b)) - return FALSE; - if (!ds2746_i2c_read_u8(®[6], 0x0c)) - return FALSE; - if (!ds2746_i2c_read_u8(®[7], 0x0d)) - return FALSE; - if (!ds2746_i2c_read_u8(®[8], 0x0e)) - return FALSE; - if (!ds2746_i2c_read_u8(®[9], 0x0f)) - return FALSE; - if (!ds2746_i2c_read_u8(®[10], 0x10)) - return FALSE; - if (!ds2746_i2c_read_u8(®[11], 0x11)) - return FALSE; - - return TRUE; -} - -static BOOL __ds2746_battery_adc_udpate(struct battery_type *battery) -{ - UINT8 reg[12]; - - if (!__ds2746_get_reg_data((UINT8 *) ®)) { - printk(DRIVER_ZONE " get ds2746 data failed...\n"); - return FALSE; - } - - printk(DRIVER_ZONE " [x0]%x [x8]%x %x %x %x %x %x %x %x %x %x\n", - reg[0], - reg[2], - reg[3], - reg[4], - reg[5], - reg[6], - reg[7], - reg[8], - reg[9], - reg[10], - reg[11]); - - if (!(reg[0] & DS2746_STATUS_AIN0) || !(reg[0] & DS2746_STATUS_AIN1)) { - printk(DRIVER_ZONE " AIN not ready...\n"); - return FALSE; - } - - if (reg[0] & DS2746_STATUS_PORF) { - battery->is_power_on_reset = TRUE; - } - else{ - battery->is_power_on_reset = FALSE; - } - - /* adc register value*/ - battery->voltage_adc = MAKEWORD(reg[7], reg[6]) >> 4; - battery->current_adc = MAKEWORD(reg[9], reg[8]); - if (battery->current_adc & 0x8000) { - battery->current_adc = -(0x10000 - battery->current_adc); - } - battery->current_adc /= 4; - battery->charge_counter_adc = MAKEWORD(reg[11], reg[10]); - if (battery->charge_counter_adc & 0x8000) { - battery->charge_counter_adc = -(0x10000 - battery->charge_counter_adc); - } - battery->id_adc = MAKEWORD(reg[5], reg[4]) >> 4; - battery->temp_adc = MAKEWORD(reg[3], reg[2]) >> 4; - if (support_ds2746_gauge_ic) { - /* we preserve 500mAh for capacity lower than 0%, however the 500mAh is still drained out...we need to do predict for correct ACR*/ - if ((battery->charge_counter_adc & 0xFFFF) >= 0xF000){ - printk(DRIVER_ZONE " ACR out of range (x%x)...\n", - battery->charge_counter_adc); - battery->is_power_on_reset = TRUE; - } - } - - return TRUE; -} - -/*======================================================================================== - -softwar acr functions, to accumulate ACR by software and revise by battery parameter - -========================================================================================*/ - -static void __software_charge_counter_update(struct battery_type *battery, UINT32 ms) -{ - /* if the charge counter is maintained by sw, batt_alg shall use this routine to update charge counter and related parameters*/ - INT32 capacity_deduction_01p = CAPACITY_DEDUCTION_01p[battery->temp_index]; - /* AEL(mAh): A low temp unusable battery capacity, calculated in runtime*/ - INT32 ael_mAh = capacity_deduction_01p *battery->charge_full_real_mAh / 1000; -#if HTC_ENABLE_POWER_DEBUG - printk(DRIVER_ZONE "chgctr update: I=%d ms=%d.\n", battery->current_mA, ms); -#endif /* HTC_ENABLE_POWER_DEBUG*/ - - /* ACRt(mAh): The total capacity battery owns, stored in battery->charge_counter_mAh*/ - battery->software_charge_counter_mAms += (INT32) (battery->current_mA * ms); - battery->charge_counter_mAh += (battery->software_charge_counter_mAms / 3600000); - battery->software_charge_counter_mAms -= (battery->software_charge_counter_mAms / 3600000) * 3600000; - - /* CCBI(0.1%): A software RARC*/ - battery->RARC_01p = (battery->charge_counter_mAh - ael_mAh) * 1000 / (battery->charge_full_real_mAh - ael_mAh); - /* store back the battery->charge_counter_mAh to battery->charge_counter_adc*/ - battery->charge_counter_adc = (battery->charge_counter_mAh + charge_counter_zero_base_mAh) * acr_adc_to_mv_coef / acr_adc_to_mv_resl; -} - -static void __software_charge_counter_revise(struct battery_type *battery, UINT32 ms) -{ - if (battery->current_mA < 0) { -#if HTC_ENABLE_POWER_DEBUG - printk(DRIVER_ZONE "chgctr revise: delta=%d.\n", get_software_acr_revise(battery, ms)); -#endif /* HTC_ENABLE_POWER_DEBUG*/ - - /* revise software charge counter by coulomb counter+curve tracer*/ - battery->software_charge_counter_mAms += get_software_acr_revise(battery, ms); - battery->charge_counter_mAh += (battery->software_charge_counter_mAms / 3600000); - battery->software_charge_counter_mAms -= (battery->software_charge_counter_mAms / 3600000) * 3600000; - /* store back the battery->charge_counter_mAh to battery->charge_counter_adc*/ - battery->charge_counter_adc = (battery->charge_counter_mAh + charge_counter_zero_base_mAh) * acr_adc_to_mv_coef / acr_adc_to_mv_resl; - } -} - -static void __software_acr_update(struct battery_type *battery) -{ - static BOOL s_bFirstEntry = TRUE; - static DWORD last_time_ms; - DWORD now_time_ms = BAHW_MyGetMSecs(); - - if (s_bFirstEntry) { - s_bFirstEntry = FALSE; - last_time_ms = now_time_ms; - } - -#if HTC_ENABLE_POWER_DEBUG - printk(DRIVER_ZONE "+acr update: adc=%d C=%d mams=%d.\n", - battery->charge_counter_adc, - battery->charge_counter_mAh, - battery->software_charge_counter_mAms); -#endif /* HTC_ENABLE_POWER_DEBUG*/ - - __software_charge_counter_update(battery, now_time_ms - last_time_ms); - __software_charge_counter_revise(battery, now_time_ms - last_time_ms); - -#if HTC_ENABLE_POWER_DEBUG - printk(DRIVER_ZONE "-acr update: adc=%d C=%d mams=%d.\n", - battery->charge_counter_adc, - battery->charge_counter_mAh, - battery->software_charge_counter_mAms); -#endif /* HTC_ENABLE_POWER_DEBUG*/ - - last_time_ms = now_time_ms; -} - -/*======================================================================================== - -battery param update, the coef are referenced from power spec - -========================================================================================*/ - -static BOOL __battery_param_udpate(struct battery_type *battery) -{ - static int batt_id_stable_counter = 0; - INT32 batt_id_index; - INT32 temp_01c; - - if (support_ds2746_gauge_ic) { - /* adc register value are read from __ds2746_battery_adc_udpate()*/ - if (!__ds2746_battery_adc_udpate(battery)) - return FALSE; - } - else{ - /* adc register value are read from BAHW_get_batt_info_all() - if ( !BAHW_get_batt_info_all(battery) ) return FALSE;*/ - } - - /*real physical value*/ - battery->voltage_mV = (battery->voltage_adc * voltage_adc_to_mv_coef / voltage_adc_to_mv_resl); - battery->current_mA = (battery->current_adc * current_adc_to_mv_coef / current_adc_to_mv_resl); - battery->discharge_mA = (battery->discharge_adc * discharge_adc_to_mv_coef / discharge_adc_to_mv_resl); - battery->charge_counter_mAh = (battery->charge_counter_adc * acr_adc_to_mv_coef / acr_adc_to_mv_resl) - charge_counter_zero_base_mAh; - battery->current_mA = battery->current_mA - battery->discharge_mA; - /* prevent from adc out of range*/ - if (battery->id_adc >= id_adc_resl) { - battery->id_adc = id_adc_resl - 1; - } - if (battery->id_adc <= 0) { - battery->id_adc = 1; - } - if (battery->temp_adc >= temp_adc_resl) { - battery->temp_adc = temp_adc_resl - 1; - } - if (battery->temp_adc <= 0) { - battery->temp_adc = 1; - } - - /* battery ID shall be ready first for temp/kadc calculation*/ - // if ( id_conversion ) battery->id_ohm = ((float)id_R_kohm / ((float)id_adc_resl/battery->id_adc - 1)) * 1000; // kohm -> ohm - // else battery->id_ohm = battery->id_adc; - battery->id_ohm = battery->id_adc; - calibrate_id_ohm(battery); - - batt_id_index = get_id_index(battery); - - if (is_allow_batt_id_change) { - /*! TODO: batt_id changes immediately; may need to modify in future*/ - if (batt_id_stable_counter >= 3 && batt_id_index != battery->id_index){ - /* if batt_id is stable but is different from previous one*/ - batt_id_stable_counter = 0; /* reset stable counter and set batt_id to new one*/ - } - } - - if (batt_id_stable_counter < 3) { - if (batt_id_stable_counter == 0) { - /* first time to get the batt id*/ - battery->id_index = batt_id_index; - battery->charge_full_design_mAh = FL_25[battery->id_index]; - battery->charge_full_real_mAh = battery->charge_full_design_mAh; - batt_id_stable_counter = 1; - } - else{ - /* 2nd and further time to get the batt id*/ - if (batt_id_index == battery->id_index) - batt_id_stable_counter++; - else - batt_id_stable_counter = 0; - } - } - - /* calculate temperature*/ - // battery->temp_01c = get_temp_c((float)temp_R_kohm / ((float)temp_adc_resl/battery->temp_adc - 1))*10; - temp_01c = get_temp_01c(battery); - if (temp_01c >= TEMP_MIN*10) - battery->temp_01c = temp_01c; - else - printk(DRIVER_ZONE " get temp_01c(%d) failed...\n", temp_01c); - battery->temp_index = get_temp_index(battery); - - /* calculate KADC and RARC*/ - battery->KADC_01p = CEILING(get_kadc_001p(battery), 10); - battery->RARC_01p = CEILING(10000 * battery->charge_counter_mAh / battery->charge_full_real_mAh, 10); - if (!support_ds2746_gauge_ic) { - __software_acr_update(battery); - } - - if (battery->voltage_mV voltage_mV> BATTERY_VOLTAGE_MAX) { - printk(DRIVER_ZONE " invalid V(%d).\n", battery->voltage_mV); - return FALSE; - } - - /*! star_lee 20100426 - minimum RARC is 0%*/ - if (battery->RARC_01p <= 0) { - battery->RARC_01p = 0; - } - - printk(DRIVER_ZONE " V=%d(%x) I=%d(%x) C=%d.%d/%d(%x) id=%d(%x) T=%d(%x) KADC=%d\n", - battery->voltage_mV, - battery->voltage_adc, - battery->current_mA, - battery->current_adc, - battery->charge_counter_mAh, - battery->software_charge_counter_mAms, - battery->charge_full_real_mAh, - battery->charge_counter_adc, - battery->id_index, - battery->id_adc, - battery->temp_01c, - battery->temp_adc, - battery->KADC_01p); - - return TRUE; -} - -/*======================================================================================== - -time functions - -========================================================================================*/ - -DWORD BAHW_MyGetMSecs(void) -{ - struct timespec now; - getnstimeofday(&now); - /*struct timespec t; - t.tv_sec = t.tv_nsec = 0; - clock_gettime(CLOCK_MONOTONIC, &t);*/ - return now.tv_sec * 1000 + now.tv_nsec / 1000000; -} - -/*======================================================================================== - -battery param public function - -========================================================================================*/ - -void battery_capacity_update(struct battery_type *battery, int capacity_01p) -{ - - /* ACR 500~500+FULL mapping to capacity 0~FULL*/ - battery->charge_counter_mAh = capacity_01p * battery->charge_full_real_mAh / 1000; - battery->charge_counter_adc = (battery->charge_counter_mAh + charge_counter_zero_base_mAh) * acr_adc_to_mv_resl / acr_adc_to_mv_coef; - battery->RARC_01p = capacity_01p; - if (support_ds2746_gauge_ic) { - __ds2746_acr_update(battery, capacity_01p); - } - - printk(DRIVER_ZONE "new RARC=%d C=%dmAh adc=%d.\n", - battery->RARC_01p, - battery->charge_counter_mAh, - battery->charge_counter_adc); - battery->is_power_on_reset = FALSE; -} - -BOOL battery_param_update(struct battery_type *battery, struct protect_flags_type *flags) -{ - if (!__battery_param_udpate(battery)) { - return FALSE; - } - - if (flags->is_fake_room_temp) { - battery->temp_01c = 250; - printk(DRIVER_ZONE "fake temp=%d(%x)\n", - battery->temp_01c, - battery->temp_adc); - } - __protect_flags_update(battery, flags); - -#if ! HTC_ENABLE_DUMMY_BATTERY - if (battery->id_index == BATTERY_ID_UNKNOWN) { - flags->is_charging_enable_available = FALSE; - } -#else /* HTC_ENABLE_DUMMY_BATTERY*/ - /* do not disable charging for debug stage*/ - flags->is_charging_enable_available = TRUE; -#endif /* HTC_ENABLE_DUMMY_BATTERY*/ - - return TRUE; -} - -void battery_param_init(struct battery_type *battery) -{ - /* set battery id to unknown to get battery id and related characters*/ - battery->id_index = BATTERY_ID_UNKNOWN; - - /* default to 25C unless we can get valid battery temp from adc*/ - battery->temp_01c = 250; - battery->last_temp_01c = battery->temp_01c; - battery->temp_check_index = 0; - battery->last_temp_adc = 0; - - battery->voltage_mV = 3800; - - /* this is used when accumulate current by software; initial it as 0mAs*/ - battery->software_charge_counter_mAms = 0; - - /* set POR at first by software; gauge ic will has correct value*/ - battery->is_power_on_reset = TRUE; - - if (support_ds2746_gauge_ic) { - __ds2746_init_config(battery); - } - - if (battery->thermal_id == THERMAL_1000) { - TEMP_MAP = TEMP_MAP_1000K; - printk(DRIVER_ZONE "Use 1000 Kohm thermal resistance"); - } else { - printk(DRIVER_ZONE "Use default(300 Kohm) thermal resistance"); - } - - /*printk(DRIVER_ZONE "battery param inited with board name <%s>\n", HTC_BATT_BOARD_NAME);*/ -} - diff --git a/include/linux/ds2746_battery.h b/include/linux/ds2746_battery.h deleted file mode 100644 index d8930f52..00000000 --- a/include/linux/ds2746_battery.h +++ /dev/null @@ -1,148 +0,0 @@ -/* - * Copyright (C) 2007 HTC Incorporated - * - * This software is licensed under the terms of the GNU General Public - * License version 2, as published by the Free Software Foundation, and - * may be copied, distributed, and modified under those terms. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - */ -#ifndef _DS2746_BATTERY_H_ -#define _DS2746_BATTERY_H_ -#include -#include -#include -#include - -enum ds2784_notify_evt_t { - DS2784_CHARGING_CONTROL = 0, - DS2784_LEVEL_UPDATE, - DS2784_BATTERY_FAULT, - DS2784_OVER_TEMP, - DS2784_NUM_EVENTS, -}; - -/* battery charging state*/ - -enum { - CHARGE_STATE_UNKNOWN, /* before anything is ready, we are in this state. shall default low current charge and show charging LED*/ - CHARGE_STATE_PREDICTION, /* in normal case, we need to enter prediction for 10 seconds for 1st KADC*/ - CHARGE_STATE_DISCHARGE, /* cable out state*/ - CHARGE_STATE_CHARGING, /* charging state*/ - CHARGE_STATE_PENDING, /* charging state but no good*/ - CHARGE_STATE_FULL_WAIT_STABLE, /* charging state but going full*/ - CHARGE_STATE_FULL_CHARGING, /* charging full, keep charging*/ - CHARGE_STATE_FULL_PENDING, /* charging full, stop charging*/ -}; - -enum { - THERMAL_300, - THERMAL_600, - THERMAL_1000, -}; - -/* power algorithm data structure and config data structure*/ - -struct poweralg_type -{ - int charge_state; - int capacity_01p; - int last_capacity_01p; - int fst_discharge_capacity_01p; - int fst_discharge_acr_mAh; - int charging_source; - int charging_enable; - BOOL is_need_calibrate_at_49p; - BOOL is_need_calibrate_at_14p; - BOOL is_charge_over_load; - struct battery_type battery; - struct protect_flags_type protect_flags; - BOOL is_china_ac_in; - BOOL is_cable_in; - BOOL is_voltage_stable; - BOOL is_software_charger_timeout; - UINT32 state_start_time_ms; -}; - -struct poweralg_config_type -{ - INT32 full_charging_mv; - INT32 full_charging_ma; - INT32 full_pending_ma; /* 0 to disable*/ - INT32 full_charging_timeout_sec; /* 0 to disable*/ - INT32 voltage_recharge_mv; /* 0 to disable*/ - INT32 capacity_recharge_p; /* 0 to disable*/ - INT32 voltage_exit_full_mv; /* 0 to disable*/ - INT32 wait_votlage_statble_sec; - INT32 predict_timeout_sec; - INT32 polling_time_in_charging_sec; - INT32 polling_time_in_discharging_sec; - - BOOL enable_full_calibration; - BOOL enable_weight_percentage; - INT32 software_charger_timeout_sec; /* 0 to disable*/ - - BOOL debug_disable_shutdown; - BOOL debug_fake_room_temp; - BOOL debug_disable_hw_timer; - BOOL debug_always_predict; - INT32 full_level; /* 0 to disable*/ -}; - -struct ds2746_platform_data { - int (*func_get_thermal_id)(void); -}; - -/* battery behavior constant*/ - -#define BATTERY_PERCENTAGE_UNKNOWN 0xFF -#define BATTERY_LOW_PERCENTAGE 10 /* in 1%*/ -#define BATTERY_CRITICAL_PERCENTAGE 5 /* in 1%*/ -#define BATTERY_EMPTY_PERCENTAGE 0 /* in 1%*/ - -/* battery algorithm public functions*/ - -int get_state_check_interval_min_sec( void); -BOOL do_power_alg( BOOL is_event_triggered); -void power_alg_init( struct poweralg_config_type *debug_config); -void power_alg_preinit( void); -int ds2746_blocking_notify( unsigned long val, void *v); -void ds2746_charger_control( int type); -int ds2746_i2c_write_u8( u8 value, u8 reg); -int ds2746_i2c_read_u8( u8* value, u8 reg); -void calibrate_id_ohm( struct battery_type *battery); -/* external function implemented by upper layer*/ - -/*extern void powerlog_to_file(struct poweralg_type* poweralg);*/ -/*extern void update_os_batt_status(struct poweralg_type* poweralg);*/ - -#ifdef CONFIG_BATTERY_DS2746 -extern int ds2746_register_notifier( struct notifier_block *nb); -extern int ds2746_unregister_notifier( struct notifier_block *nb); -extern int ds2746_get_battery_info( struct battery_info_reply *batt_info); -extern ssize_t htc_battery_show_attr( struct device_attribute *attr, char *buf); -#else -static int ds2746_register_notifier( struct notifier_block *nb) { - - return 0; -} -static int ds2746_unregister_notifier( struct notifier_block *nb) { - - return 0; -} -static int ds2746_get_battery_info( struct battery_info_reply *batt_info) { - - batt_info->level = 10; - return 0; -} -extern ssize_t htc_battery_show_attr( struct device_attribute *attr, char *buf) { - - return 0; -} - -#endif - -#endif diff --git a/include/linux/ds2746_battery_config.h b/include/linux/ds2746_battery_config.h deleted file mode 100644 index 2195d450..00000000 --- a/include/linux/ds2746_battery_config.h +++ /dev/null @@ -1,44 +0,0 @@ -/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - -Copyright (c) 2010 High Tech Computer Corporation - -Module Name: - - batt_alg_config.c -Abstract: - - This module tells batt_alg.c module how to config power alg. - -Original Auther: - - Star Lee (star_lee) Apr-12-2010 - ----------------------------------------------------------------------------------*/ - -#define HTC_BATT_BOARD_NAME "ACE" - -static void poweralg_config_init(struct poweralg_config_type *config) -{ - config->full_charging_mv = 4110; - config->full_charging_ma = 50; - config->full_pending_ma = 0; /* disabled*/ - config->full_charging_timeout_sec = 60 * 60; - config->voltage_recharge_mv = 4150; - config->capacity_recharge_p = 0; /* disabled*/ - config->voltage_exit_full_mv = 4100; - config->wait_votlage_statble_sec = 1 * 60; - config->predict_timeout_sec = 10; - config->polling_time_in_charging_sec = 30; - config->polling_time_in_discharging_sec = 30; - - config->enable_full_calibration = TRUE; - config->enable_weight_percentage = TRUE; - config->software_charger_timeout_sec = 0; /* disabled*/ - - config->debug_disable_shutdown = FALSE; - config->debug_fake_room_temp = FALSE; - config->debug_disable_hw_timer = FALSE; - config->debug_always_predict = FALSE; - config->full_level = 0; -} - diff --git a/include/linux/ds2746_param.h b/include/linux/ds2746_param.h deleted file mode 100644 index 49733165..00000000 --- a/include/linux/ds2746_param.h +++ /dev/null @@ -1,70 +0,0 @@ -#ifndef __BATT_PARAM_H__ -#define __BATT_PARAM_H__ - -/* battery status and charging information*/ - -struct battery_type{ - - BOOL is_power_on_reset; - - INT32 voltage_mV; - INT32 current_mA; - INT32 discharge_mA; - INT32 charge_counter_mAh; - INT32 temp_01c; - INT32 last_temp_01c; - INT32 id_ohm; - INT32 vref_mv; - - INT32 voltage_adc; - INT32 current_adc; - INT32 discharge_adc; - INT32 charge_counter_adc; - INT32 temp_adc; - INT32 last_temp_adc; - INT32 id_adc; - INT32 vref_adc; - - INT32 id_index; - INT32 charge_full_design_mAh; - INT32 charge_full_real_mAh; - - INT32 temp_index; - INT32 temp_check_index; - - INT32 KADC_01p; - INT32 RARC_01p; - INT32 pd_m; - - INT32 software_charge_counter_mAms; - INT32 thermal_id; -}; - -struct protect_flags_type{ - - BOOL is_charging_enable_available; - BOOL is_charging_high_current_avaialble; - BOOL is_charging_indicator_available; - BOOL is_battery_dead; -#if 0 - BOOL is_battery_overtemp; -#endif - BOOL is_fake_room_temp; -}; - -/* ds2746 register definition*/ - -#define DS2746_STATUS_PORF (1 << 6) /* write to 0 as power-up sequence ready*/ -#define DS2746_STATUS_SMOD (1 << 5) /* write to 0 to disable DS2746 sleep mode*/ -#define DS2746_STATUS_NBEN (1 << 4) /* write to 0 to disable blanking of negative currents*/ -#define DS2746_STATUS_AIN0 (1 << 0) -#define DS2746_STATUS_AIN1 (1 << 1) - -/* function prototypes*/ - -void battery_capacity_update(struct battery_type *battery, int capacity_01p); -BOOL battery_param_update(struct battery_type *battery, struct protect_flags_type *flags); -DWORD BAHW_MyGetMSecs(void); -void battery_param_init(struct battery_type *battery); - -#endif /* __BATT_PARAM_H__*/ diff --git a/include/linux/ds2746_param_config.h b/include/linux/ds2746_param_config.h deleted file mode 100644 index ff77356e..00000000 --- a/include/linux/ds2746_param_config.h +++ /dev/null @@ -1,274 +0,0 @@ -/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - -Copyright (c) 2010 High Tech Computer Corporation - -Module Name: - - ds2746_param_config.c - -Abstract: - - This module tells batt_param.c module what the battery characteristic is. - And also which charger/gauge component hardware uses, to decide if software/hardware function is available. - -Original Auther: - - Andy.ys Wang June-01-2010 - ----------------------------------------------------------------------------------*/ - - -#ifndef __BATT_PARAM_CONFIG_H__ -#define __BATT_PARAM_CONFIG_H__ -#define HTC_BATT_BOARD_NAME "ACE" - -/*======================================================================================== - -battery parameter defines (depend on board design) - -========================================================================================*/ - -static BOOL support_ds2746_gauge_ic = TRUE; - -enum BATTERY_ID_ENUM { - BATTERY_ID_UNKNOWN = 0, - BATTERY_ID_SONY_1300MAH_FORMOSA, - BATTERY_ID_SONY_1300MAH_HTE, - BATTERY_ID_SANYO_1300MAH_HTE, - BATTERY_ID_SANYO_1300MAH_TWS, - BATTERY_ID_NUM /* include unknown battery*/ -}; - -UINT32 ID_RANGE[] = -{ - /* id resister range = [min, max)*/ - 7150, 15500, /* Sony 1300mAh (Formosa) */ /* 7.1k~15k */ - 27500, 49500, /* Sony 1300mAh (HTE) */ /* 28k~49.5k */ - 15500, 27500, /* Sanyo 1300mAh (HTE) */ /* 16k~27k */ - 0, 7150, /* Samsung 1230mAh */ /* 0k~7k */ -}; - -/*This table is calculated according to temp formula for temp mapping. -If temp_adc is located on 0-95, then the temp_01c is 700. - 96-99, then the temp_01c is 690. - 100-102, then the temp_01c is 680. - ... - 1117777777-1145, then the temp_01c is 0. - 1146-1175, then the temp_01c is -1. - ... - 1433-2046, then the temp_01c is -11. -*/ -UINT32 TEMP_MAP_300K[] = -{ -0, 96, 100, 103, 107, 111, 115, 119, 123, 127, -133, 137, 143, 148, 154, 159, 165, 172, 178, 185, -192, 199, 207, 215, 223, 232, 241, 250, 260, 270, -280, 291, 301, 314, 326, 339, 352, 366, 380, 394, -410, 425, 442, 458, 476, 494, 512, 531, 551, 571, -592, 614, 636, 659, 682, 706, 730, 755, 780, 806, -833, 860, 887, 942, 943, 971, 1000, 1028, 1058, 1087, -1117, 1146, 1176, 1205, 1234, 1264, 1293, 1321, 1350, 1378, -1406, 1433, 2047, -}; - -UINT32 TEMP_MAP_1000K[] = -{ -0, 30, 31, 32, 34, 35, 36, 38, 39, 40, -42, 44, 45, 47, 49, 51, 53, 55, 57, 60, -62, 64, 67, 70, 73, 76, 79, 82, 86, 89, -93, 97, 101, 106, 111, 115, 120, 126, 131, 137, -143, 150, 156, 163, 171, 178, 187, 195, 204, 213, -223, 233, 244, 255, 267, 279, 292, 306, 320, 334, -350, 365, 382, 399, 418, 436, 456, 476, 497, 519, -542, 566, 590, 615, 641, 668, 695, 723, 752, 782, -812, 843, 2047, -}; - -UINT32 *TEMP_MAP = TEMP_MAP_300K; - -UINT32 FL_25[] = -{ - 1280, /* Unknown battery */ - 1280, /* Sony 1300mAh (Formosa) */ - 1280, /* Sony 1300mAh (HTE) */ - 1250, /* Sanyo 1300mAh (HTE) */ - 1230, /* Samsung 1230mAh */ -}; - -UINT32 PD_M_COEF[] = -{ - /* for TAO PMA, this is defined as PD_M; for TPE PMA, this is defined as FT or t*/ - 24, /* Unknown battery */ - 24, /* Sony 1300mAh (Formosa) */ - 24, /* Sony 1300mAh (HTE) */ - 27, /* Sanyo 1300mAh (HTE) */ - 30, /* Samsung 1230mAh */ -}; - -UINT32 PD_M_RESL[] = -{ - /* for TAO PMA, this is defined as PD_M; for TPE PMA, this is defined as FT or t*/ - 100, /* Unknown battery */ - 100, /* Sony 1300mAh (Formosa) */ - 100, /* Sony 1300mAh (HTE) */ - 100, /* Sanyo 1300mAh (HTE) */ - 100, /* Samsung 1230mAh */ -}; - -UINT32 PD_T_COEF[] = -{ - /* Ex: 140 -> 0.014, 156 -> 0.0156*/ - 140, /* Unknown battery */ - 140, /* Sony 1300mAh (Formosa) */ - 140, /* Sony 1300mAh (HTE) */ - 156, /* Sanyo 1300mAh (HTE) */ - 250, /* Samsung 1230mAh */ -}; - -/*! star_lee 20100426 - update KADC discharge parameter */ -UINT32 M_PARAMETER_SONY_1300MAH_FORMOSA[] = -{ - /* capacity (in 0.01%) -> voltage (in mV)*/ - 10000, 4100, 5500, 3839, 2400, 3759, 400, 3667, 0, 3397, -}; - -UINT32 M_PARAMETER_Samsung_1230MAH_FORMOSA[] = -{ - /* capacity (in 0.01%) -> voltage (in mV)*/ - 10000, 4135, 7500, 3960, 4700, 3800, 1700, 3727, 900, 3674, 300, 3640, 0, 3420, -}; - -UINT32 *M_PARAMTER_TABLE[] = -{ - /* Unknown battery */ - (UINT32 *) (M_PARAMETER_SONY_1300MAH_FORMOSA), - /* same as Sony 1300mAh (Formosa) currently... */ - /* Sony 1300mAh (Formosa) */ - (UINT32 *) (M_PARAMETER_SONY_1300MAH_FORMOSA), - /* Sony 1300mAh (HTE) */ - (UINT32 *) (M_PARAMETER_SONY_1300MAH_FORMOSA), - /* same as Sony 1300mAh (Formosa) currently... */ - /* Sanyo 1300mAh (HTE) */ - (UINT32 *) (M_PARAMETER_SONY_1300MAH_FORMOSA), - /* same as Sony 1300mAh (Formosa) currently... */ - /* Samsung 1230mAh */ - (UINT32 *) (M_PARAMETER_Samsung_1230MAH_FORMOSA), - /* same as Sony 1300mAh (Formosa) currently... */ -}; - -INT32 TEMP_RANGE[] = -{ - /* mapping temp to temp_index*/ - 200, /* ~20C */ - 100, /* 20~10C */ - 50, /* 10~5C */ - 0, /* 5~0C */ -5, /* 0~-5C */ -10, /* -5~-10C */ -3000, - /* -10C~ */ -}; - -UINT32 *PD_M_COEF_TABLE_BOOT[] = -{ - /* mapping current to pd_m_coef table when booting*/ - (UINT32 *) (PD_M_COEF), /* ~20C, using PD_M_COEF */ - (UINT32 *) (PD_M_COEF), /* 20~10C, using PD_M_COEF */ - (UINT32 *) (PD_M_COEF), /* 10~5C, using PD_M_COEF */ - (UINT32 *) (PD_M_COEF), /* 5~0C, using PD_M_COEF */ - (UINT32 *) (PD_M_COEF), /* 0~-5C, using PD_M_COEF */ - (UINT32 *) (PD_M_COEF), /* -5~-10C, using PD_M_COEF */ - (UINT32 *) (PD_M_COEF), /* -10C~, using PD_M_COEF */ -}; - -UINT32 *PD_M_COEF_TABLE[] = -{ - /* mapping current to pd_m_coef table*/ - (UINT32 *) (PD_M_COEF), /* ~20C, using PD_M_COEF */ - (UINT32 *) (PD_M_COEF), /* 20~10C, using PD_M_COEF */ - (UINT32 *) (PD_M_COEF), /* 10~5C, using PD_M_COEF */ - (UINT32 *) (PD_M_COEF), /* 5~0C, using PD_M_COEF */ - (UINT32 *) (PD_M_COEF), /* 0~-5C, using PD_M_COEF */ - (UINT32 *) (PD_M_COEF), /* -5~-10C, using PD_M_COEF */ - (UINT32 *) (PD_M_COEF), /* -10C~, using PD_M_COEF */ -}; - -UINT32 *PD_M_RESL_TABLE_BOOT[] = -{ - /* mapping current to pd_m_coef table when booting*/ - (UINT32 *) (PD_M_RESL), /* ~20C, using PD_M_RESL */ - (UINT32 *) (PD_M_RESL), /* 20~10C, using PD_M_RESL */ - (UINT32 *) (PD_M_RESL), /* 10~5C, using PD_M_RESL */ - (UINT32 *) (PD_M_RESL), /* 5~0C, using PD_M_RESL */ - (UINT32 *) (PD_M_RESL), /* 0~-5C, using PD_M_RESL */ - (UINT32 *) (PD_M_RESL), /* -5~-10C, using PD_M_RESL */ - (UINT32 *) (PD_M_RESL), /* -10C~, using PD_M_RESL */ -}; - -UINT32 *PD_M_RESL_TABLE[] = -{ - /* mapping current to pd_m_coef table*/ - (UINT32 *) (PD_M_RESL), /* ~20C, using PD_M_RESL */ - (UINT32 *) (PD_M_RESL), /* 20~10C, using PD_M_RESL */ - (UINT32 *) (PD_M_RESL), /* 10~5C, using PD_M_RESL */ - (UINT32 *) (PD_M_RESL), /* 5~0C, using PD_M_RESL */ - (UINT32 *) (PD_M_RESL), /* 0~-5C, using PD_M_RESL */ - (UINT32 *) (PD_M_RESL), /* -5~-10C, using PD_M_RESL */ - (UINT32 *) (PD_M_RESL), /* -10C~, using PD_M_RESL */ -}; - -UINT32 CAPACITY_DEDUCTION_01p[] = -{ - 0, /* ~20C, upper capacity 100 is usable */ - 0, /* 20~10C, upper capacity 95 is usable */ - 0, /* 10~5C, upper capacity 92 is usable */ - 0, /* 5~0C, upper capacity 90 is usable */ - 0, /* 0~-5C, upper capacity 87 is usable */ - 0, /* -5~-10C, upper capacity 85 is usable */ - 0, /* -10C~, upper capacity 85 is usable */ -}; - -/*======================================================================================== - -battery formula coef definition, can be re-programable - -========================================================================================*/ - -/* adc converter*/ - -static INT32 voltage_adc_to_mv_coef = 244; -static INT32 voltage_adc_to_mv_resl = 100; -static INT32 current_adc_to_mv_coef = 625; -static INT32 current_adc_to_mv_resl = 1580; -static INT32 discharge_adc_to_mv_coef = 625; -static INT32 discharge_adc_to_mv_resl = 1580; -static INT32 acr_adc_to_mv_coef = 625; -static INT32 acr_adc_to_mv_resl = 1580; -static INT32 charge_counter_zero_base_mAh = 500; - -static INT32 id_adc_resl = 2047; -static INT32 temp_adc_resl = 2047; - -/* kadc parameter*/ - -static INT32 pd_m_bias_mA; /* the bias current when calculating pd_m*/ - -/* over temperature algorithm*/ - -static INT32 over_high_temp_lock_01c = 450; -static INT32 over_high_temp_release_01c = 420; -static INT32 over_low_temp_lock_01c; /*over_low_temp_lock_01c = 0*/ -static INT32 over_low_temp_release_01c = 30; - -/* function config*/ - -static BOOL is_allow_batt_id_change = FALSE; - -/*boot up voltage*/ - -/*dead battery is voltage < M_0*/ -#define BATTERY_DEAD_VOLTAGE_LEVEL 3420 -#define BATTERY_DEAD_VOLTAGE_RELEASE 3450 - -#define TEMP_MAX 70 -#define TEMP_MIN -11 -#define TEMP_NUM 83 - -#endif diff --git a/include/linux/tps65200.h b/include/linux/tps65200.h deleted file mode 100644 index 6048cecb..00000000 --- a/include/linux/tps65200.h +++ /dev/null @@ -1,23 +0,0 @@ -/* - * Copyright (C) 2007 HTC Incorporated - * - * This software is licensed under the terms of the GNU General Public - * License version 2, as published by the Free Software Foundation, and - * may be copied, distributed, and modified under those terms. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - */ -#ifndef _TPS65200_H_ -#define _TPS65200_H_ -#include -#include - -#ifdef CONFIG_TPS65200 -extern int tps_set_charger_ctrl(u32 ctl); -#else -static int tps_set_charger_ctrl(u32 ctl) {return 0 ; } -#endif -#endif diff --git a/include/linux/wrapper_types.h b/include/linux/wrapper_types.h deleted file mode 100644 index 742755fe..00000000 --- a/include/linux/wrapper_types.h +++ /dev/null @@ -1,92 +0,0 @@ -#ifndef __WRAPPER_TYPES_H_ -#define __WRAPPER_TYPES_H_ - -#define DRIVER_ZONE "[D:BATT]" -#define DRIVER_BATTERY (1<<9) - -/* The left side of these typedefs are machine and compiler dependent */ -typedef signed char INT8; -typedef unsigned char UINT8; -typedef signed short INT16; -typedef unsigned short UINT16; -typedef signed int INT32; -typedef unsigned int UINT32; -typedef struct _INT64{ - - UINT32 u0, u1, u2; INT32 u3; -} INT64; -typedef struct _UINT64{ - - UINT32 u0, u1, u2, u3; -} UINT64; -typedef struct _INT128{ - - UINT32 u0, u1, u2; INT32 u3; -} INT128; -typedef struct _UINT128{ - - UINT32 u0, u1, u2, u3; -} UINT128; - -typedef INT8 * PINT8; -typedef UINT8 *PUINT8; -typedef INT16 * PINT16; -typedef UINT16 * PUINT16; -typedef INT32 *PINT32; -typedef UINT32 *PUINT32; -typedef INT64 * PINT64; -typedef UINT64 * PUINT64; -typedef INT128 * PINT128; -typedef UINT128 * PUINT128; -typedef const void *PCVOID; -typedef void **PPVOID; -/*typedef unsigned char uchar;*/ -typedef void (*PFNVOID)( void); -typedef char CHAR; -typedef UINT8 BYTE; -typedef UINT8 UCHAR; -typedef UINT32 ULONG; -typedef INT32 LONG; -typedef UINT32 DWORD; -typedef UINT32 UINT; -typedef UINT32 BOOL; -typedef UINT16 WORD; -typedef UINT16 USHORT; -typedef INT32 INT; -typedef void *LPVOID; -typedef void *PVOID; -typedef void VOID; -typedef void *HLOCAL; -typedef CHAR * LPCHAR; -typedef CHAR * PBYTE; -typedef INT16 * LPCWSTR; -typedef UINT8 *LPTSTR; -typedef UINT8 *LPCSTR; -typedef UINT8 *LPCTSTR; -typedef BYTE * LPBYTE; -typedef DWORD *LPDWORD; -typedef DWORD *PDWORD; -typedef CHAR TCHAR; -typedef UINT32 HINSTANCE; -typedef UINT32 HKEY; -typedef UINT32 HMODULE; -typedef UINT32 FARPROC; -typedef UINT32 HRESULT; -typedef UINT32 HREGNOTIFY; -typedef UINT32 LPSTARTUPINFO; -typedef UINT32 LPPROCESS_INFORMATION; -typedef UINT32 REGISTRYNOTIFYCALLBACK; -typedef UINT32 NOTIFICATIONCONDITION; -typedef UINT32 REGSAM; -typedef UINT32 PHKEY; - -#define FALSE 0 -#define TRUE 1 -#define INFINITE 0x7fffffffffffffffL - -#define MAKEWORD(a, b) ((WORD)(((BYTE)(a)) | ((WORD)((BYTE)(b))) << 8)) -#define LOBYTE(w) ((BYTE)(w)) -#define HIBYTE(w) ((BYTE)(((WORD)(w) >> 8) & 0xFF)) -#define CEILING(n, precision) ((n+precision-1)/precision) /* ex: CEILING(989, 10)=99, means 98.9 mapping to 99*/ - -#endif From 0eba6e9d4d68617319db33acff62b0c8a95934d5 Mon Sep 17 00:00:00 2001 From: Markinus Date: Sun, 14 Nov 2010 18:26:50 +0100 Subject: [PATCH 07/10] htcleo: Back to our old battery driver. We have to find some stuff more about our battery to get it real good wrokring. Revert "htcleo: fixed USB charging problems in some configurations and cleanups" This reverts commit d28b1aa6d6f204a9184c06631228241593960a39. Conflicts: arch/arm/mach-msm/board-htcleo.c --- arch/arm/mach-msm/htc_battery.c | 15 +-- .../include/mach/board-htcleo-battery.h | 102 ++++++++++++++++++ arch/arm/mach-msm/include/mach/htc_battery.h | 1 - 3 files changed, 104 insertions(+), 14 deletions(-) create mode 100644 arch/arm/mach-msm/include/mach/board-htcleo-battery.h diff --git a/arch/arm/mach-msm/htc_battery.c b/arch/arm/mach-msm/htc_battery.c index fbb717a8..4ca27764 100644 --- a/arch/arm/mach-msm/htc_battery.c +++ b/arch/arm/mach-msm/htc_battery.c @@ -112,7 +112,6 @@ struct htc_battery_info { int gpio_usb_id; int gpio_mchg_en_n; int gpio_iset; - int gpio_power; int guage_driver; int m2a_cable_detect; int charger; @@ -336,20 +335,10 @@ static int init_batt_gpio(void) if (htc_batt_info.gpio_mchg_en_n > 0 && gpio_request(htc_batt_info.gpio_mchg_en_n, "charger_en") < 0) goto gpio_failed; - else - gpio_direction_output(htc_batt_info.gpio_mchg_en_n, 1); if (htc_batt_info.gpio_iset > 0 && gpio_request(htc_batt_info.gpio_iset, "charge_current") < 0) goto gpio_failed; - else - gpio_direction_output(htc_batt_info.gpio_iset, 1); - if (htc_batt_info.gpio_power > 0 && - gpio_request(htc_batt_info.gpio_power, "usb_power") < 0) - goto gpio_failed; - else - gpio_direction_output(htc_batt_info.gpio_power, 0); - return 0; gpio_failed: @@ -365,6 +354,7 @@ gpio_failed: int battery_charging_ctrl(enum batt_ctl_t ctl) { int result = 0; + if (!htc_battery_initial) return 0; switch (ctl) { @@ -1573,10 +1563,9 @@ static struct notifier_block ds2784_notifier = { static int htc_battery_probe(struct platform_device *pdev) { struct htc_battery_platform_data *pdata = pdev->dev.platform_data; - + htc_batt_info.device_id = pdev->id; htc_batt_info.gpio_usb_id = pdata->gpio_usb_id; - htc_batt_info.gpio_power = pdata->gpio_power; htc_batt_info.guage_driver = pdata->guage_driver; htc_batt_info.m2a_cable_detect = pdata->m2a_cable_detect; htc_batt_info.func_show_batt_attr = pdata->func_show_batt_attr; diff --git a/arch/arm/mach-msm/include/mach/board-htcleo-battery.h b/arch/arm/mach-msm/include/mach/board-htcleo-battery.h new file mode 100644 index 00000000..bc7c9ec2 --- /dev/null +++ b/arch/arm/mach-msm/include/mach/board-htcleo-battery.h @@ -0,0 +1,102 @@ +#ifndef __LEO_BATTERY__ +#define __LEO_BATTERY__ + +#include + +#define LEO_BATTERY_CAPACITY 1230 +#define LEO_BATTERY_EMPTY 500 + +// from board-htcleo-power.c +extern int is_ac_power_supplied(void); + +// from board-htcleo-log.c +extern double log(double x); + +#define RAW_DATA_SIZE 10 + + +struct battery_status +{ + int timestamp; + + int voltage_uV; /* units of uV */ + int current_uA; /* units of uA */ + int current_avg_uA; + int charge_uAh; + + s16 temp_C; /* units of 0.1 C */ + + u8 percentage; /* battery percentage */ + u8 charge_source; + u8 status_reg; + u8 battery_full; /* battery full (don't charge) */ + + u8 cooldown; /* was overtemp */ + u8 charge_mode; +} __attribute__((packed)); + + +#define SOURCE_NONE 0 +#define SOURCE_USB 1 +#define SOURCE_AC 2 + +#define CHARGE_OFF 0 +#define CHARGE_SLOW 1 +#define CHARGE_FAST 2 + +#define TEMP_CRITICAL 600 /* no charging at all */ +#define TEMP_HOT 500 /* no fast charge, no charge > 4.1v */ +#define TEMP_WARM 450 /* no fast charge above this */ + +#define TEMP_HOT_MAX_MV 4100 /* stop charging here when hot */ +#define TEMP_HOT_MIN_MV 3800 /* resume charging here when hot */ +#define CE_DISABLE_MIN_MV 4100 + + +/* When we're awake or running on wall power, sample the battery +* gauge every FAST_POLL seconds. If we're asleep and on battery +* power, sample every SLOW_POLL seconds +*/ +#define FAST_POLL (1 * 60) +#define SLOW_POLL (10 * 60) + + +struct htcleo_device_info +{ + struct device *dev; + + /* DS2784 data, valid after calling htcleo_battery_read_status() */ + char raw[RAW_DATA_SIZE]; /* raw HTCLEO data */ + uint32_t raw_status; + + struct battery_status status; + + struct power_supply bat; + struct workqueue_struct *monitor_wqueue; + struct work_struct monitor_work; + struct alarm alarm; + struct wake_lock work_wake_lock; + + // int (*charge)(int on, int fast); + // struct w1_slave *w1_slave; + struct i2c_client *client; + + u8 dummy; /* dummy battery flag */ + u8 last_charge_mode; /* previous charger state */ + u8 slow_poll; + + ktime_t last_poll; + ktime_t last_charge_seen; +}; + +static struct htcleo_device_info * mydi = NULL; + +#define psy_to_dev_info(x) container_of((x), struct htcleo_device_info, bat) + +static struct wake_lock vbus_wake_lock; + + +#define to_htcleo_device_info(x) container_of((x), struct htcleo_device_info, bat); + +#endif + diff --git a/arch/arm/mach-msm/include/mach/htc_battery.h b/arch/arm/mach-msm/include/mach/htc_battery.h index 7a7edc5f..9b1b4d0e 100644 --- a/arch/arm/mach-msm/include/mach/htc_battery.h +++ b/arch/arm/mach-msm/include/mach/htc_battery.h @@ -74,7 +74,6 @@ struct htc_battery_platform_data { int gpio_usb_id; int gpio_mchg_en_n; int gpio_iset; - int gpio_power; int guage_driver; int m2a_cable_detect; int charger; From 3a4df97971ef6eb5d9dbeb68412f35669949ae03 Mon Sep 17 00:00:00 2001 From: Markinus Date: Sun, 14 Nov 2010 19:54:46 +0100 Subject: [PATCH 08/10] htcleo: removed the fix firmware in kgsl 3d driver. We can use now the yamato_xxx.fw files. Revert "htcleo: fix hw3d hardcoding firmware in kernel" This reverts commit d3a4673828a030e6f2f3848ae54f4580d762a4e1. --- drivers/video/msm/gpu/kgsl/kgsl_ringbuffer.c | 696 +------------------ 1 file changed, 2 insertions(+), 694 deletions(-) diff --git a/drivers/video/msm/gpu/kgsl/kgsl_ringbuffer.c b/drivers/video/msm/gpu/kgsl/kgsl_ringbuffer.c index 89dd24e5..472d10c1 100644 --- a/drivers/video/msm/gpu/kgsl/kgsl_ringbuffer.c +++ b/drivers/video/msm/gpu/kgsl/kgsl_ringbuffer.c @@ -63,671 +63,6 @@ inline unsigned int kgsl_ringbuffer_sizelog2quadwords(unsigned int sizedwords) return sizelog2quadwords; } -#if defined(CONFIG_MACH_HTCLEO) -// +Cotulla hack -#ifndef ARRAYSIZE -#define ARRAYSIZE(a) (sizeof(a)/sizeof(a[0])) -#endif - -unsigned char fw_yamato_pfp[1156] = -{ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0xC6, 0x00, 0x4B, 0x42, 0x7E, 0x00, 0x00, 0x00, 0xA0, 0x00, - 0x8B, 0x82, 0x7E, 0x00, 0x01, 0x00, 0x80, 0x00, 0x00, 0x04, 0xC6, 0x00, 0x03, 0x40, 0xCC, 0x00, - 0x00, 0x00, 0x80, 0x00, 0x03, 0x00, 0xD6, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x2C, 0xC6, 0x00, - 0x35, 0x0C, 0xC8, 0x00, 0x00, 0xC0, 0x98, 0x00, 0x35, 0x0C, 0xC8, 0x00, 0x00, 0x00, 0x88, 0x00, - 0x1D, 0x0C, 0xC8, 0x00, 0x0B, 0x00, 0x84, 0x00, 0x00, 0x08, 0xC6, 0x00, 0x07, 0xC0, 0x98, 0x00, - 0x00, 0x10, 0xC6, 0x00, 0x03, 0x80, 0x97, 0x00, 0x03, 0x40, 0xCC, 0x00, 0x04, 0x00, 0xD6, 0x00, - 0x00, 0x00, 0x80, 0x00, 0x03, 0x00, 0xCD, 0x00, 0x00, 0x00, 0x80, 0x00, 0x1F, 0x00, 0xD6, 0x00, - 0x0B, 0x00, 0x84, 0x00, 0x00, 0x08, 0xC6, 0x00, 0x0C, 0xC0, 0x98, 0x00, 0x00, 0x10, 0xC6, 0x00, - 0x03, 0x40, 0xCC, 0x00, 0x00, 0x14, 0xC6, 0x00, 0x00, 0x18, 0xC6, 0x00, 0x40, 0x6D, 0x7D, 0x00, - 0x1E, 0x40, 0xCD, 0x00, 0x03, 0x80, 0x97, 0x00, 0x1E, 0x80, 0xCD, 0x00, 0x04, 0x00, 0xD6, 0x00, - 0x00, 0x00, 0x80, 0x00, 0x03, 0x00, 0xCD, 0x00, 0x00, 0x00, 0x80, 0x00, 0x1F, 0x00, 0xD6, 0x00, - 0x0B, 0x00, 0x84, 0x00, 0x00, 0x08, 0xC6, 0x00, 0x07, 0xC0, 0x98, 0x00, 0x00, 0x0C, 0xC6, 0x00, - 0x03, 0x40, 0xCC, 0x00, 0x03, 0x80, 0xCC, 0x00, 0x03, 0xC0, 0xCC, 0x00, 0x00, 0x00, 0x80, 0x00, - 0x03, 0x00, 0xD6, 0x00, 0x00, 0x00, 0x80, 0x00, 0x1F, 0x00, 0xD6, 0x00, 0x00, 0x08, 0xC6, 0x00, - 0x08, 0x8C, 0x34, 0x00, 0x06, 0xC0, 0x98, 0x00, 0x1E, 0x0C, 0xC8, 0x00, 0x00, 0xC0, 0x98, 0x00, - 0x1E, 0x0C, 0xC8, 0x00, 0x3F, 0x00, 0x80, 0x00, 0x07, 0x80, 0xCC, 0x00, 0x08, 0x80, 0xCC, 0x00, - 0x03, 0x40, 0xCC, 0x00, 0x00, 0x00, 0x80, 0x00, 0x03, 0x80, 0xCC, 0x00, 0x00, 0x04, 0xC6, 0x00, - 0x07, 0x9C, 0x1A, 0x00, 0x21, 0x88, 0xCA, 0x00, 0xBB, 0xC3, 0x95, 0x00, 0x2C, 0x10, 0xC8, 0x00, - 0x0A, 0x80, 0x98, 0x00, 0x18, 0x94, 0x32, 0x00, 0x04, 0x40, 0x9A, 0x00, 0x10, 0x68, 0xCC, 0x00, - 0x01, 0x24, 0x04, 0x00, 0x43, 0x01, 0xD0, 0x00, 0x62, 0x01, 0xD0, 0x00, 0x02, 0x00, 0xCD, 0x00, - 0x4C, 0x51, 0x7D, 0x00, 0x03, 0x40, 0xCD, 0x00, 0x07, 0x80, 0x9B, 0x00, 0x01, 0xA8, 0x06, 0x00, - 0x03, 0x40, 0x96, 0x00, 0x00, 0x80, 0xC2, 0x00, 0x03, 0x40, 0xCF, 0x00, 0x01, 0x00, 0x80, 0x00, - 0x00, 0x04, 0xC6, 0x00, 0x43, 0x00, 0x80, 0x00, 0x00, 0x04, 0xC6, 0x00, 0x01, 0x00, 0x80, 0x00, - 0x00, 0x04, 0xC6, 0x00, 0x00, 0x08, 0xC6, 0x00, 0x00, 0x0C, 0xC6, 0x00, 0x2D, 0x10, 0xC8, 0x00, - 0x02, 0x94, 0x34, 0x00, 0x0B, 0x00, 0x99, 0x00, 0x2E, 0x18, 0xC8, 0x00, 0x02, 0x40, 0xCD, 0x00, - 0x02, 0x80, 0xCD, 0x00, 0xE3, 0x01, 0xD0, 0x00, 0xC3, 0x01, 0xD0, 0x00, 0x03, 0xC0, 0xCC, 0x00, - 0x1C, 0x80, 0xCC, 0x00, 0x1D, 0x80, 0xCD, 0x00, 0x01, 0x00, 0x80, 0x00, 0x00, 0x04, 0xC6, 0x00, - 0x03, 0x02, 0xD0, 0x00, 0x00, 0x00, 0x80, 0x00, 0xC3, 0x01, 0xD0, 0x00, 0x1F, 0x08, 0xC8, 0x00, - 0x00, 0x0C, 0xC6, 0x00, 0x20, 0x0C, 0xC8, 0x00, 0x00, 0x80, 0x98, 0x00, 0x1F, 0x08, 0xC8, 0x00, - 0x03, 0x40, 0xCC, 0x00, 0x03, 0xC0, 0xCC, 0x00, 0x03, 0x00, 0xD6, 0x00, 0x22, 0xC0, 0xCC, 0x00, - 0x1F, 0x00, 0xCC, 0x00, 0x00, 0x00, 0x80, 0x00, 0x1F, 0x00, 0xCC, 0x00, 0x2F, 0x1C, 0xC8, 0x00, - 0x00, 0x04, 0xC6, 0x00, 0x00, 0x08, 0xC6, 0x00, 0x00, 0x0C, 0xC6, 0x00, 0x30, 0x10, 0xC8, 0x00, - 0x00, 0xC0, 0x99, 0x00, 0x2F, 0x1C, 0xC8, 0x00, 0x21, 0x80, 0xCC, 0x00, 0x20, 0x40, 0xCC, 0x00, - 0x11, 0x00, 0x99, 0x00, 0xFF, 0x07, 0xC1, 0x00, 0x23, 0x02, 0xD0, 0x00, 0x43, 0x02, 0xD0, 0x00, - 0x02, 0x54, 0x34, 0x00, 0x8B, 0xB1, 0x7C, 0x00, 0xCC, 0x95, 0x7D, 0x00, 0x02, 0xC0, 0xCD, 0x00, - 0x02, 0xC0, 0xCC, 0x00, 0x63, 0x02, 0xD0, 0x00, 0x05, 0x80, 0x97, 0x00, 0x03, 0xC0, 0xCC, 0x00, - 0x00, 0x08, 0xC6, 0x00, 0x88, 0x00, 0x80, 0x00, 0x00, 0x0C, 0xC6, 0x00, 0x00, 0x00, 0x80, 0x00, - 0x83, 0x02, 0xD0, 0x00, 0x6D, 0x83, 0x97, 0x00, 0x00, 0x04, 0xC6, 0x00, 0x1F, 0x00, 0xD6, 0x00, - 0x01, 0x00, 0x80, 0x00, 0x00, 0x04, 0xC6, 0x00, 0x0D, 0x00, 0xD2, 0x00, 0x0D, 0x00, 0xCC, 0x00, - 0x00, 0x00, 0x80, 0x00, 0x0D, 0x00, 0xCC, 0x00, 0x00, 0x08, 0xC6, 0x00, 0x00, 0x0C, 0xC6, 0x00, - 0x33, 0x14, 0xCA, 0x00, 0xA0, 0x22, 0xD0, 0x00, 0x00, 0xE0, 0xCC, 0x00, 0x5E, 0x43, 0x99, 0x00, - 0x05, 0xE0, 0xCC, 0x00, 0x00, 0x00, 0x80, 0x00, 0x01, 0x20, 0x06, 0x00, 0x00, 0x08, 0xC6, 0x00, - 0x00, 0x0C, 0xC6, 0x00, 0xC3, 0x02, 0xD2, 0x00, 0x03, 0x80, 0xCC, 0x00, 0x03, 0xC0, 0xCC, 0x00, - 0x27, 0xE0, 0xCC, 0x00, 0x00, 0x00, 0x80, 0x00, 0x01, 0x20, 0x06, 0x00, 0x31, 0x08, 0xCA, 0x00, - 0xFF, 0x83, 0x98, 0x00, 0x31, 0x08, 0xCA, 0x00, 0x1F, 0x00, 0xD6, 0x00, 0x01, 0x00, 0x80, 0x00, - 0x00, 0x04, 0xC6, 0x00, 0x01, 0x20, 0x0A, 0x00, 0x01, 0x00, 0x80, 0x00, 0x00, 0x04, 0xC6, 0x00, - 0x09, 0x00, 0xD2, 0x00, 0x0A, 0x00, 0xD2, 0x00, 0x1F, 0x00, 0xCC, 0x00, 0x00, 0x00, 0x80, 0x00, - 0x1F, 0x00, 0xCC, 0x00, 0x0B, 0x00, 0xD2, 0x00, 0x0C, 0x00, 0xD2, 0x00, 0x1F, 0x00, 0xCC, 0x00, - 0x00, 0x00, 0x80, 0x00, 0x1F, 0x00, 0xCC, 0x00, 0x23, 0x00, 0xCC, 0x00, 0x03, 0x40, 0xCC, 0x00, - 0x03, 0x00, 0xCE, 0x00, 0x00, 0x00, 0x80, 0x00, 0x03, 0x00, 0xD6, 0x00, 0x03, 0x03, 0xD0, 0x00, - 0x24, 0x00, 0xCC, 0x00, 0x03, 0x40, 0xCC, 0x00, 0x00, 0x00, 0x80, 0x00, 0x03, 0x00, 0xD6, 0x00, - 0x23, 0x03, 0xD0, 0x00, 0x25, 0x00, 0xCC, 0x00, 0x03, 0x40, 0xCC, 0x00, 0x00, 0x00, 0x80, 0x00, - 0x03, 0x00, 0xD6, 0x00, 0x43, 0x03, 0xD0, 0x00, 0x26, 0x00, 0xCC, 0x00, 0x03, 0x40, 0xCC, 0x00, - 0x00, 0x00, 0x80, 0x00, 0x03, 0x00, 0xD6, 0x00, 0x00, 0x00, 0x80, 0x00, 0x1F, 0x00, 0xD6, 0x00, - 0x01, 0x04, 0x28, 0x00, 0x01, 0x00, 0xD2, 0x00, 0x00, 0x10, 0xC6, 0x00, 0x00, 0x14, 0xC6, 0x00, - 0x01, 0x40, 0xCC, 0x00, 0x06, 0x40, 0xCC, 0x00, 0xFA, 0x00, 0x84, 0x00, 0x02, 0x08, 0xC4, 0x00, - 0x02, 0x00, 0xC4, 0x00, 0x15, 0x80, 0x94, 0x00, 0x2B, 0x40, 0xCC, 0x00, 0x01, 0x00, 0xCD, 0x00, - 0x01, 0x40, 0xCC, 0x00, 0x06, 0x40, 0xCC, 0x00, 0xFA, 0x00, 0x84, 0x00, 0x02, 0x08, 0xC4, 0x00, - 0x02, 0x00, 0xC4, 0x00, 0x00, 0x80, 0xC2, 0x00, 0xC7, 0x48, 0x7D, 0x00, 0x07, 0xC0, 0x94, 0x00, - 0xC1, 0x48, 0x7D, 0x00, 0xC4, 0xF4, 0x7C, 0x00, 0x08, 0xC0, 0x94, 0x00, 0x2B, 0x40, 0xCC, 0x00, - 0x00, 0x00, 0x80, 0x00, 0x1F, 0x00, 0xD2, 0x00, 0xC4, 0xF4, 0x7C, 0x00, 0x03, 0xC0, 0x94, 0x00, - 0x2B, 0x40, 0xCC, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x38, 0xC6, 0x00, 0xFA, 0x00, 0x84, 0x00, - 0x2B, 0x80, 0xCF, 0x00, 0x00, 0x00, 0x80, 0x00, 0x1F, 0x00, 0xD6, 0x00, 0x1F, 0x00, 0xCC, 0x00, - 0x00, 0x00, 0x88, 0x00, 0x1F, 0x00, 0xCC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xC6, 0x00, 0x01, 0x00, 0xCB, 0x00, 0x02, 0x00, 0xD0, 0x00, 0x03, 0x00, - 0x04, 0x00, 0x05, 0x00, 0xD5, 0x00, 0x10, 0x00, 0xB4, 0x00, 0x17, 0x00, 0x10, 0x00, 0x22, 0x00, - 0x36, 0x00, 0x23, 0x00, 0x42, 0x00, 0x25, 0x00, 0x5C, 0x00, 0x27, 0x00, 0x6E, 0x00, 0x2D, 0x00, - 0x7A, 0x00, 0x2E, 0x00, 0x09, 0x00, 0x4B, 0x00, 0x1B, 0x00, 0x34, 0x00, 0x2B, 0x00, 0x36, 0x00, - 0xA6, 0x00, 0x37, 0x00, 0x99, 0x00, 0x3B, 0x00, 0x9D, 0x00, 0x3F, 0x00, 0xD7, 0x00, 0x44, 0x00, - 0xC1, 0x00, 0x48, 0x00, 0xB7, 0x00, 0x50, 0x00, 0xBC, 0x00, 0x51, 0x00, 0xC7, 0x00, 0x55, 0x00, - 0xCC, 0x00, 0x56, 0x00, 0xD1, 0x00, 0x57, 0x00, 0xAE, 0x00, 0x5D, 0x00, 0xC2, 0x00, 0x5F, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, - 0x06, 0x00, 0x00, 0x00 -}; - -unsigned char fw_yamato_pm4[9220] = -{ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0xA0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF3, 0x01, 0x00, 0x00, - 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x11, 0x48, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x04, 0x00, 0x00, 0x00, - 0xFF, 0xFF, 0x00, 0x00, 0x21, 0x46, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x48, 0x00, 0xD9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x34, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x90, 0x02, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, - 0x20, 0x0A, 0x28, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0x45, 0x29, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0xD9, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x60, 0x00, 0x90, 0x02, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x20, 0x46, 0x28, 0xC0, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0xD9, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x60, 0x00, 0xAC, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x20, 0xC0, - 0x00, 0x00, 0x00, 0x00, 0xFC, 0x21, 0x00, 0x00, 0x2C, 0x46, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x03, 0x48, 0x40, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x60, 0x00, 0xAC, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0xC0, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, - 0xFC, 0x21, 0x00, 0x00, 0x2C, 0x46, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x03, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x3F, 0x00, 0x00, 0x2F, 0x02, 0x2F, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0C, 0x00, 0x00, 0x00, 0x00, - 0xFD, 0xA1, 0x00, 0x00, 0x2C, 0x46, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x48, 0x00, 0xD9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, - 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x10, 0x00, 0x00, 0x23, 0x12, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, - 0x24, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0C, - 0x00, 0x00, 0x00, 0x00, 0xF9, 0x21, 0x00, 0x00, 0x2C, 0x46, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x0E, 0x00, 0x00, 0x00, 0x11, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x94, 0x03, 0x00, 0x00, - 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x11, 0x48, 0x40, 0xC0, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0xAC, 0x02, 0x00, 0x00, - 0xF9, 0x21, 0x00, 0x00, 0x2C, 0x46, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, - 0x20, 0x0A, 0x21, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x14, - 0x2D, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x11, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x08, 0x00, 0x00, 0x00, 0x11, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, - 0x20, 0x0A, 0x28, 0x40, 0x00, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x22, 0x02, 0x2F, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0C, 0x43, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x22, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0xE0, 0x0C, 0x4A, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x22, 0x02, 0x2F, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0C, 0x51, 0x00, 0x00, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x22, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0xE0, 0x0C, 0x58, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x22, 0x02, 0x2F, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0C, 0x58, 0x00, 0x00, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x22, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0xE0, 0x0C, 0x60, 0x00, 0x00, 0x00, 0xF9, 0x21, 0x00, 0x00, 0x2C, 0x46, 0x29, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x48, 0x40, 0xC0, 0x00, 0x00, 0x00, 0x00, - 0x1F, 0x00, 0x00, 0x00, 0x20, 0x0A, 0x28, 0x40, 0x00, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, - 0x22, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0C, - 0x43, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x22, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0C, 0x4A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x40, 0x00, 0x51, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x20, 0x0E, 0x21, 0xC0, - 0x00, 0x00, 0x00, 0x00, 0x12, 0x06, 0x00, 0x00, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x03, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x48, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x20, 0xC0, - 0x00, 0x00, 0x00, 0x00, 0xF9, 0x21, 0x00, 0x00, 0x2C, 0x46, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x02, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, - 0x20, 0x0E, 0x21, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x11, 0x44, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x48, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, 0xF9, 0x21, 0x00, 0x00, 0x2C, 0x46, 0x29, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x1E, 0x00, 0x00, 0x00, 0x20, 0x0E, 0x21, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x05, 0x06, 0x00, 0x00, - 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x48, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, 0xF9, 0x21, 0x00, 0x00, - 0x2C, 0x46, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x48, 0x40, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x20, 0x0A, 0x28, 0x40, 0x00, 0x00, 0x00, 0x00, - 0x1F, 0x00, 0x00, 0x00, 0x20, 0x0E, 0x21, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x06, 0x00, 0x00, - 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x48, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, 0xF9, 0x21, 0x00, 0x00, - 0x2C, 0x46, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x48, 0x40, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x20, 0x0A, 0x68, 0xC0, 0xAC, 0x02, 0x00, 0x00, - 0xF9, 0x21, 0x00, 0x00, 0x2C, 0x46, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x02, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x81, 0x11, 0x44, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x11, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0x1F, 0x00, 0x00, 0x20, 0x0A, 0x28, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, - 0x20, 0x0E, 0x28, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x20, 0x12, 0x28, 0xC0, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x22, 0x46, 0x69, 0x00, 0xC1, 0x02, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x10, 0x14, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x23, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, - 0x6D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x40, 0xC0, 0x70, 0x00, 0x00, 0x00, - 0xFF, 0x1F, 0x00, 0x00, 0x20, 0x1A, 0x28, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, - 0x26, 0x46, 0x69, 0x00, 0xC1, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x18, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x1C, 0x40, 0xC0, 0x76, 0x00, 0x00, 0x00, 0xFF, 0x1F, 0x00, 0x00, 0x20, 0x1E, 0x28, 0xC0, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x27, 0x46, 0x69, 0x00, 0xC1, 0x02, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x10, 0x1C, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x02, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC5, 0x20, 0x28, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE8, 0x48, 0x49, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x90, 0x02, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, - 0x20, 0x0A, 0x21, 0x40, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x22, 0x0A, 0x28, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xFF, 0x07, 0x00, 0x00, 0x20, 0x0E, 0x28, 0x40, 0x00, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x23, 0x1E, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x20, 0x12, 0x21, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x24, 0x12, 0x28, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x24, 0x02, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x14, 0x84, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0xA1, - 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x48, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x2D, 0x16, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x23, 0x0E, 0x50, 0x00, - 0x97, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x22, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, 0x8C, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x2D, 0x16, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x23, 0x0E, 0x50, 0x00, - 0x97, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x22, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, 0x90, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x2D, 0x16, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, 0x00, 0x00, 0x23, 0x0E, 0x50, 0x00, - 0x97, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x22, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, 0x94, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x2D, 0x16, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x49, 0x00, 0x00, 0x23, 0x0E, 0x50, 0x00, - 0x97, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x2D, 0x16, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x20, 0x00, 0x00, 0x23, 0x0E, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x83, 0x0D, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x94, 0x11, 0x44, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE5, 0x48, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x83, 0x44, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x18, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0xD9, - 0x00, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x24, 0x02, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x14, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x94, - 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE5, 0x48, 0x29, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x93, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x60, 0x00, 0x90, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x20, 0xC0, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, - 0x1F, 0x00, 0x00, 0x00, 0x25, 0x1A, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0xE0, 0x14, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x07, 0x00, 0x00, 0x25, 0x0E, 0x28, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x25, 0x12, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0xFF, 0x00, 0x83, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x24, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, - 0xAE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x36, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x40, 0x00, 0x00, 0x23, 0x4A, 0x50, 0x00, 0xBD, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x24, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, - 0xB2, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x22, 0x36, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x48, 0x00, 0x00, 0x23, 0x4A, 0x50, 0x00, 0xBD, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x24, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, - 0xB6, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x22, 0x36, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x49, 0x00, 0x00, 0x23, 0x4A, 0x50, 0x00, 0xBD, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x24, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, - 0xBA, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x22, 0x36, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x08, 0x49, 0x00, 0x00, 0x23, 0x4A, 0x50, 0x00, 0xBD, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, - 0x22, 0x36, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x83, 0x0D, 0x29, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x23, 0x4A, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0xFF, 0x00, 0x84, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x48, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0xA4, 0x00, 0x00, 0x00, - 0xFF, 0xFF, 0x00, 0x81, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x11, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x05, 0x04, 0x00, 0x11, 0x44, 0x60, 0x00, - 0xC1, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xC0, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x10, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x20, 0xC0, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x7F, 0x00, 0x00, 0x21, 0x0A, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, - 0x22, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0C, - 0xCD, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, - 0x23, 0x0A, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x22, 0x02, 0x2F, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0C, 0xD5, 0x00, 0x00, 0x00, - 0xFF, 0xFF, 0x00, 0x81, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x11, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x24, 0x46, 0x69, 0x00, - 0xC1, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0xD6, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x3A, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xD0, 0x20, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x23, 0x0A, 0x28, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x22, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, 0xDD, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xA8, 0x00, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x04, - 0xF6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0xFD, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x22, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0xE0, 0x0A, 0xE2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA8, 0x00, 0x2F, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x02, 0xF6, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0xFD, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x22, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, - 0xE7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA8, 0x00, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0C, 0xF6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x40, 0x00, 0xFD, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x22, 0x02, 0x2F, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, 0xEC, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xA8, 0x00, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0xE0, 0x0A, 0xF6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, - 0xFD, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x22, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, 0xF1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xA8, 0x00, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x06, - 0xF6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0xFD, 0x00, 0x00, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x22, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0xE0, 0x0A, 0xF6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA8, 0x00, 0x2F, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x08, 0xF6, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0xFD, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x00, - 0x21, 0x0A, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, 0x22, 0x02, 0x2F, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, 0x00, 0x00, 0x00, 0x00, - 0x08, 0x00, 0x00, 0x00, 0x23, 0x0A, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0xE0, 0x14, 0x1B, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0x20, 0xC0, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x40, 0xC0, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x7F, 0x00, 0x00, 0x21, 0x0A, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, - 0x22, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, - 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x07, 0x4C, 0x40, 0x00, 0xCD, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x20, 0xC0, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x1C, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, - 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x81, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x11, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, - 0x24, 0x46, 0x69, 0x00, 0xC1, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD0, 0x20, 0x28, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA8, 0x00, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x07, 0x4C, 0x40, 0x00, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x20, 0xC0, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x1C, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, - 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x81, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x11, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, - 0x24, 0x46, 0x69, 0x00, 0xC1, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD0, 0x20, 0x28, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA8, 0x00, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x07, 0x4C, 0x40, 0x00, 0x13, 0x01, 0x00, 0x00, 0x0D, 0x06, 0x00, 0x00, 0x11, 0x44, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, - 0x0E, 0x86, 0x00, 0x00, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x48, 0x00, 0xD9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x81, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x09, 0x00, 0x00, 0x00, 0x11, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0D, 0x06, 0x00, 0x00, - 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x20, 0xC0, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0xFF, 0x00, 0x81, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x11, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x20, 0xC0, - 0x00, 0x00, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x00, 0x22, 0x1A, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x20, 0x00, 0x00, 0x26, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0xE0, 0x04, 0x2E, 0x01, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x26, 0x02, 0x2F, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x06, 0x2E, 0x01, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x86, 0x19, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, - 0x26, 0x46, 0x69, 0x00, 0xC1, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x0C, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x80, 0x22, 0x1A, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x26, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0C, - 0x37, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x3A, 0x01, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x10, 0x1C, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x67, 0x0C, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0D, 0x06, 0x00, 0x00, 0x11, 0x44, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x03, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x81, - 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x48, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0xA4, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x11, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xEA, 0x01, 0x00, 0x00, - 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x48, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x1A, 0x40, 0x01, 0x00, 0x00, - 0xFF, 0xFF, 0x00, 0x9E, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xEF, 0xBE, 0xAD, 0xDE, - 0x11, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x1A, - 0x43, 0x01, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0xA4, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x0B, 0x48, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF3, 0x01, 0x00, 0x00, - 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x20, 0x4A, 0x48, 0xC0, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD9, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x0C, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x8C, 0x11, 0x44, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0x0F, 0x00, 0x00, 0x23, 0x12, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, - 0x24, 0x36, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x24, 0x12, 0x38, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x24, 0x12, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x0E, 0x00, 0x00, 0x00, 0x24, 0x36, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x87, - 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x48, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x24, 0x12, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0xFF, 0x00, 0x86, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x04, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1D, 0x00, 0x00, 0x00, 0x23, 0x12, 0x21, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x91, 0x20, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x28, 0x12, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x88, - 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x4F, 0x00, 0x00, 0x24, 0x4A, 0x30, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x23, 0x16, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0x0F, 0x00, 0x00, 0x25, 0x16, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x0F, 0x00, 0x00, - 0x23, 0x1A, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA6, 0x1C, 0x33, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x8F, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x27, 0x4A, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, - 0x23, 0x12, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x0F, 0x00, 0x00, 0x24, 0x12, 0x28, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x24, 0x36, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0xFF, 0x00, 0x8B, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x04, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x24, 0x12, 0x38, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x24, 0x12, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x0C, 0x00, 0x00, 0x00, 0x24, 0x36, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x85, - 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x48, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC8, 0x1C, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0xFF, 0x00, 0x90, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x27, 0x4A, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x2E, 0x3A, 0x49, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x2C, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x2F, 0x3E, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x08, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x02, 0x2F, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0C, 0x77, 0x01, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, - 0x90, 0x02, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x81, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x11, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x30, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, - 0x7A, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, - 0x09, 0x00, 0x00, 0x00, 0x22, 0x02, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0xC0, 0x14, 0x82, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, - 0xB3, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x0C, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x16, 0x00, 0x00, 0x00, 0x23, 0x36, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x22, 0x02, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x14, - 0x85, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x22, 0x02, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0xC0, 0x14, 0x88, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0xC0, - 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x22, 0x02, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x14, 0x92, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x20, 0x36, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x20, 0x36, 0x20, 0xC0, - 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x20, 0x36, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, - 0x07, 0x00, 0x00, 0x00, 0x20, 0x36, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, - 0x20, 0x36, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x20, 0x36, 0x20, 0xC0, - 0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x20, 0x36, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, - 0x0B, 0x00, 0x00, 0x00, 0x20, 0x36, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x22, 0x02, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x14, - 0xBA, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0xFF, 0x00, 0x8C, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x03, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x0F, 0x00, 0x00, 0x23, 0x12, 0x28, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x24, 0x36, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x24, 0x12, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, - 0x24, 0x12, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x24, 0x36, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x87, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x04, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x24, 0x12, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x86, 0x11, 0x44, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x1D, 0x00, 0x00, 0x00, 0x23, 0x12, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, - 0x91, 0x20, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x28, 0x12, 0x38, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x88, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0x4F, 0x00, 0x00, 0x24, 0x4A, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, - 0x23, 0x16, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x0F, 0x00, 0x00, 0x25, 0x16, 0x28, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xFF, 0x0F, 0x00, 0x00, 0x23, 0x1A, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xA6, 0x1C, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x8F, - 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x27, 0x4A, 0x38, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x23, 0x12, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0x0F, 0x00, 0x00, 0x24, 0x12, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, - 0x24, 0x36, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x8B, 0x11, 0x44, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x24, 0x12, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, - 0x24, 0x12, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x24, 0x36, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x85, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x04, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xC8, 0x1C, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x90, 0x11, 0x44, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x27, 0x4A, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x30, 0x00, 0x2E, 0x3A, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, - 0x22, 0x02, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x14, - 0xC2, 0x01, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0xA3, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, - 0x20, 0x0E, 0x22, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x23, 0x36, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xF4, 0x21, 0x00, 0x00, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x0A, 0x00, 0x00, 0x00, 0x2C, 0x4A, 0x61, 0x00, 0xB3, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x22, 0x02, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x14, - 0xC5, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x22, 0x02, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0xC0, 0x14, 0xCB, 0x01, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x9C, 0x11, 0x44, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x20, 0x4A, 0x21, 0x40, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0xFF, 0x00, 0x96, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x48, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x22, 0x02, 0x21, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x14, 0xD5, 0x01, 0x00, 0x00, - 0xFF, 0xFF, 0xFF, 0x3F, 0x2E, 0x3A, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, - 0x20, 0x0E, 0x28, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6E, 0x38, 0x29, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x20, 0x0E, 0x28, 0x40, 0x00, 0x00, 0x00, 0x00, - 0x16, 0x00, 0x00, 0x00, 0x23, 0x36, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0xA4, - 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2C, 0x20, 0xC0, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0B, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x08, 0x00, 0x00, 0x00, 0x22, 0x02, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0xC0, 0x14, 0xE1, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x20, 0xC0, - 0x00, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x23, 0x36, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x15, 0x00, 0x00, 0x00, 0x23, 0x36, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, - 0x20, 0x12, 0x22, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x83, 0x10, 0x30, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x24, 0x36, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x20, 0x0E, 0x21, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, - 0x23, 0x0E, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xEF, 0x2E, 0x3A, 0x28, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6E, 0x38, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x60, 0x00, 0x90, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x20, 0xC0, - 0x00, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x22, 0x0E, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x14, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x03, 0x00, 0x00, - 0x22, 0x0E, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x22, 0x12, 0x21, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x24, 0x12, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x8D, 0x10, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, - 0x24, 0x12, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x83, 0x11, 0x44, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x49, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0xFF, 0x00, 0x84, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x03, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0xE3, 0x01, 0x00, 0x00, - 0xFF, 0xFF, 0x00, 0x82, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x11, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x20, 0xC0, - 0x00, 0x00, 0x00, 0x00, 0xFF, 0x3F, 0x00, 0x00, 0x20, 0x0E, 0x28, 0x40, 0x00, 0x00, 0x00, 0x00, - 0x10, 0x00, 0x00, 0x00, 0x20, 0x12, 0x21, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x22, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, - 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x2A, 0x0A, 0x02, 0x00, 0x00, - 0x80, 0x00, 0x00, 0x20, 0x2E, 0x1E, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, - 0x27, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0C, - 0xFD, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x1C, 0x40, 0x00, 0xFE, 0x01, 0x00, 0x00, - 0x10, 0x00, 0x00, 0x00, 0x2D, 0x1E, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF9, 0x21, 0x00, 0x00, - 0x27, 0x46, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x48, 0x40, 0x00, - 0x0A, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x22, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, 0x3F, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0xE0, 0x28, 0x0A, 0x02, 0x00, 0x00, 0x80, 0x00, 0x80, 0x00, 0x2E, 0x1E, 0x28, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x27, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0C, 0x07, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x0C, 0x1C, 0x40, 0x00, 0x08, 0x02, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x2D, 0x1E, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xF9, 0x21, 0x00, 0x00, 0x27, 0x46, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x11, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x81, - 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x02, 0x2F, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, 0x11, 0x02, 0x00, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x11, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, - 0x2D, 0x16, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x2D, 0x1A, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xDF, 0xFF, 0x2E, 0x3A, 0x48, 0x00, 0x15, 0x02, 0x00, 0x00, - 0x04, 0x00, 0x00, 0x00, 0x11, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, - 0x2D, 0x16, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x2D, 0x1A, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xEF, 0xFF, 0x2E, 0x3A, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x10, 0x1C, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x67, 0x00, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x04, - 0x0A, 0x02, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x81, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x06, 0x00, 0x00, 0x00, 0x11, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x83, - 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x48, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x89, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x06, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x84, - 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x48, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x60, 0x00, 0x90, 0x02, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, - 0x24, 0x1E, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x02, 0x2F, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, 0x32, 0x02, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x20, 0x2E, 0x3A, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF7, 0x21, 0x00, 0x00, - 0x2C, 0x46, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC7, 0x48, 0x29, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x81, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x05, 0x00, 0x00, 0x00, 0x11, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, - 0x30, 0x36, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x11, 0x48, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x30, 0x36, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0xFF, 0x00, 0x91, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x03, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, - 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x8D, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x03, 0x48, 0x40, 0x00, 0x45, 0x02, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, - 0x2E, 0x3A, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF6, 0x21, 0x00, 0x00, 0x2C, 0x46, 0x29, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC7, 0x48, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0xFF, 0x00, 0x81, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, - 0x11, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x30, 0x36, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x11, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x0F, 0x00, 0x00, 0x00, 0x30, 0x36, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x92, - 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x48, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0xFF, 0x00, 0x8E, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x03, 0x48, 0x40, 0x00, 0x45, 0x02, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x83, 0x11, 0x44, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x24, 0x12, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x50, 0x00, 0x00, 0x24, 0x4A, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x84, - 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x48, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0xFF, 0x00, 0x82, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x11, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x20, 0x0A, 0x28, 0x40, - 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0xFF, 0x20, 0x0E, 0x28, 0xC0, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0xFF, 0x00, 0x81, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x11, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x22, 0x02, 0x2F, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, 0x4F, 0x02, 0x00, 0x00, - 0xF6, 0x21, 0x00, 0x00, 0x2C, 0x12, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, - 0x24, 0x46, 0x49, 0x00, 0x51, 0x02, 0x00, 0x00, 0xF7, 0x21, 0x00, 0x00, 0x2C, 0x12, 0x29, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x24, 0x46, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0xC1, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x22, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0C, - 0x57, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x22, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0C, 0x57, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x30, 0x16, 0x48, 0x00, 0x5D, 0x02, 0x00, 0x00, 0xFF, 0x0F, 0x00, 0x00, 0x30, 0x16, 0x28, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x30, 0x1A, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0x0F, 0x00, 0x00, 0x26, 0x1A, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x26, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, - 0x5D, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xC0, 0x00, 0x00, 0x00, 0x00, - 0x02, 0x0D, 0x04, 0x00, 0x11, 0x44, 0x60, 0x00, 0xC1, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x22, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, - 0x62, 0x02, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x30, 0x1E, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0x0F, 0x00, 0x00, 0x30, 0x26, 0x48, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x22, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, - 0x66, 0x02, 0x00, 0x00, 0xFF, 0x0F, 0x00, 0x00, 0x30, 0x1E, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x02, 0x00, 0x00, 0x11, 0x24, 0x40, 0x00, 0x6B, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x30, 0x1E, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x30, 0x26, 0x21, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x30, 0x1A, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x26, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0xE0, 0x0C, 0x5C, 0x02, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x25, 0x16, 0x38, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x26, 0x1A, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x03, 0x00, 0x00, 0x00, 0x27, 0x1E, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, - 0x29, 0x26, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x29, 0x26, 0x30, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x0D, 0x06, 0x00, 0x00, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x06, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x25, 0x22, 0x30, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x28, 0x46, 0x69, 0x00, 0xC1, 0x02, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x28, 0x22, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x10, 0x28, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x28, 0x46, 0x69, 0x00, - 0xC1, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x28, 0x22, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x10, 0x08, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, - 0x28, 0x46, 0x69, 0x00, 0xC1, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x28, 0x22, 0x30, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x14, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x0D, 0x06, 0x00, 0x00, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x03, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x86, 0x00, 0x00, 0x11, 0x44, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x02, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x05, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x01, 0x2F, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, 0x86, 0x02, 0x00, 0x00, - 0x00, 0x50, 0x00, 0x00, 0x27, 0x22, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, - 0x23, 0x0E, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x26, 0x1A, 0x33, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x02, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, 0x74, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF3, 0x01, 0x00, 0x00, 0x11, 0x44, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x11, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x8D, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x60, 0xC0, 0x90, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x0E, 0x92, 0x02, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF9, 0x21, 0x00, 0x00, - 0x2C, 0x46, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x11, 0x48, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x28, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x11, 0x00, 0x00, 0x00, 0x2D, 0x26, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x2C, 0x01, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0A, - 0x99, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x30, 0x40, 0x00, 0x9A, 0x02, 0x00, 0x00, - 0x00, 0x04, 0x00, 0x00, 0x2C, 0x32, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x81, - 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x11, 0x48, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x2C, 0x26, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x30, 0x01, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0xC0, 0x14, 0xA1, 0x02, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0xA5, 0x11, 0x44, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x11, 0x48, 0x40, 0x00, 0x9D, 0x02, 0x00, 0x00, - 0xFF, 0xFF, 0x00, 0xA5, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x11, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF4, 0x21, 0x00, 0x00, 0x2C, 0x46, 0x29, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x2A, 0x4A, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0xFF, 0x00, 0xA2, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x11, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x81, 0x11, 0x44, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x11, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x30, 0x01, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x7F, 0xDF, - 0x2E, 0x3A, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x2A, 0x36, 0x80, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x97, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x0C, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0xA2, - 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x48, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x81, 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x00, 0x00, 0x11, 0x48, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x30, 0x01, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x30, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x2C, 0x36, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, 0x2F, 0x3E, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x08, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x02, 0x2F, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0C, 0xBA, 0x02, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x08, 0x20, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x02, 0x2F, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0C, 0xBE, 0x02, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x0B, 0x08, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0xA4, - 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x48, 0x40, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xC0, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x1A, 0xC1, 0x02, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x9F, - 0x11, 0x44, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xEF, 0xBE, 0xAD, 0xDE, 0x11, 0x48, 0x20, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x1A, 0xC4, 0x02, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x48, 0x01, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x02, 0x00, - 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0xE2, 0x01, - 0x00, 0x00, 0x00, 0x00, 0xF3, 0x01, 0x63, 0x00, 0x12, 0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x02, 0x00, 0x26, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x02, 0x00, - 0x02, 0x00, 0xF1, 0x01, 0x00, 0x00, 0x00, 0x00, 0x47, 0x02, 0x79, 0x00, 0x02, 0x00, 0x02, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x12, 0x00, 0x20, 0x00, 0x16, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x02, 0x00, - 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC5, 0x00, 0x1B, 0x01, 0x25, 0x01, 0x02, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x46, 0x01, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x02, 0x00, 0xC5, 0x00, 0x2E, 0x00, 0x48, 0x01, 0x00, 0x00, 0x00, 0x00, 0x70, 0x01, 0xA2, 0x00, - 0x4A, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x20, 0x01, - 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x02, 0x00, 0x03, 0x01, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x09, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x58, 0x00, - 0x02, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC1, 0x00, 0x02, 0x00, 0x8E, 0x02, 0xB5, 0x02, - 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x02, 0x00, - 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x02, 0x00, - 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x02, 0x05, 0x00, 0x08, 0x00, 0x02, 0x00, - 0x00, 0x00, 0x00, 0x00 -}; -// -Cotulla hack -#endif /* functions */ void kgsl_cp_intrcallback(struct kgsl_device *device) @@ -938,11 +273,9 @@ static int kgsl_ringbuffer_load_pm4_ucode(struct kgsl_device *device) { int status = 0; int i; + const struct firmware *fw = NULL; unsigned int *fw_ptr = NULL; size_t fw_word_size = 0; - -#if !defined(CONFIG_MACH_HTCLEO) - const struct firmware *fw = NULL; status = request_firmware(&fw, YAMATO_PM4_FW, kgsl_driver.misc.this_device); @@ -951,13 +284,6 @@ static int kgsl_ringbuffer_load_pm4_ucode(struct kgsl_device *device) YAMATO_PM4_FW, status); goto done; } -#else - struct firmware foo_fw; - struct firmware *fw = &foo_fw; - - fw->data = fw_yamato_pm4; - fw->size = ARRAYSIZE(fw_yamato_pm4); -#endif /*this firmware must come in 3 word chunks. plus 1 word of version*/ if ((fw->size % (sizeof(uint32_t)*3)) != 4) { KGSL_DRV_ERR("bad firmware size %d.\n", fw->size); @@ -974,23 +300,17 @@ static int kgsl_ringbuffer_load_pm4_ucode(struct kgsl_device *device) kgsl_yamato_regwrite(device, REG_CP_ME_RAM_DATA, fw_ptr[i]); done: -#if !defined(CONFIG_MACH_HTCLEO) release_firmware(fw); return status; -#else - return 0; -#endif - } static int kgsl_ringbuffer_load_pfp_ucode(struct kgsl_device *device) { int status = 0; int i; + const struct firmware *fw = NULL; unsigned int *fw_ptr = NULL; size_t fw_word_size = 0; -#if !defined(CONFIG_MACH_HTCLEO) - const struct firmware *fw = NULL; status = request_firmware(&fw, YAMATO_PFP_FW, kgsl_driver.misc.this_device); @@ -999,14 +319,6 @@ static int kgsl_ringbuffer_load_pfp_ucode(struct kgsl_device *device) YAMATO_PFP_FW, status); return status; } -#else - struct firmware foo_fw; - struct firmware *fw = &foo_fw; - - fw->data = fw_yamato_pfp; - fw->size = ARRAYSIZE(fw_yamato_pfp); -#endif - /*this firmware must come in 1 word chunks. */ if ((fw->size % sizeof(uint32_t)) != 0) { KGSL_DRV_ERR("bad firmware size %d.\n", fw->size); @@ -1022,12 +334,8 @@ static int kgsl_ringbuffer_load_pfp_ucode(struct kgsl_device *device) for (i = 1; i < fw_word_size; i++) kgsl_yamato_regwrite(device, REG_CP_PFP_UCODE_DATA, fw_ptr[i]); -#if !defined(CONFIG_MACH_HTCLEO) release_firmware(fw); return status; -#else - return 0; -#endif } static int kgsl_ringbuffer_start(struct kgsl_ringbuffer *rb) From 044ee667e9cc5f91c0c9c31605fe010b4ede64f5 Mon Sep 17 00:00:00 2001 From: Markinus Date: Sun, 14 Nov 2010 23:58:20 +0100 Subject: [PATCH 09/10] htcleo: readded the new battery driver after recheck For most people the driver works good. I checked the coefficients and the pd_m for the 1230 Battery is correct, so the voltage calculating is ok. We need a other test to check the pd_t value for the voltage temperatur correction. Still no battery detection. Wince can detect it, we have to find out how this works. --- arch/arm/configs/htcleo_defconfig | 4 +- arch/arm/mach-msm/Makefile | 4 +- arch/arm/mach-msm/board-htcleo-battery.c | 728 ---------- arch/arm/mach-msm/board-htcleo-log.c | 121 -- arch/arm/mach-msm/board-htcleo-power.c | 214 --- arch/arm/mach-msm/board-htcleo.c | 53 +- arch/arm/mach-msm/htc_battery.c | 237 +++- arch/arm/mach-msm/include/mach/htc_battery.h | 14 +- drivers/power/ds2746_battery.c | 1264 ++++++++++++++++++ drivers/power/ds2746_param.c | 857 ++++++++++++ include/linux/ds2746_battery.h | 148 ++ include/linux/ds2746_battery_config.h | 44 + include/linux/ds2746_param.h | 70 + include/linux/ds2746_param_config.h | 286 ++++ include/linux/tps65200.h | 23 + include/linux/wrapper_types.h | 92 ++ 16 files changed, 3041 insertions(+), 1118 deletions(-) delete mode 100644 arch/arm/mach-msm/board-htcleo-battery.c delete mode 100644 arch/arm/mach-msm/board-htcleo-log.c delete mode 100644 arch/arm/mach-msm/board-htcleo-power.c create mode 100644 drivers/power/ds2746_battery.c create mode 100644 drivers/power/ds2746_param.c create mode 100644 include/linux/ds2746_battery.h create mode 100644 include/linux/ds2746_battery_config.h create mode 100644 include/linux/ds2746_param.h create mode 100644 include/linux/ds2746_param_config.h create mode 100644 include/linux/tps65200.h create mode 100644 include/linux/wrapper_types.h diff --git a/arch/arm/configs/htcleo_defconfig b/arch/arm/configs/htcleo_defconfig index 7620dcce..99432307 100644 --- a/arch/arm/configs/htcleo_defconfig +++ b/arch/arm/configs/htcleo_defconfig @@ -238,7 +238,7 @@ CONFIG_MACH_HTCLEO=y # CONFIG_MACH_INCREDIBLEC is not set # CONFIG_MACH_SUPERSONIC is not set # CONFIG_HTC_BATTCHG_SMEM is not set -# CONFIG_HTC_BATTCHG is not set +CONFIG_HTC_BATTCHG=y # CONFIG_HTC_PWRSINK is not set CONFIG_HTC_SLEEP_MODE_GPIO_DUMP=y # CONFIG_HTC_POWER_COLLAPSE_MAGIC is not set @@ -1192,7 +1192,7 @@ CONFIG_POWER_SUPPLY=y # CONFIG_BATTERY_DS2760 is not set # CONFIG_BATTERY_DS2782 is not set # CONFIG_BATTERY_DS2784 is not set -# CONFIG_BATTERY_DS2746 is not set +CONFIG_BATTERY_DS2746=y # CONFIG_BATTERY_BQ27x00 is not set # CONFIG_BATTERY_MAX17040 is not set # CONFIG_HWMON is not set diff --git a/arch/arm/mach-msm/Makefile b/arch/arm/mach-msm/Makefile index 847d9811..5f3a5b58 100644 --- a/arch/arm/mach-msm/Makefile +++ b/arch/arm/mach-msm/Makefile @@ -115,9 +115,9 @@ obj-$(CONFIG_MACH_BRAVOC) += board-bravoc-wifi.o htc_awb_cal.o obj-$(CONFIG_MACH_BRAVOC) += board-bravoc-microp.o clock.o obj-$(CONFIG_MACH_HTCLEO) += board-htcleo.o board-htcleo-panel.o board-htcleo-keypad.o -obj-$(CONFIG_MACH_HTCLEO) += board-htcleo-ts.o board-htcleo-mmc.o ieee754-df.o board-htcleo-power.o +obj-$(CONFIG_MACH_HTCLEO) += board-htcleo-ts.o board-htcleo-mmc.o ieee754-df.o -obj-$(CONFIG_MACH_HTCLEO) += board-htcleo-battery.o board-htcleo-log.o board-htcleo-audio.o board-htcleo-acoustic.o +obj-$(CONFIG_MACH_HTCLEO) += board-htcleo-audio.o board-htcleo-acoustic.o obj-$(CONFIG_MACH_HTCLEO) += board-htcleo-rfkill.o board-htcleo-wifi.o board-htcleo-microp.o obj-$(CONFIG_MACH_HTCLEO) += board-htcleo-proximity.o board-htcleo-leds.o board-htcleo-ls.o obj-$(CONFIG_MACH_HTCLEO) += clock-wince.o diff --git a/arch/arm/mach-msm/board-htcleo-battery.c b/arch/arm/mach-msm/board-htcleo-battery.c deleted file mode 100644 index 20488aa9..00000000 --- a/arch/arm/mach-msm/board-htcleo-battery.c +++ /dev/null @@ -1,728 +0,0 @@ -/* arch/arm/mach-msm/board-htcleo-battery.h -* -* Copyright (C) 2010 Markinus -* Copyright (C) 2009 HTC Corporation -* Copyright (C) 2009 Google, Inc. -* -* This software is licensed under the terms of the GNU General Public -* License version 2, as published by the Free Software Foundation, and -* may be copied, distributed, and modified under those terms. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -*/ - -/* - -actually this file called "board-htcleo-battery.c", so it's HTC LEO specific only -most values are hard coded here really. -this driver designed for android. - -proper ds2745 driver located at "driver/i2c/chips/ds2745.c" -I don't want and have not resources to support any "proper" linux drivers coding. -("proper" for them, not for me ofcourse) - -my primary target was to make high quality battery support in Android for HTC LEO. kefir with us! - -*/ -//#define DEBUG - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include - -#include "gpio_chip.h" -#include "board-htcleo.h" - -static enum power_supply_property battery_properties[] = -{ - POWER_SUPPLY_PROP_STATUS, - POWER_SUPPLY_PROP_HEALTH, - POWER_SUPPLY_PROP_PRESENT, - POWER_SUPPLY_PROP_TECHNOLOGY, - POWER_SUPPLY_PROP_CAPACITY, - POWER_SUPPLY_PROP_VOLTAGE_NOW, - POWER_SUPPLY_PROP_TEMP, - POWER_SUPPLY_PROP_CURRENT_NOW, - POWER_SUPPLY_PROP_CURRENT_AVG, - POWER_SUPPLY_PROP_CHARGE_COUNTER, -}; - -static int battery_get_property(struct power_supply *psy, enum power_supply_property psp, union power_supply_propval *val); -static void htcleo_program_alarm(struct htcleo_device_info *di, int seconds); -static void battery_ext_power_changed(struct power_supply *psy); - -#define BATTERY_LOG_MAX 1024 -#define BATTERY_LOG_MASK (BATTERY_LOG_MAX - 1) - -static DEFINE_MUTEX(battery_log_lock); -static struct battery_status battery_log[BATTERY_LOG_MAX]; -static unsigned battery_log_head; -static unsigned battery_log_tail; - -void battery_log_status(struct battery_status *s) -{ - unsigned n; - mutex_lock(&battery_log_lock); - n = battery_log_head; - memcpy(battery_log + n, s, sizeof(struct battery_status)); - n = (n + 1) & BATTERY_LOG_MASK; - if (n == battery_log_tail) - battery_log_tail = (battery_log_tail + 1) & BATTERY_LOG_MASK; - battery_log_head = n; - mutex_unlock(&battery_log_lock); -} - -static const char *battery_source[3] = { "none", " usb", " ac" }; -static const char *battery_mode[4] = { " off", "slow", "fast", "full" }; - -static int battery_log_print(struct seq_file *sf, void *private) -{ - unsigned n; - mutex_lock(&battery_log_lock); - seq_printf(sf, "timestamp mV mA avg mA uAh dC %% src mode reg full\n"); - for (n = battery_log_tail; n != battery_log_head; n = (n + 1) & BATTERY_LOG_MASK) - { - struct battery_status *s = battery_log + n; - seq_printf(sf, "%9d %5d %6d %6d %8d %4d %3d %s %s 0x%02x %d\n", - s->timestamp, s->voltage_uV / 1000, - s->current_uA / 1000, s->current_avg_uA / 1000, - s->charge_uAh, s->temp_C, - s->percentage, - battery_source[s->charge_source], - battery_mode[s->charge_mode], - s->status_reg, s->battery_full); - } - mutex_unlock(&battery_log_lock); - return 0; -} - -static int I2C_Read_Status(struct htcleo_device_info *di) -{ - uint8_t i2c_msg[1]; - uint8_t i2c_data[2]; - - i2c_msg[0] = 0x01; //status reg - - i2c_master_send(di->client, i2c_msg, 1); - i2c_master_recv(di->client, i2c_data, 2); - - dev_dbg(&di->client->dev, "I2C_Read_Status() = %08X!\n", i2c_data[0]); - di->raw_status = i2c_data[0]; - return 0; -} - -static int I2C_Read_Data(struct htcleo_device_info *di) -{ - uint8_t i2c_msg[1]; - uint8_t i2c_data[10]; - - i2c_msg[0] = 0x08; // AUX0 AUX1 VOLTAGE CURRENT ACR - - i2c_master_send(di->client, i2c_msg, 1); - i2c_master_recv(di->client, i2c_data, 10); - - dev_dbg(&di->client->dev, "I2C_Read_Data() %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X!\n", - i2c_data[0], i2c_data[1], i2c_data[2], i2c_data[3], i2c_data[4], - i2c_data[5], i2c_data[6], i2c_data[7], i2c_data[8], i2c_data[9]); - memcpy(di->raw, i2c_data, 10); - return 0; -} - -static int I2C_Write_ACR(struct htcleo_device_info *di, uint16_t val) -{ - uint8_t i2c_msg[3]; - - i2c_msg[0] = 0x10; - i2c_msg[1] = (val >> 8) & 0xFF; - i2c_msg[2] = (val >> 0) & 0xFF; - -// dev_dbg(&di->client->dev, "I2C_Write_ACR() = %04X!\n", val); - i2c_master_send(di->client, i2c_msg, 3); - return 0; -} - -////////////////////////////////////////////////////////////////////////// - -static int htcleo_charge(int on, int fast) -{ - gpio_direction_output(HTCLEO_GPIO_BATTERY_CHARGER_CURRENT, !!fast); - gpio_direction_output(HTCLEO_GPIO_BATTERY_CHARGER_ENABLE, !on); - return 0; -} - -static void htcleo_parse_data(uint32_t raw_status, u8 *raw, struct battery_status *s) -{ - short n; - uint32_t n32; - uint32_t FL, ACR, ACR_EMPTY; - - /* Get status reg */ - s->status_reg = raw_status; - - /* Get Level */ - // TODO: FL too wrong (?) - ACR = ((raw[8] << 8) | raw[9]); - FL = (LEO_BATTERY_CAPACITY * 1570) / 625; - ACR_EMPTY = (LEO_BATTERY_EMPTY * 1570) / 625; - s->percentage = (100 * (ACR - ACR_EMPTY)) / FL; - - s->charge_uAh = 1000 * (((ACR - ACR_EMPTY) * 625) / 1570); - - if (s->percentage < 0 ) s->percentage = 0; - if (s->percentage > 100 ) s->percentage = 100; - - - /* Get Voltage */ - n32 = (((raw[4] << 8) | raw[5]) / 16); - //s->voltage_uV = (n32 * 244) / 100; - s->voltage_uV = 1000 * ((n32 * 312) >> 7); // div to 128 - - /* Get Current */ - n = ((raw[6]) << 8) | raw[7]; - s->current_uA = 1000 * (((n/4) * 625) / 1570); - - printk("ACR=%d CURR=%d VOL=%d RAAC=%d\n", ACR, s->current_uA, s->voltage_uV, s->percentage); - - // average current not supported by DS2746 - s->current_avg_uA = s->current_uA; - - /* Get Temperature */ - n = ((raw[0] << 8) | (raw[1])); - n /= 16; - - // printk("temp = %x\n", n); - if (n > 2047 || n == 0) - { - s->temp_C = 250; - } - else - { - double v = 0.021277 * (300.0 / (2047.0 / n - 1.0)); - s->temp_C = 10 * (1.0 / ((log(v) * 0.000290698) + 0.003354016) - 273.15); - } - if (s->temp_C < -250) - { - s->temp_C = -250; - } -} - -static int htcleo_battery_read_status(struct htcleo_device_info *di) -{ - // read status - I2C_Read_Status(di); - I2C_Read_Data(di); - - // printk("status = %04X\n", di->raw_status); - htcleo_parse_data(di->raw_status, di->raw, &di->status); - - dev_dbg(&di->client->dev, "batt: %3d%%, %d mV, %d mA (%d avg), %d.%d C, %d mAh\n", - di->status.percentage, - di->status.voltage_uV / 1000, di->status.current_uA / 1000, - di->status.current_avg_uA / 1000, - di->status.temp_C / 10, di->status.temp_C % 10, - di->status.charge_uAh / 1000); - - return 0; -} - -////////////////////////////////////////////////////////////////////////// - -static int htcleo_set_cc(struct htcleo_device_info *di, bool enable) -{ - // not supported for DS2745, there no CE bit - return 0; -} - - -static int battery_get_property(struct power_supply *psy, enum power_supply_property psp, union power_supply_propval *val) -{ - struct htcleo_device_info *di = psy_to_dev_info(psy); - - switch (psp) - { - case POWER_SUPPLY_PROP_STATUS: - switch (di->status.charge_source) - { - case CHARGE_OFF: - val->intval = POWER_SUPPLY_STATUS_DISCHARGING; - break; - case CHARGE_FAST: - case CHARGE_SLOW: - if (di->status.battery_full) - val->intval = POWER_SUPPLY_STATUS_FULL; - else if (di->status.charge_mode == CHARGE_OFF) - val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING; - else - val->intval = POWER_SUPPLY_STATUS_CHARGING; - break; - default: - val->intval = POWER_SUPPLY_STATUS_UNKNOWN; - break; - } - break; - case POWER_SUPPLY_PROP_HEALTH: - if (di->status.temp_C >= TEMP_HOT) - val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; - else - val->intval = POWER_SUPPLY_HEALTH_GOOD; - break; - case POWER_SUPPLY_PROP_PRESENT: - /* XXX todo */ - val->intval = 1; - break; - case POWER_SUPPLY_PROP_TECHNOLOGY: - if (di->dummy) - val->intval = POWER_SUPPLY_TECHNOLOGY_UNKNOWN; - else - val->intval = POWER_SUPPLY_TECHNOLOGY_LION; - break; - case POWER_SUPPLY_PROP_CAPACITY: - if (di->dummy) - val->intval = 75; - else - val->intval = di->status.percentage; - break; - case POWER_SUPPLY_PROP_VOLTAGE_NOW: - val->intval = di->status.voltage_uV; - break; - case POWER_SUPPLY_PROP_TEMP: - val->intval = di->status.temp_C; - break; - case POWER_SUPPLY_PROP_CURRENT_NOW: - val->intval = di->status.current_uA; - break; - case POWER_SUPPLY_PROP_CURRENT_AVG: - val->intval = di->status.current_avg_uA; - break; - case POWER_SUPPLY_PROP_CHARGE_COUNTER: - val->intval = di->status.charge_uAh; - break; - default: - return -EINVAL; - } - - return 0; -} - -static void htcleo_battery_update_status(struct htcleo_device_info *di) -{ - u8 last_level; - last_level = di->status.percentage; - - htcleo_battery_read_status(di); - - // CotullaTODO: add ACR = FL at top point here - - if ((last_level != di->status.percentage) || (di->status.temp_C > 450)) - { - power_supply_changed(&di->bat); - } -} - -static DEFINE_MUTEX(charge_state_lock); - -static bool check_timeout(ktime_t now, ktime_t last, int seconds) -{ - ktime_t timeout = ktime_add(last, ktime_set(seconds, 0)); - return ktime_sub(timeout, now).tv64 < 0; -} - -static int battery_adjust_charge_state(struct htcleo_device_info *di) -{ - unsigned source; - int rc = 0; - int temp, volt, curr, perc; - int ovp; - u8 charge_mode; - bool charge_timeout = false; - static int lastval=0xffff; - const int min_curr=5000; - - mutex_lock(&charge_state_lock); - - curr = di->status.current_uA; - perc = di->status.percentage; - temp = di->status.temp_C; - volt = di->status.voltage_uV / 1000; - - source = di->status.charge_source; - - /* initially our charge mode matches our source: - * NONE:OFF, USB:SLOW, AC:FAST - */ - charge_mode = source; - - // Check whether the bat is full and change the ACR to right 100% value - if(curr >=0 && curr < min_curr && lastval < min_curr && perc > 95 && source) { - uint32_t FL = (LEO_BATTERY_CAPACITY * 1570) / 625; - uint32_t ACR_EMPTY = (LEO_BATTERY_EMPTY * 1570) / 625; - I2C_Write_ACR(di, FL+ACR_EMPTY); - di->status.battery_full = 1; - di->status.percentage = 100; - charge_mode = CHARGE_OFF; - } - else { - di->status.battery_full = 0; - } - if(curr >=0) lastval=curr; - else lastval=0xffff; - - ovp = gpio_get_value(HTCLEO_GPIO_BATTERY_OVER_CHG); - if (ovp) - { - printk("Battery overpowered!\n"); - } - - if (temp >= TEMP_HOT || ovp) - { - if (temp >= TEMP_CRITICAL) - { - charge_mode = CHARGE_OFF; - } - - /* once we charge to max voltage when hot, disable - * charging until the temp drops or the voltage drops - */ - if (volt >= TEMP_HOT_MAX_MV) - { - di->status.cooldown = 1; - } - } - - /* when the battery is warm, only charge in slow charge mode */ - if ((temp >= TEMP_WARM) && (charge_mode == CHARGE_FAST)) - charge_mode = CHARGE_SLOW; - - if (di->status.cooldown) - { - if ((temp < TEMP_WARM) || (volt <= TEMP_HOT_MIN_MV)) - di->status.cooldown = 0; - else - charge_mode = CHARGE_OFF; - } - - if (di->status.current_uA > 1024) - { - di->last_charge_seen = di->last_poll; - } - else if (di->last_charge_mode != CHARGE_OFF && check_timeout(di->last_poll, di->last_charge_seen, 60 * 60)) - { - /* The charger has probably stopped charging. Turn it - * off until the next sample period. - */ - charge_timeout = true; - charge_mode = CHARGE_OFF; - } - - if (source == CHARGE_OFF) - charge_mode = CHARGE_OFF; - - - if (di->last_charge_mode == charge_mode) - goto done; - - di->last_charge_mode = charge_mode; - di->status.charge_mode = charge_mode; - - switch (charge_mode) - { - case CHARGE_OFF: - htcleo_charge(0, 0); - htcleo_set_cc(di, true); - if (temp >= TEMP_CRITICAL) - pr_info("batt: charging OFF [OVERTEMP]\n"); - else if (di->status.cooldown) - pr_info("batt: charging OFF [COOLDOWN]\n"); - else if (di->status.battery_full) - pr_info("batt: charging OFF [FULL]\n"); - else if (charge_timeout) - pr_info("batt: charging OFF [TIMEOUT]\n"); - else - pr_info("batt: charging OFF\n"); - break; - case CHARGE_SLOW: - di->last_charge_seen = di->last_poll; - htcleo_set_cc(di, true); - htcleo_charge(1, 0); - pr_info("batt: charging SLOW\n"); - break; - case CHARGE_FAST: - di->last_charge_seen = di->last_poll; - htcleo_set_cc(di, true); - htcleo_charge(1, 1); - pr_info("batt: charging FAST\n"); - break; - } - rc = 1; - done: - mutex_unlock(&charge_state_lock); - return rc; -} - - - -static void htcleo_battery_work(struct work_struct *work) -{ - struct htcleo_device_info *di = container_of(work, struct htcleo_device_info, monitor_work); - struct timespec ts; - unsigned long flags; - - htcleo_battery_update_status(di); - - di->last_poll = alarm_get_elapsed_realtime(); - - if (battery_adjust_charge_state(di)) - { - power_supply_changed(&di->bat); - } - - ts = ktime_to_timespec(di->last_poll); - di->status.timestamp = ts.tv_sec; - battery_log_status(&di->status); - - /* prevent suspend before starting the alarm */ - local_irq_save(flags); - wake_unlock(&di->work_wake_lock); - htcleo_program_alarm(di, FAST_POLL); - local_irq_restore(flags); -} - -////////////////////////////////////////////////////////////////////////// - -static void htcleo_program_alarm(struct htcleo_device_info *di, int seconds) -{ - ktime_t low_interval = ktime_set(seconds - 10, 0); - ktime_t slack = ktime_set(20, 0); - ktime_t next; - - next = ktime_add(di->last_poll, low_interval); - - alarm_start_range(&di->alarm, next, ktime_add(next, slack)); -} - -static void htcleo_battery_alarm(struct alarm *alarm) -{ - struct htcleo_device_info *di = container_of(alarm, struct htcleo_device_info, alarm); - wake_lock(&di->work_wake_lock); - queue_work(di->monitor_wqueue, &di->monitor_work); -} - -static void battery_ext_power_changed(struct power_supply *psy) -{ - struct htcleo_device_info *di; - int got_power; - - di = psy_to_dev_info(psy); - got_power = power_supply_am_i_supplied(psy); - - if (got_power) - { - if (is_ac_power_supplied()) - di->status.charge_source = SOURCE_AC; - else - di->status.charge_source = SOURCE_USB; - wake_lock(&vbus_wake_lock); - } - else - { - di->status.charge_source = SOURCE_NONE; - /* give userspace some time to see the uevent and update - * LED state or whatnot... - */ - wake_lock_timeout(&vbus_wake_lock, HZ / 2); - } - battery_adjust_charge_state(di); - power_supply_changed(psy); -} - -static int htcleo_battery_probe(struct i2c_client *client, const struct i2c_device_id *id) -{ - int rc; - struct htcleo_device_info *di; - - printk("%s\n", __func__); - if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE)) - { - return -EIO; - } - - di = kzalloc(sizeof(*di), GFP_KERNEL); - if (!di) - { - return -ENOMEM; - } - - mydi=di; - - di->client = client; - - i2c_set_clientdata(client, di); - - gpio_request(HTCLEO_GPIO_BATTERY_CHARGER_CURRENT, "charger_current"); - gpio_request(HTCLEO_GPIO_BATTERY_CHARGER_ENABLE, "charger_enable"); - gpio_request(HTCLEO_GPIO_BATTERY_OVER_CHG, "charger_over_chg"); - - gpio_direction_output(HTCLEO_GPIO_BATTERY_CHARGER_CURRENT, 1); - gpio_direction_output(HTCLEO_GPIO_BATTERY_CHARGER_ENABLE, 1); - gpio_direction_input(HTCLEO_GPIO_BATTERY_OVER_CHG); - - - di->bat.name = "battery"; - di->bat.type = POWER_SUPPLY_TYPE_BATTERY; - di->bat.properties = battery_properties; - di->bat.num_properties = ARRAY_SIZE(battery_properties); - di->bat.external_power_changed = battery_ext_power_changed; - di->bat.get_property = battery_get_property; - di->last_charge_mode = 0xff; - - rc = power_supply_register(&client->dev, &di->bat); - if (rc) - { - goto fail_register; - } - - INIT_WORK(&di->monitor_work, htcleo_battery_work); - di->monitor_wqueue = create_freezeable_workqueue(dev_name(&client->dev)); - - /* init to something sane */ - di->last_poll = alarm_get_elapsed_realtime(); - - if (!di->monitor_wqueue) - { - rc = -ESRCH; - goto fail_workqueue; - } - wake_lock_init(&di->work_wake_lock, WAKE_LOCK_SUSPEND, "htcleo-battery"); - printk("alarm init\n"); - alarm_init(&di->alarm, ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP, htcleo_battery_alarm); - wake_lock(&di->work_wake_lock); - queue_work(di->monitor_wqueue, &di->monitor_work); - printk("%s: done!\n", __func__); - return 0; - - fail_workqueue: - power_supply_unregister(&di->bat); - fail_register: - - - gpio_free(HTCLEO_GPIO_BATTERY_CHARGER_CURRENT); - gpio_free(HTCLEO_GPIO_BATTERY_CHARGER_ENABLE); - gpio_free(HTCLEO_GPIO_BATTERY_OVER_CHG); - - kfree(di); - return rc; -} - -static int htcleo_suspend(struct device *dev) -{ - struct htcleo_device_info *di = dev_get_drvdata(dev); - - /* If we are on battery, reduce our update rate until - * we next resume. - */ - if (di->status.charge_source == SOURCE_NONE) - { - htcleo_program_alarm(di, SLOW_POLL); - di->slow_poll = 1; - } - return 0; -} - -static int htcleo_resume(struct device *dev) -{ - struct htcleo_device_info *di = dev_get_drvdata(dev); - - /* We might be on a slow sample cycle. If we're - * resuming we should resample the battery state - * if it's been over a minute since we last did - * so, and move back to sampling every minute until - * we suspend again. - */ - if (di->slow_poll) - { - htcleo_program_alarm(di, FAST_POLL); - di->slow_poll = 0; - } - return 0; -} - -static struct dev_pm_ops htcleo_pm_ops = -{ - .suspend = htcleo_suspend, - .resume = htcleo_resume, -}; - - -static const struct i2c_device_id htcleo_battery_id[] = -{ - { "htcleo-battery", 0 }, - { } -}; - - -static struct i2c_driver htcleo_battery_driver = -{ - .driver = - { - .name = "htcleo-battery", - .owner = THIS_MODULE, - .pm = &htcleo_pm_ops, - }, - .id_table = htcleo_battery_id, - .probe = htcleo_battery_probe, -#ifndef CONFIG_HAS_EARLYSUSPEND - /* .suspend = htcleo_suspend, - .resume = htcleo_resume,*/ -#endif -}; - -static int battery_log_open(struct inode *inode, struct file *file) -{ - return single_open(file, battery_log_print, NULL); -} - -static struct file_operations battery_log_fops = -{ - .open = battery_log_open, - .read = seq_read, - .llseek = seq_lseek, - .release = single_release, -}; - -static int __init htcleo_battery_init(void) -{ - debugfs_create_file("battery_log", 0444, NULL, NULL, &battery_log_fops); - wake_lock_init(&vbus_wake_lock, WAKE_LOCK_SUSPEND, "vbus_present"); - return i2c_add_driver(&htcleo_battery_driver); -} - -//module_init(htcleo_battery_init); -late_initcall(htcleo_battery_init); - -MODULE_LICENSE("GPL"); -MODULE_AUTHOR("Cotulla"); -MODULE_DESCRIPTION("htcleo battery driver"); -// END OF FILE diff --git a/arch/arm/mach-msm/board-htcleo-log.c b/arch/arm/mach-msm/board-htcleo-log.c deleted file mode 100644 index db920492..00000000 --- a/arch/arm/mach-msm/board-htcleo-log.c +++ /dev/null @@ -1,121 +0,0 @@ -/* arch/arm/mach-msm/board-htcleo-log.c -* -* Copyright (C) 2010 Cotulla -* Copyright (C) Open Watcom Project -* -* This software is licensed under the terms of the GNU General Public -* License version 2, as published by the Free Software Foundation, and -* may be copied, distributed, and modified under those terms. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -*/ -#include -#include -#include -#include -#include - - - -#define sqrt_of_half 0.7071067811865475244 -#define C1 (355./512.) -#define C2 (-2.121944400546905827679e-4) - - -static const double APoly[] = -{ - -0.78956112887491257267, - 0.16383943563021534222e+2, - -0.64124943423745581147e+2 -}; - -static const double BPoly[] = -{ - 1.0, - -0.35667977739034646171e+2, - 0.31203222091924532844e+3, - -0.76949932108494879777e+3 -}; - -static double _EvalPoly( double x, const double *poly, int degree ) -/********************************************************************/ -{ - double z; - - z = *poly++; - do - { - z = z * x + *poly++; - } while( --degree != 0 ); - return( z ); -} - -static double frexp( double value, int *exp ) -/**********************************************/ -{ - int n; - union - { - double x; - unsigned short a[4]; - } u; - - n = 0; - u.x = value; - if( value != 0.0 ) - { - n = (u.a[3] & 0x7ff0) >> 4; - n -= 0x03fe; - u.a[3] &= 0x800f; - u.a[3] |= 0x3fe0; - } - *exp = n; - return( u.x ); -} - - -double log(double x) -/***********************************/ -{ - int exp; - double z; - - if( x <= 0.0 ) - { - BUG(); - x = 0; // who cares? :) - } - else - { - x = frexp( x, &exp ); - z = x - .5; - if( x > sqrt_of_half ) - { - z -= .5; - } - else - { - x = z; - --exp; - } - z = z / (x * .5 + .5); - x = z * z; - x = z + z * x * _EvalPoly( x, APoly, 2 ) / _EvalPoly( x, BPoly, 3 ); - if( exp != 0 ) - { - z = exp; - x = (z * C2 + x) + z * C1; - } - } - return( x ); -} - - -MODULE_LICENSE("GPL"); -MODULE_AUTHOR("Cotulla"); -MODULE_DESCRIPTION("htcleo log function"); -// END OF FILE diff --git a/arch/arm/mach-msm/board-htcleo-power.c b/arch/arm/mach-msm/board-htcleo-power.c deleted file mode 100644 index fcb9d8da..00000000 --- a/arch/arm/mach-msm/board-htcleo-power.c +++ /dev/null @@ -1,214 +0,0 @@ -/* arch/arm/mach-msm/board-htcleo-power.c -* -* Copyright (C) 2010 Cotulla -* Copyright (C) 2008 HTC Corporation. -* Copyright (C) 2008 Google, Inc. -* -* This software is licensed under the terms of the GNU General Public -* License version 2, as published by the Free Software Foundation, and -* may be copied, distributed, and modified under those terms. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -*/ - -// -// calls seq: -// -// notify_vbus_change_intr -> vbus_work_func -> msm_hsusb_set_vbus_state -> USB -> notify_usb_connected -// - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include - -#include "board-htcleo.h" - -static char *supply_list[] = -{ - "battery", -}; - -static int inited; -static int vbus_present; -static int usb_status; -static struct work_struct vbus_work; - -#ifdef CONFIG_USB_ANDROID -void notify_usb_connected(int status); -static struct t_usb_status_notifier usb_status_notifier = { - .name = "htc_battery", - .func = notify_usb_connected, -}; -#endif - -static int power_get_property(struct power_supply *psy, - enum power_supply_property psp, - union power_supply_propval *val) -{ - if (psp != POWER_SUPPLY_PROP_ONLINE) - return -EINVAL; - - if (psy->type == POWER_SUPPLY_TYPE_MAINS) - { - val->intval = (usb_status == 2); - } - else - { - val->intval = vbus_present; - } - return 0; -} - -static enum power_supply_property power_properties[] = -{ - POWER_SUPPLY_PROP_ONLINE, -}; - -static struct power_supply ac_supply = -{ - .name = "ac", - .type = POWER_SUPPLY_TYPE_MAINS, - .supplied_to = supply_list, - .num_supplicants = ARRAY_SIZE(supply_list), - .properties = power_properties, - .num_properties = ARRAY_SIZE(power_properties), - .get_property = power_get_property, -}; - -static struct power_supply usb_supply = -{ - .name = "usb", - .type = POWER_SUPPLY_TYPE_USB, - .supplied_to = supply_list, - .num_supplicants = ARRAY_SIZE(supply_list), - .properties = power_properties, - .num_properties = ARRAY_SIZE(power_properties), - .get_property = power_get_property, -}; - -static int get_vbus_state(void) -{ - if (readl(MSM_SHARED_RAM_BASE + 0xEF20C)) - return 1; - else - return 0; -} - -void notify_cable_status(int status) -{ - pr_info("### notify_cable_status(%d) ###\n", status); - vbus_present = status; - msm_hsusb_set_vbus_state(vbus_present); - power_supply_changed(&ac_supply); - power_supply_changed(&usb_supply); - if(mydi) - power_supply_changed(&mydi->bat); -} - -// called from USB driver -void notify_usb_connected(int status) -{ - if (!inited) return; - pr_info("### notify_usb_connected(%d) ###\n", status); - usb_status = status; - power_supply_changed(&ac_supply); - power_supply_changed(&usb_supply); - if(mydi) - power_supply_changed(&mydi->bat); -} - -// called from DEX intrrupt -void notify_vbus_change_intr(void) -{ - if (!inited) return; - schedule_work(&vbus_work); -} - -// used by battery driver -int is_ac_power_supplied(void) -{ - return (usb_status == 2); -} - -static void vbus_work_func(struct work_struct *work) -{ - int vbus = get_vbus_state(); - printk(" new vbus = %d\n", vbus); - #ifdef CONFIG_USB_EHCI_HCD - if (vbus) - return 0; - else - return 0; - #else - if (vbus) - gpio_set_value(HTCLEO_GPIO_POWER_USB, 0); - else - gpio_set_value(HTCLEO_GPIO_POWER_USB, 1); - #endif - notify_cable_status(vbus); -} - - -static int htcleo_power_probe(struct platform_device *pdev) -{ - printk("$$$ htcleo_power_probe $$$\n"); - - INIT_WORK(&vbus_work, vbus_work_func); - - gpio_request(HTCLEO_GPIO_POWER_USB, "power_usb"); - gpio_direction_output(HTCLEO_GPIO_POWER_USB, 0); - - power_supply_register(&pdev->dev, &ac_supply); - power_supply_register(&pdev->dev, &usb_supply); - - inited = 1; - // init VBUS state - notify_vbus_change_intr(); - return 0; -} - -//#define APP_BATT_PDEV_NAME "rs30100001:00000000" -#define APP_BATT_PDEV_NAME "htcleo_power" - -static struct platform_driver htcleo_power_driver = -{ - .probe = htcleo_power_probe, - .driver = - { - .name = APP_BATT_PDEV_NAME, - .owner = THIS_MODULE, - }, -}; - -static int __init htcleo_power_init(void) -{ - printk("htcleo_power_init\n"); - platform_driver_register(&htcleo_power_driver); - #ifdef CONFIG_USB_ANDROID - usb_register_notifier(&usb_status_notifier); - #endif - return 0; -} - -//module_init(htcleo_power_init); -late_initcall(htcleo_power_init); -MODULE_DESCRIPTION("HTCLEO Power Driver"); -MODULE_LICENSE("GPL"); diff --git a/arch/arm/mach-msm/board-htcleo.c b/arch/arm/mach-msm/board-htcleo.c index 47632913..3db89f33 100644 --- a/arch/arm/mach-msm/board-htcleo.c +++ b/arch/arm/mach-msm/board-htcleo.c @@ -34,6 +34,7 @@ #endif #include #include <../../../drivers/staging/android/timed_gpio.h> +#include #include #include @@ -231,9 +232,6 @@ static struct microp_i2c_platform_data microp_data = { static struct i2c_board_info base_i2c_devices[] = { - { - I2C_BOARD_INFO("htcleo-battery", 0x26), - }, { I2C_BOARD_INFO(LEO_TOUCH_DRV_NAME, 0), }, @@ -716,11 +714,45 @@ static struct platform_device ram_console_device = { // Power/Battery /////////////////////////////////////////////////////////////////////// -static struct platform_device htcleo_power = -{ - .name = "htcleo_power", - .id = -1, +static struct htc_battery_platform_data htc_battery_pdev_data = { + .func_show_batt_attr = htc_battery_show_attr, + .gpio_mbat_in = -1, + .gpio_mchg_en_n = HTCLEO_GPIO_BATTERY_CHARGER_ENABLE, + .gpio_iset = HTCLEO_GPIO_BATTERY_CHARGER_CURRENT, + .guage_driver = GUAGE_DS2746, + .charger = LINEAR_CHARGER, + .m2a_cable_detect = 0, + .force_no_rpc = 1, + .int_data = { + .chg_int = HTCLEO_GPIO_BATTERY_OVER_CHG, + }, }; + +static struct platform_device htc_battery_pdev = { + .name = "htc_battery", + .id = -1, + .dev = { + .platform_data = &htc_battery_pdev_data, + }, +}; + +static int get_thermal_id(void) +{ + return THERMAL_600; +} + +static struct ds2746_platform_data ds2746_pdev_data = { + .func_get_thermal_id = get_thermal_id, +}; + +static struct platform_device ds2746_battery_pdev = { + .name = "ds2746-battery", + .id = -1, + .dev = { + .platform_data = &ds2746_pdev_data, + }, +}; + /////////////////////////////////////////////////////////////////////// // Real Time Clock /////////////////////////////////////////////////////////////////////// @@ -751,10 +783,11 @@ static struct platform_device *devices[] __initdata = &android_pmem_adsp_device, &android_pmem_venc_device, &msm_device_i2c, + &ds2746_battery_pdev, + &htc_battery_pdev, &msm_kgsl_device, &msm_camera_sensor_s5k3e2fx, &htcleo_flashlight_device, - &htcleo_power, &qsd_device_spi, &htc_headset_mgr, &htc_headset_gpio, @@ -905,10 +938,6 @@ static void __init htcleo_init(void) platform_device_register(&htcleo_timed_gpios); -#ifdef CONFIG_USB_ANDROID - msm_hsusb_set_vbus_state(htcleo_get_vbus_state()); -#endif - /* Blink the camera LED shortly to show that we're alive! */ #ifdef CONFIG_HTCLEO_BLINK_AT_BOOT bank6_in = (unsigned int*)(MSM_GPIO1_BASE + 0x0864); diff --git a/arch/arm/mach-msm/htc_battery.c b/arch/arm/mach-msm/htc_battery.c index 4ca27764..d898e10e 100644 --- a/arch/arm/mach-msm/htc_battery.c +++ b/arch/arm/mach-msm/htc_battery.c @@ -30,21 +30,23 @@ #include /* Jay, to register display notifier */ #include #include +#include +#include #ifdef CONFIG_HTC_BATTCHG_SMEM #include "smd_private.h" #endif +#include +#include #if defined(CONFIG_TROUT_BATTCHG_DOCK) #include #endif #ifdef CONFIG_BATTERY_DS2784 #include -#elif CONFIG_BATTERY_DS2746 +#elif defined(CONFIG_BATTERY_DS2746) #include #endif -#include - static struct wake_lock vbus_wake_lock; enum { @@ -114,6 +116,7 @@ struct htc_battery_info { int gpio_iset; int guage_driver; int m2a_cable_detect; + int force_no_rpc; int charger; }; @@ -204,6 +207,37 @@ int unregister_notifier_cable_status(struct notifier_block *nb) return blocking_notifier_chain_unregister(&cable_status_notifier_list, nb); } +/* -------------------------------------------------------------------------- */ +/* HTCLeo Dex Functions. */ +#if defined(CONFIG_MACH_HTCLEO) + +static int get_vbus_state(void) +{ + if (readl(MSM_SHARED_RAM_BASE + 0xEF20C)) + return 1; + else + return 0; +} + +void notify_cable_status(int status) +{ + pr_info("notify_cable_status(%d)\n", status); + msm_hsusb_set_vbus_state(status); + power_supply_changed(&htc_power_supplies[CHARGER_USB]); + power_supply_changed(&htc_power_supplies[CHARGER_AC]); + power_supply_changed(&htc_power_supplies[CHARGER_BATTERY]); +} + +// called from DEX intrrupt +void notify_vbus_change_intr(void) +{ + int vbus; + if (!htc_battery_initial) return; + vbus = get_vbus_state(); + notify_cable_status(vbus); +} + +#endif /* -------------------------------------------------------------------------- */ /* For sleep charging screen. */ static int zcharge_enabled; @@ -328,7 +362,6 @@ device_initcall(batt_debug_init); static int init_batt_gpio(void) { - if (htc_batt_info.gpio_mbat_in > 0 && gpio_request(htc_batt_info.gpio_mbat_in, "batt_detect") < 0) goto gpio_failed; @@ -613,9 +646,13 @@ static void usb_status_notifier_func(int online) blocking_notifier_call_chain(&cable_status_notifier_list, htc_batt_info.rep.charging_source, NULL); - power_supply_changed(&htc_power_supplies[CHARGER_AC]); - power_supply_changed(&htc_power_supplies[CHARGER_USB]); - power_supply_changed(&htc_power_supplies[CHARGER_BATTERY]); + if (htc_battery_initial) { + power_supply_changed(&htc_power_supplies[CHARGER_AC]); + power_supply_changed(&htc_power_supplies[CHARGER_USB]); + power_supply_changed(&htc_power_supplies[CHARGER_BATTERY]); + } else { + pr_err("\n\n ### htc_battery_code is not inited yet! ###\n\n"); + } update_wake_lock(htc_batt_info.rep.charging_source); #else mutex_lock(&htc_batt_info.lock); @@ -983,13 +1020,17 @@ static int htc_battery_get_charging_status(void) break; case CHARGER_USB: case CHARGER_AC: +#if !defined(CONFIG_BATTERY_DS2746) if ((htc_charge_full) && (htc_batt_info.rep.full_level == 100)) { htc_batt_info.rep.level = 100; } - +#endif level = htc_batt_info.rep.level; if (level == 100){ htc_charge_full = 1;} + else + htc_charge_full = 0; + if (htc_charge_full) ret = POWER_SUPPLY_STATUS_FULL; else if (htc_batt_info.rep.charging_enabled != 0) @@ -1016,12 +1057,20 @@ static int htc_battery_get_property(struct power_supply *psy, break; case POWER_SUPPLY_PROP_HEALTH: val->intval = POWER_SUPPLY_HEALTH_GOOD; - if (machine_is_paradise() && (htc_batt_info.rep.batt_temp >= 500 || - htc_batt_info.rep.batt_temp <= 0)) - val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; - else if (!machine_is_paradise() && (htc_batt_info.rep.batt_temp >= 480 || - htc_batt_info.rep.batt_temp <= 0)) - val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; + if (machine_is_paradise()) { + if (htc_batt_info.rep.batt_temp >= 500 || + htc_batt_info.rep.batt_temp <= 0) + val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; + } else if (machine_is_spade()) { + if (htc_batt_info.rep.batt_temp >= 450 || + htc_batt_info.rep.batt_temp <= 0) + val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; + } else { + if (htc_batt_info.rep.batt_temp >= 480 || + htc_batt_info.rep.batt_temp <= 0) + val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; + } + if (htc_batt_debug_mask & HTC_BATT_DEBUG_USER_QUERY) BATT_LOG("%s: %s: health=%d", __func__, psy->name, val->intval); break; @@ -1072,9 +1121,8 @@ static struct device_attribute htc_battery_attrs[] = { #ifdef CONFIG_HTC_BATTCHG_SMEM __ATTR(smem_raw, S_IRUGO, htc_battery_show_smem, NULL), __ATTR(smem_text, S_IRUGO, htc_battery_show_smem, NULL), -#else - __ATTR(batt_attr_text, S_IRUGO, htc_battery_show_batt_attr, NULL), #endif + __ATTR(batt_attr_text, S_IRUGO, htc_battery_show_batt_attr, NULL), }; enum { @@ -1196,7 +1244,6 @@ static ssize_t htc_battery_set_full_level(struct device *dev, { int rc = 0; unsigned long percent = 100; - unsigned long param = 0; percent = simple_strtoul(buf, NULL, 10); @@ -1216,9 +1263,8 @@ static ssize_t htc_battery_set_full_level(struct device *dev, mutex_lock(&htc_batt_info.lock); htc_full_level_flag = 1; htc_batt_info.rep.full_level = percent; - param = percent; blocking_notifier_call_chain(&cable_status_notifier_list, - 0xff, (void *) ¶m); + 0xff, (void *) &htc_batt_info.rep.full_level); mutex_unlock(&htc_batt_info.lock); } rc = 0; @@ -1290,7 +1336,7 @@ static int update_batt_info(void) ret = -1; } break; -#elif CONFIG_BATTERY_DS2746 +#elif defined(CONFIG_BATTERY_DS2746) case GUAGE_DS2746: if (ds2746_get_battery_info(&htc_batt_info.rep)) { BATT_ERR("%s: ds2746 read failed!!!", __func__); @@ -1380,10 +1426,93 @@ dont_need_update: return i; } +static irqreturn_t tps65200_int_detection(int irq, void *data) +{ + struct htc_battery_tps65200_int *ip = data; + + BATT_LOG("%s: over voltage is detected.", __func__); + + disable_irq_nosync(ip->chg_int); + + ip->tps65200_reg = 0; + + schedule_delayed_work(&ip->int_work, msecs_to_jiffies(200)); + + return IRQ_HANDLED; +} + +static void htc_battery_tps65200_int_func(struct work_struct *work) +{ + struct htc_battery_tps65200_int *ip; + int fault_bit; + ip = container_of(work, struct htc_battery_tps65200_int, + int_work.work); + + switch (ip->tps65200_reg) { + case CHECK_INT1: + /* read twice. First read to trigger TPS65200 clear fault bit + on INT1. Second read to make sure that fault bit is cleared + and call off ovp function.*/ + fault_bit = tps_set_charger_ctrl(CHECK_INT1); + BATT_LOG("INT1 value: %d", fault_bit); + fault_bit = tps_set_charger_ctrl(CHECK_INT1); + + if (fault_bit) { +#ifdef CONFIG_HTC_BATTCHG_SMEM + smem_batt_info->over_vchg = 1; +#else + htc_batt_info.rep.over_vchg = 1; +#endif + power_supply_changed(&htc_power_supplies[CHARGER_BATTERY]); + schedule_delayed_work(&ip->int_work, + msecs_to_jiffies(5000)); + BATT_LOG("OVER_VOLTAGE: " + "over voltage fault bit on TPS65200 is raised:" + " %d", fault_bit); + } else { +#ifdef CONFIG_HTC_BATTCHG_SMEM + smem_batt_info->over_vchg = 0; +#else + htc_batt_info.rep.over_vchg = 0; +#endif + cancel_delayed_work(&ip->int_work); + enable_irq(ip->chg_int); + } + break; + default: + fault_bit = tps_set_charger_ctrl(CHECK_INT2); + BATT_LOG("Read TPS65200 INT2 register value: %x", fault_bit); + if (fault_bit) { + fault_bit = tps_set_charger_ctrl(CHECK_INT2); + BATT_LOG("Read TPS65200 INT2 register value: %x" + , fault_bit); + fault_bit = tps_set_charger_ctrl(CHECK_INT2); + BATT_LOG("Read TPS65200 INT2 register value: %x" + , fault_bit); + fault_bit = tps_set_charger_ctrl(CHECK_CONTROL); +#ifdef CONFIG_HTC_BATTCHG_SMEM + smem_batt_info->reserve4 = 1; +#endif + cancel_delayed_work(&ip->int_work); + enable_irq(ip->chg_int); + } else { + fault_bit = tps_set_charger_ctrl(CHECK_INT1); + BATT_LOG("Read TPS65200 INT1 register value: %x" + , fault_bit); + if (fault_bit) { + ip->tps65200_reg = CHECK_INT1; + schedule_delayed_work(&ip->int_work, + msecs_to_jiffies(200)); + } + } + break; + } +} + static int htc_battery_core_probe(struct platform_device *pdev) { int i, rc; - + pr_info("%s\n", __func__); /* init battery gpio */ if (htc_batt_info.charger == LINEAR_CHARGER) { if ((rc = init_batt_gpio()) < 0) { @@ -1399,12 +1528,14 @@ static int htc_battery_core_probe(struct platform_device *pdev) */ htc_batt_info.present = 1; - /* init rpc */ - endpoint = msm_rpc_connect(APP_BATT_PROG, APP_BATT_VER, 0); - if (IS_ERR(endpoint)) { - BATT_ERR("%s: init rpc failed! rc = %ld", - __func__, PTR_ERR(endpoint)); - return -EINVAL; + if(!htc_batt_info.force_no_rpc) { + /* init rpc */ + endpoint = msm_rpc_connect(APP_BATT_PROG, APP_BATT_VER, 0); + if (IS_ERR(endpoint)) { + BATT_ERR("%s: init rpc failed! rc = %ld", + __func__, PTR_ERR(endpoint)); + return -EINVAL; + } } /* init power supplier framework */ @@ -1421,16 +1552,21 @@ static int htc_battery_core_probe(struct platform_device *pdev) * the battery status in case of we lost some info */ htc_battery_initial = 1; + + if(htc_batt_info.force_no_rpc) { + update_batt_info(); + } + else { + mutex_lock(&htc_batt_info.rpc_lock); + htc_batt_info.rep.charging_source = CHARGER_BATTERY; + if (htc_get_batt_info(&htc_batt_info.rep) < 0) + BATT_ERR("%s: get info failed", __func__); - mutex_lock(&htc_batt_info.rpc_lock); - htc_batt_info.rep.charging_source = CHARGER_BATTERY; - if (htc_get_batt_info(&htc_batt_info.rep) < 0) - BATT_ERR("%s: get info failed", __func__); - - if (htc_rpc_set_delta(1) < 0) - BATT_ERR("%s: set delta failed", __func__); - htc_batt_info.update_time = jiffies; - mutex_unlock(&htc_batt_info.rpc_lock); + if (htc_rpc_set_delta(1) < 0) + BATT_ERR("%s: set delta failed", __func__); + htc_batt_info.update_time = jiffies; + mutex_unlock(&htc_batt_info.rpc_lock); + } return 0; } @@ -1528,7 +1664,6 @@ static int ds2784_notifier_func(struct notifier_block *nfb, unsigned long action, void *param) { u8 arg = 0; - if (param) arg = *(u8 *)param; @@ -1562,12 +1697,14 @@ static struct notifier_block ds2784_notifier = { static int htc_battery_probe(struct platform_device *pdev) { + int rc = 0; struct htc_battery_platform_data *pdata = pdev->dev.platform_data; htc_batt_info.device_id = pdev->id; htc_batt_info.gpio_usb_id = pdata->gpio_usb_id; htc_batt_info.guage_driver = pdata->guage_driver; htc_batt_info.m2a_cable_detect = pdata->m2a_cable_detect; + htc_batt_info.force_no_rpc = pdata->force_no_rpc; htc_batt_info.func_show_batt_attr = pdata->func_show_batt_attr; htc_batt_info.charger = pdata->charger; htc_batt_info.rep.full_level = 100; @@ -1584,11 +1721,35 @@ static int htc_battery_probe(struct platform_device *pdev) #ifdef CONFIG_BATTERY_DS2784 if (pdata->guage_driver == GUAGE_DS2784) ds2784_register_notifier(&ds2784_notifier); -#elif CONFIG_BATTERY_DS2746 +#elif defined(CONFIG_BATTERY_DS2746) if (pdata->guage_driver == GUAGE_DS2746) ds2746_register_notifier(&ds2784_notifier); #endif + if (system_rev >= 1 || machine_is_htcleo()) { + if (pdata->int_data.chg_int) { + BATT_LOG("init over voltage interrupt detection."); + INIT_DELAYED_WORK(&pdata->int_data.int_work, + htc_battery_tps65200_int_func); + + rc = request_irq(pdata->int_data.chg_int, + tps65200_int_detection, + IRQF_TRIGGER_LOW, + "over_voltage_interrupt", + &pdata->int_data); + + if (rc) { + BATT_LOG("request irq failed"); + return rc; + } + } + } +#if defined(CONFIG_MACH_HTCLEO) + if(pdata->force_no_rpc) { + htc_battery_core_probe(pdev); + htc_cable_status_update(get_vbus_state()); + } +#endif return 0; } diff --git a/arch/arm/mach-msm/include/mach/htc_battery.h b/arch/arm/mach-msm/include/mach/htc_battery.h index 9b1b4d0e..d4e758dc 100644 --- a/arch/arm/mach-msm/include/mach/htc_battery.h +++ b/arch/arm/mach-msm/include/mach/htc_battery.h @@ -22,7 +22,10 @@ #define SET_ICL500 0X65 #define SET_ICL100 0X66 #define CHECK_INT2 0X67 - +#define OVERTEMP_VREG_4060 0XC8 +#define NORMALTEMP_VREG_4200 0XC9 +#define CHECK_INT1 0XCA +#define CHECK_CONTROL 0xCB /* information about the system we're running on */ extern unsigned int system_rev; @@ -67,6 +70,13 @@ struct battery_info_reply { u32 over_vchg; /* 0:normal, 1:over voltage charger */ s32 eval_current; /* System loading current from ADC */ }; + +struct htc_battery_tps65200_int { + int chg_int; + int tps65200_reg; + struct delayed_work int_work; +}; + struct htc_battery_platform_data { int (*func_show_batt_attr)(struct device_attribute *attr, char *buf); @@ -77,6 +87,8 @@ struct htc_battery_platform_data { int guage_driver; int m2a_cable_detect; int charger; + struct htc_battery_tps65200_int int_data; + int force_no_rpc; }; #if CONFIG_HTC_BATTCHG diff --git a/drivers/power/ds2746_battery.c b/drivers/power/ds2746_battery.c new file mode 100644 index 00000000..931191b4 --- /dev/null +++ b/drivers/power/ds2746_battery.c @@ -0,0 +1,1264 @@ +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Copyright (c) 2010 High Tech Computer Corporation + +Module Name: + + ds2746_battery.c + +Abstract: + + This module implements the power algorithm, including below concepts: + 1. Charging function control. + 2. Charging full condition. + 3. Recharge control. + 4. Battery capacity maintainance. + 5. Battery full capacity calibration. + +Original Auther: + + Andy.YS Wang June-01-2010 +---------------------------------------------------------------------------------*/ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +/*#include */ +#include +#include +#include +#include +#include "../../arch/arm/mach-msm/proc_comm.h" +#include /* for i2c_adapter, i2c_client define*/ +/*#include "../w1/w1.h"*/ +/*#include "../w1/slaves/w1_ds2784.h"*/ +#include +#include + +struct ds2746_device_info { + + struct device *dev; + struct device *w1_dev; + struct workqueue_struct *monitor_wqueue; + struct work_struct monitor_work; + /* lock to protect the battery info */ + struct mutex lock; + /* DS2784 data, valid after calling ds2784_battery_read_status() */ + unsigned long update_time; /* jiffies when data read */ + struct alarm alarm; + struct wake_lock work_wake_lock; + u8 slow_poll; + ktime_t last_poll; +}; +static struct wake_lock vbus_wake_lock; + +/*======================================================================================== + +HTC power algorithm helper member and functions + +========================================================================================*/ + +static struct poweralg_type poweralg = {0}; +static struct poweralg_config_type config = {0}; +static struct poweralg_config_type debug_config = {0}; + +#define FAST_POLL (1 * 60) +#define SLOW_POLL (10 * 60) +#define PREDIC_POLL 20 + +#define SOURCE_NONE 0 +#define SOURCE_USB 1 +#define SOURCE_AC 2 + +#define CHARGE_OFF 0 +#define CHARGE_SLOW 1 +#define CHARGE_FAST 2 + +#define BATTERY_ID_UNKNOWN 0 +#define HTC_BATTERY_DS2746_DEBUG_ENABLE 0 + +/* DS2746 I2C BUS*/ +#define DS2746_I2C_BUS_ID 0 +#define DS2746_I2C_SLAVE_ADDR 0x26 + +/*======================================================================================== + +IC dependent defines + +========================================================================================*/ + +/* DS2746 I2C register address*/ +#define DS2746_STATUS_REG 0x01 +#define DS2746_AUX0_MSB 0x08 +#define DS2746_AUX0_LSB 0x09 +#define DS2746_AUX1_MSB 0x0A +#define DS2746_AUX1_LSB 0x0B +#define DS2746_VOLT_MSB 0x0C +#define DS2746_VOLT_LSB 0x0D +#define DS2746_CURRENT_MSB 0x0E +#define DS2746_CURRENT_LSB 0x0F +#define DS2746_ACR_MSB 0x10 +#define DS2746_ACR_LSB 0x11 + +/* DS2746 I2C I/O*/ +static struct i2c_adapter *i2c2 = NULL; +static struct i2c_client *ds2746_i2c = NULL; +static int htc_battery_initial = 0; + +int ds2746_i2c_write_u8(u8 value, u8 reg) +{ + int ret; + u8 buf[2]; + struct i2c_msg *msg; + struct i2c_msg xfer_msg[1]; + + /* [MSG1] fill the register address data and fill the data Tx buffer */ + msg = &xfer_msg[0]; + msg->addr = ds2746_i2c->addr; + msg->len = 2; + msg->flags = 0; /* Read the register value */ + msg->buf = buf; + + buf[0] = reg; + buf[1] = value; + + ret = i2c_transfer(ds2746_i2c->adapter, xfer_msg, 1); + if (ret <= 0){ + printk(DRIVER_ZONE "[%s] fail.\n", __func__); + } + +#if HTC_BATTERY_DS2746_DEBUG_ENABLE + printk(DRIVER_ZONE "[%s] ds2746[0x%x]<-0x%x.\n", __func__, reg, value); +#endif + + return ret; +} + +int ds2746_i2c_read_u8(u8 *value, u8 reg) +{ + int ret; + struct i2c_msg *msg; + struct i2c_msg xfer_msg[2]; + + /* [MSG1] fill the register address data */ + msg = &xfer_msg[0]; + msg->addr = ds2746_i2c->addr; + msg->len = 1; + msg->flags = 0; /* Read the register value */ + msg->buf = ® + /* [MSG2] fill the data rx buffer */ + msg = &xfer_msg[1]; + msg->addr = ds2746_i2c->addr; + msg->len = 1; + msg->flags = I2C_M_RD; /* Read the register value */ + msg->buf = value; + + ret = i2c_transfer(ds2746_i2c->adapter, xfer_msg, 2); + if (ret <= 0){ + printk(DRIVER_ZONE "[%s] fail.\n", __func__); + } + +#if HTC_BATTERY_DS2746_DEBUG_ENABLE + printk(DRIVER_ZONE "[%s] ds2746[0x%x]=0x%x.\n", __func__, reg, *value); +#endif + + return ret; +} + +static void ds2746_i2c_exit(void) +{ + if (ds2746_i2c != NULL){ + kfree(ds2746_i2c); + ds2746_i2c = NULL; + } + + if (i2c2 != NULL){ + i2c_put_adapter(i2c2); + i2c2 = NULL; + } +} + +static int ds2746_i2c_init(void) +{ + i2c2 = i2c_get_adapter(DS2746_I2C_BUS_ID); + ds2746_i2c = kzalloc(sizeof(*ds2746_i2c), GFP_KERNEL); + + if (i2c2 == NULL || ds2746_i2c == NULL){ + printk(DRIVER_ZONE "[%s] fail (0x%x, 0x%x).\n", + __func__, + (int) i2c2, + (int) ds2746_i2c); + ds2746_i2c_exit(); + return -ENOMEM; + } + + ds2746_i2c->adapter = i2c2; + ds2746_i2c->addr = DS2746_I2C_SLAVE_ADDR; + + return 0; +} + +/*======================================================================================== + + HTC supporting MFG testing member and functions + +=========================================================================================*/ + +static BOOL b_is_charge_off_by_bounding = FALSE; +static void bounding_fullly_charged_level(int upperbd) +{ + static int pingpong = 1; + int lowerbd; + int current_level; + b_is_charge_off_by_bounding = FALSE; + if (upperbd <= 0) + return; /* doesn't activated this function */ + lowerbd = upperbd - 5; /* 5% range */ + + if (lowerbd < 0) + lowerbd = 0; + current_level = CEILING(poweralg.capacity_01p, 10); + + if (pingpong == 1 && upperbd <= current_level) { + printk(DRIVER_ZONE "MFG: lowerbd=%d, upperbd=%d, current=%d, pingpong:1->0 turn off\n", lowerbd, upperbd, current_level); + b_is_charge_off_by_bounding = TRUE; + pingpong = 0; + } else if (pingpong == 0 && lowerbd < current_level) { + printk(DRIVER_ZONE "MFG: lowerbd=%d, upperbd=%d, current=%d, toward 0, turn off\n", lowerbd, upperbd, current_level); + b_is_charge_off_by_bounding = TRUE; + } else if (pingpong == 0 && current_level <= lowerbd) { + printk(DRIVER_ZONE "MFG: lowerbd=%d, upperbd=%d, current=%d, pingpong:0->1 turn on\n", lowerbd, upperbd, current_level); + pingpong = 1; + } else { + printk(DRIVER_ZONE "MFG: lowerbd=%d, upperbd=%d, current=%d, toward %d, turn on\n", lowerbd, upperbd, current_level, pingpong); + } + +} + +static BOOL is_charge_off_by_bounding_condition(void) +{ + return b_is_charge_off_by_bounding; +} + +void calibrate_id_ohm(struct battery_type *battery) +{ + if (!poweralg.charging_source || !poweralg.charging_enable){ + battery->id_ohm += 500; /* If device is in discharge mode, Rid=Rid_1 + 0.5Kohm*/ + } + else if (poweralg.charging_source == 2 && battery->current_mA >= 400 && battery->id_ohm >= 1500){ + battery->id_ohm -= 1500; /* If device is in charge mode and ISET=1 (charge current is <800mA), Rid=Rid_1 - 1.5Kohm*/ + } + else if (battery->id_ohm >= 700){ + battery->id_ohm -= 700; /* If device is in charge mode and ISET=0 (charge current is <400mA), Rid=Rid_1 - 0.7Kohm*/ + } +} + +static BOOL is_charging_avaiable(void) +{ + if (poweralg.is_software_charger_timeout) return FALSE; + if (!poweralg.protect_flags.is_charging_enable_available)return FALSE; + if (!poweralg.is_cable_in) return FALSE; + if (poweralg.charge_state == CHARGE_STATE_PENDING) return FALSE; + if (poweralg.charge_state == CHARGE_STATE_FULL_PENDING) return FALSE; + if (poweralg.charge_state == CHARGE_STATE_PREDICTION) return FALSE; + if (is_charge_off_by_bounding_condition()) return FALSE; + return TRUE; /* CHARGE_STATE_UNKNOWN, SET_LED_BATTERY_CHARGING is available to be charged by default*/ +} + +static BOOL is_high_current_charging_avaialable(void) +{ + if (!poweralg.protect_flags.is_charging_high_current_avaialble) return FALSE; + if (!poweralg.is_china_ac_in) return FALSE; + if (poweralg.charge_state == CHARGE_STATE_UNKNOWN) return FALSE; + return TRUE; +} + +static void update_next_charge_state(void) +{ + static UINT32 count_charging_full_condition; + static UINT32 count_charge_over_load; + int next_charge_state; + int i; + + /* unknown -> prediction -> unknown -> discharge/charging/pending + charging -> full-wait-stable -> full-charging -> full-pending + full-pending -> full-charging -> charging + *(cable in group) -> discharge, charge-pending, dead + *(cable out group), full-wait-stable, charge-pending, dead -> charging*/ + + for (i = 0; i < 25; i++) /* maximun 25 times state transition to prevent from busy loop; ideally the transition time shall be less than 5 times.*/ + { + next_charge_state = poweralg.charge_state; + + /* 0. enter prediction state or not*/ + if (poweralg.charge_state == CHARGE_STATE_UNKNOWN){ + if (poweralg.battery.is_power_on_reset || config.debug_always_predict){ + if (poweralg.protect_flags.is_battery_dead){ + /* keep poweralg.charge_state unchanged, set capacity to 0% directly*/ + printk(DRIVER_ZONE " dead battery, \ + p=0%%\n"); + poweralg.capacity_01p = 0; + battery_capacity_update(&poweralg.battery, poweralg.capacity_01p); + + poweralg.fst_discharge_capacity_01p = poweralg.capacity_01p; + poweralg.fst_discharge_acr_mAh = poweralg.battery.charge_counter_mAh; + } + else{ + /* battery replaced, recalculate capacity based on battery voltage*/ + printk(DRIVER_ZONE " start predict discharge...\n"); + next_charge_state = CHARGE_STATE_PREDICTION; + } + + config.debug_always_predict = FALSE; + } + } + + if (next_charge_state == poweralg.charge_state){ + /*---------------------------------------------------------------------------------------------------*/ + /* 1. cable in group*/ + if (poweralg.charge_state == CHARGE_STATE_UNKNOWN || + poweralg.charge_state == CHARGE_STATE_CHARGING || + poweralg.charge_state == CHARGE_STATE_PENDING || + poweralg.charge_state == CHARGE_STATE_FULL_WAIT_STABLE || + poweralg.charge_state == CHARGE_STATE_FULL_CHARGING || + poweralg.charge_state == CHARGE_STATE_FULL_PENDING){ + if (!poweralg.is_cable_in){ + next_charge_state = CHARGE_STATE_DISCHARGE; + } + else if (!poweralg.protect_flags.is_charging_enable_available){ + next_charge_state = CHARGE_STATE_PENDING; + } + } + + /*---------------------------------------------------------------------------------------------------*/ + /* 2. cable out group*/ + if (poweralg.charge_state == CHARGE_STATE_UNKNOWN || + poweralg.charge_state == CHARGE_STATE_DISCHARGE){ + if (poweralg.is_cable_in){ + next_charge_state = CHARGE_STATE_CHARGING; + } + } + } + + /*---------------------------------------------------------------------------------------------------*/ + /* 3. state handler/transition, if the charge state is not changed due to cable/protect flags*/ + if (next_charge_state == poweralg.charge_state){ + switch (poweralg.charge_state){ + case CHARGE_STATE_PREDICTION: + { + UINT32 end_time_ms = BAHW_MyGetMSecs(); + + if (end_time_ms - poweralg.state_start_time_ms >= + config.predict_timeout_sec * 1000){ + + printk(DRIVER_ZONE "predict done [%d->%d]\n", poweralg.state_start_time_ms, + end_time_ms); + next_charge_state = CHARGE_STATE_UNKNOWN; + } + } + break; + case CHARGE_STATE_CHARGING: + if (!poweralg.battery.is_power_on_reset){ + /* -> full-charging, pending, dead*/ + if (poweralg.capacity_01p > 990){ + /* only ever charge-full, the capacity can be larger than 99.0%*/ + next_charge_state = CHARGE_STATE_FULL_CHARGING; + } + else if (poweralg.battery.voltage_mV >= config.full_charging_mv && + poweralg.battery.current_mA >= 0 && + poweralg.battery.current_mA <= config.full_charging_ma){ + /* meet charge full terminate condition, check again*/ + next_charge_state = CHARGE_STATE_FULL_WAIT_STABLE; + } + } + + if (poweralg.battery.current_mA <= 0){ + /* count_charge_over_load is 5 as max*/ + if (count_charge_over_load < 5) + count_charge_over_load++; + else + poweralg.is_charge_over_load = TRUE; + } + else{ + count_charge_over_load = 0; + poweralg.is_charge_over_load = FALSE; + } + + /* is_software_charger_timeout: only triggered when AC adapter in*/ + if (config.software_charger_timeout_sec && poweralg.is_china_ac_in){ + /* software charger timer is enabled; for AC charge only*/ + UINT32 end_time_ms = BAHW_MyGetMSecs(); + + if (end_time_ms - poweralg.state_start_time_ms >= + config.software_charger_timeout_sec * 1000){ + + printk(DRIVER_ZONE "software charger timer timeout [%d->%d]\n", + poweralg.state_start_time_ms, + end_time_ms); + poweralg.is_software_charger_timeout = TRUE; + } + } + break; + case CHARGE_STATE_FULL_WAIT_STABLE: + { + /* -> full-charging, pending, dead*/ + if (poweralg.battery.voltage_mV >= config.full_charging_mv && + poweralg.battery.current_mA >= 0 && + poweralg.battery.current_mA <= config.full_charging_ma){ + + count_charging_full_condition++; + } + else{ + count_charging_full_condition = 0; + next_charge_state = CHARGE_STATE_CHARGING; + } + + if (count_charging_full_condition >= 3){ + + poweralg.capacity_01p = 1000; + battery_capacity_update(&poweralg.battery, poweralg.capacity_01p); + + next_charge_state = CHARGE_STATE_FULL_CHARGING; + } + } + break; + case CHARGE_STATE_FULL_CHARGING: + { + /* -> full-pending, charging*/ + UINT32 end_time_ms = BAHW_MyGetMSecs(); + + if (poweralg.battery.voltage_mV < config.voltage_exit_full_mv){ + if (poweralg.capacity_01p > 990) + poweralg.capacity_01p = 990; + next_charge_state = CHARGE_STATE_CHARGING; + } + else if (config.full_pending_ma != 0 && + poweralg.battery.current_mA >= 0 && + poweralg.battery.current_mA <= config.full_pending_ma){ + + printk(DRIVER_ZONE " charge-full pending(%dmA)(%d:%d)\n", + poweralg.battery.current_mA, + poweralg.state_start_time_ms, + end_time_ms); + + next_charge_state = CHARGE_STATE_FULL_PENDING; + } + else if (end_time_ms - poweralg.state_start_time_ms >= + config.full_charging_timeout_sec * 1000){ + + printk(DRIVER_ZONE " charge-full (expect:%dsec)(%d:%d)\n", + config.full_charging_timeout_sec, + poweralg.state_start_time_ms, + end_time_ms); + next_charge_state = CHARGE_STATE_FULL_PENDING; + } + } + break; + case CHARGE_STATE_FULL_PENDING: + if ((poweralg.battery.voltage_mV >= 0 && + poweralg.battery.voltage_mV < config.voltage_recharge_mv) || + (poweralg.battery.RARC_01p >= 0 && + poweralg.battery.RARC_01p <= config.capacity_recharge_p * 10)){ + /* -> full-charging*/ + next_charge_state = CHARGE_STATE_FULL_CHARGING; + } + break; + case CHARGE_STATE_PENDING: + case CHARGE_STATE_DISCHARGE: + { + UINT32 end_time_ms = BAHW_MyGetMSecs(); + + if (!poweralg.is_voltage_stable){ + if (end_time_ms - poweralg.state_start_time_ms >= + config.wait_votlage_statble_sec * 1000){ + + printk(DRIVER_ZONE " voltage stable\n"); + poweralg.is_voltage_stable = TRUE; + } + } + } + + if (poweralg.is_cable_in && + poweralg.protect_flags.is_charging_enable_available){ + /* -> charging*/ + next_charge_state = CHARGE_STATE_CHARGING; + } + break; + } + } + + /*---------------------------------------------------------------------------------------------------*/ + /* 4. state transition*/ + if (next_charge_state != poweralg.charge_state){ + /* state exit*/ + switch (poweralg.charge_state){ + case CHARGE_STATE_UNKNOWN: + poweralg.capacity_01p = poweralg.battery.RARC_01p; + if (poweralg.capacity_01p > 990) + poweralg.capacity_01p = 990; + if (poweralg.capacity_01p < 0) + poweralg.capacity_01p = 0; + + poweralg.fst_discharge_capacity_01p = poweralg.capacity_01p; + poweralg.fst_discharge_acr_mAh = poweralg.battery.charge_counter_mAh; + break; + case CHARGE_STATE_PREDICTION: + battery_param_update(&poweralg.battery, + &poweralg.protect_flags); + + poweralg.capacity_01p = poweralg.battery.KADC_01p; + if (poweralg.capacity_01p > 990) + poweralg.capacity_01p = 990; + if (poweralg.capacity_01p < 0) + poweralg.capacity_01p = 0; + battery_capacity_update(&poweralg.battery, + poweralg.capacity_01p); + + poweralg.fst_discharge_capacity_01p = poweralg.capacity_01p; + poweralg.fst_discharge_acr_mAh = poweralg.battery.charge_counter_mAh; + break; + } + + /* state init*/ + poweralg.state_start_time_ms = BAHW_MyGetMSecs(); + + switch (next_charge_state){ + case CHARGE_STATE_DISCHARGE: + case CHARGE_STATE_PENDING: + /*! star_lee 20100426 - always set ACR=FULL when discharge starts and ACR>FULL*/ + if (poweralg.battery.RARC_01p > 1000) + battery_capacity_update(&poweralg.battery, 1000); + + poweralg.is_need_calibrate_at_49p = TRUE; + poweralg.is_need_calibrate_at_14p = TRUE; + poweralg.fst_discharge_capacity_01p = poweralg.capacity_01p; + poweralg.fst_discharge_acr_mAh = poweralg.battery.charge_counter_mAh; + poweralg.is_voltage_stable = FALSE; + + break; + case CHARGE_STATE_CHARGING: + poweralg.is_software_charger_timeout = FALSE; /* reset software charger timer every time when charging re-starts*/ + poweralg.is_charge_over_load = FALSE; + count_charge_over_load = 0; + poweralg.battery.charge_full_real_mAh = poweralg.battery.charge_full_design_mAh; + battery_capacity_update(&poweralg.battery, poweralg.capacity_01p); + break; + case CHARGE_STATE_FULL_WAIT_STABLE: + /* set to 0 first; the cournter will be add to 1 soon in CHARGE_STATE_FULL_WAIT_STABLE state handler*/ + count_charging_full_condition = 0; + break; + } + + printk(DRIVER_ZONE " state change(%d->%d), full count=%d, over load count=%d [%d]\n", + poweralg.charge_state, + next_charge_state, + count_charging_full_condition, + count_charge_over_load, + poweralg.state_start_time_ms); + + poweralg.charge_state = next_charge_state; + continue; + } + + break; + } +} + +static void __update_capacity(void) +{ + INT32 next_capacity_01p; + +#if HTC_BATTERY_DS2746_DEBUG_ENABLE + pr_info("ds2746_batt:__update_capacity start\n"); +#endif + if (poweralg.charge_state == CHARGE_STATE_PREDICTION || + poweralg.charge_state == CHARGE_STATE_UNKNOWN){ + + /*! star_lee 20100429 - return 99%~25% when in prediction mode*/ + poweralg.capacity_01p = max(min(990, poweralg.battery.KADC_01p), 250); + printk(DRIVER_ZONE "fake percentage (%d) during prediction.\n", + poweralg.capacity_01p); + } + else if (poweralg.charge_state == CHARGE_STATE_FULL_CHARGING || + poweralg.charge_state == CHARGE_STATE_FULL_PENDING){ + + poweralg.capacity_01p = 1000; + } + else if (!is_charging_avaiable() && poweralg.is_voltage_stable){ + /* DISCHARGE ALG: capacity is based on KADC/RARC; only do this after cable in 3 minutes later*/ + if (poweralg.battery.KADC_01p <= 0){ + if (poweralg.capacity_01p > 0) + poweralg.capacity_01p -= 10; + if (poweralg.capacity_01p > 0){ + /* capacity is still not 0 when KADC is 0; record capacity for next boot time*/ + battery_capacity_update(&poweralg.battery, poweralg.capacity_01p); + } + } + else{ + if ((config.enable_weight_percentage) && (poweralg.capacity_01p <150 || + poweralg.battery.RARC_01p> poweralg.battery.KADC_01p)){ + +#define Padc 200 +#define Pw 5 +/* 500= 1000) + next_capacity_01p = 1000; + if (next_capacity_01p < 0) + next_capacity_01p = 0; + + if (next_capacity_01p < poweralg.capacity_01p){ + poweralg.capacity_01p -= min(10, poweralg.capacity_01p-next_capacity_01p); + } + } + + if (config.enable_full_calibration){ + if (poweralg.is_need_calibrate_at_49p && + poweralg.capacity_01p <= 500 && + poweralg.fst_discharge_capacity_01p >= 600){ + + poweralg.battery.charge_full_real_mAh = (poweralg.fst_discharge_acr_mAh-poweralg.battery.charge_counter_mAh)*1000/ + (poweralg.fst_discharge_capacity_01p-poweralg.capacity_01p); + + battery_capacity_update(&poweralg.battery, poweralg.capacity_01p); + + poweralg.is_need_calibrate_at_49p = FALSE; + poweralg.fst_discharge_capacity_01p = poweralg.capacity_01p; + poweralg.fst_discharge_acr_mAh = poweralg.battery.charge_counter_mAh; + + printk(DRIVER_ZONE " 1.full calibrate: full=%d\n", + poweralg.battery.charge_full_real_mAh); + } + else if (poweralg.is_need_calibrate_at_14p && + poweralg.capacity_01p <= 150 && + poweralg.fst_discharge_capacity_01p >= 250){ + poweralg.battery.charge_full_real_mAh = (poweralg.fst_discharge_acr_mAh-poweralg.battery.charge_counter_mAh)*1000/ + (poweralg.fst_discharge_capacity_01p - poweralg.capacity_01p); + + battery_capacity_update(&poweralg.battery, poweralg.capacity_01p); + + poweralg.is_need_calibrate_at_14p = FALSE; + poweralg.fst_discharge_capacity_01p = poweralg.capacity_01p; + poweralg.fst_discharge_acr_mAh = poweralg.battery.charge_counter_mAh; + + printk(DRIVER_ZONE " 2.full calibrate: full=%d\n", + poweralg.battery.charge_full_real_mAh); + } + } + } + else{ + /* CHARGE ALG: capacity is always based on ACR + 1. plus 1% as max when charge, if the orignal capacity is <= 99%, the result is no more than 99% + 2. minus 1% as max when discharge, not less than 0%*/ + next_capacity_01p = poweralg.battery.RARC_01p; + + if (next_capacity_01p > 1000) + next_capacity_01p = 1000; + if (next_capacity_01p < 0) + next_capacity_01p = 0; + + if (next_capacity_01p > poweralg.capacity_01p){ + /* charge case*/ + next_capacity_01p = poweralg.capacity_01p + min(next_capacity_01p - poweralg.capacity_01p, 10); + if (poweralg.capacity_01p > 990) + poweralg.capacity_01p = next_capacity_01p; + else + poweralg.capacity_01p = min(next_capacity_01p, 990); + } + else if (next_capacity_01p < poweralg.capacity_01p){ + /* discharge case*/ + poweralg.capacity_01p -= min(poweralg.capacity_01p - next_capacity_01p, 10); + if (poweralg.capacity_01p < 0) + poweralg.capacity_01p = 0; + } + } +} + +/*======================================================================================== + +HTC power algorithm implemetation + +========================================================================================*/ + +int get_state_check_interval_min_sec(void) +{ + /*the minimal check interval of each states in seconds + reserve for change polling rate + UINT32 elapse_time_ms = BAHW_MyGetMSecs() - poweralg.state_start_time_ms; + switch (poweralg.charge_state) + { + case CHARGE_STATE_FULL_WAIT_STABLE: + //! star_lee 20100429 - takes 30 seconds(10 seconds*3 times) to confirm charge full condition + return 10; + case CHARGE_STATE_PREDICTION: + return min(config.predict_timeout_sec, max((INT32)(config.predict_timeout_sec - elapse_time_ms/1000), (INT32)1)); + default: + if ( BAHW_IsChargeSourceIn() ) return config.polling_time_in_charging_sec; + else return config.polling_time_in_discharging_sec; + } + */ + return 0; +} + +BOOL do_power_alg(BOOL is_event_triggered) +{ + /* is_event_triggered - TRUE: handle event only, do not update capacity; FALSE; always update capacity*/ + static BOOL s_bFirstEntry = TRUE; + static UINT32 s_pre_time_ms; + static INT32 s_level; + + UINT32 now_time_ms = BAHW_MyGetMSecs(); + + /*------------------------------------------------------ + 1 get battery data and update charge state*/ + if (!battery_param_update(&poweralg.battery, &poweralg.protect_flags)){ + printk(DRIVER_ZONE "battery_param_update fail, please retry next time.\n"); + return FALSE; + } + + update_next_charge_state(); + + /*----------------------------------------------------- + 2 calculate battery capacity (predict if necessary)*/ + if (s_bFirstEntry || now_time_ms - s_pre_time_ms > 10000 || !is_event_triggered){ + /* DO not update capacity when plug/unplug cable less than 10 seconds*/ + __update_capacity(); + + s_bFirstEntry = FALSE; + s_pre_time_ms = now_time_ms; + } + + if (config.debug_disable_shutdown){ + if (poweralg.capacity_01p <= 0){ + poweralg.capacity_01p = 1; + } + } + + s_level = CEILING(poweralg.capacity_01p, 10); + if (CEILING(poweralg.last_capacity_01p, 10) != s_level || + poweralg.battery.last_temp_01c != poweralg.battery.temp_01c) { + + poweralg.battery.last_temp_01c = poweralg.battery.temp_01c; + poweralg.last_capacity_01p = poweralg.capacity_01p; + ds2746_blocking_notify(DS2784_LEVEL_UPDATE, &s_level); + } + + bounding_fullly_charged_level(config.full_level); + + /*------------------------------------------------------ + 3 charging function change*/ + if (is_charging_avaiable()){ + if (is_high_current_charging_avaialable()){ + ds2746_charger_control(CHARGE_FAST); + } + else{ + ds2746_charger_control(CHARGE_SLOW); + } + } + else{ + ds2746_charger_control(CHARGE_OFF); + } + + if (config.debug_disable_hw_timer && poweralg.is_charge_over_load){ + ds2746_charger_control(CHARGE_OFF); + printk(DRIVER_ZONE "Toggle charger due to HW disable charger.\n"); + } + + /*------------------------------------------------------ + 4 debug messages and update os battery status*/ + + /*powerlog_to_file(&poweralg); + update_os_batt_status(&poweralg);*/ + +#if HTC_BATTERY_DS2746_DEBUG_ENABLE + printk(DRIVER_ZONE "[%d] P=%d cable=%d%d flags=%d%d%d debug=%d%d%d%d fst_discharge=%d/%d [%u]\n", + poweralg.charge_state, + poweralg.capacity_01p, + poweralg.is_cable_in, + poweralg.is_china_ac_in, + poweralg.protect_flags.is_charging_enable_available, + poweralg.protect_flags.is_charging_high_current_avaialble, + poweralg.protect_flags.is_battery_dead, + config.debug_disable_shutdown, + config.debug_fake_room_temp, + config.debug_disable_hw_timer, + config.debug_always_predict, + poweralg.fst_discharge_capacity_01p, + poweralg.fst_discharge_acr_mAh, + BAHW_MyGetMSecs()); +#endif + + return TRUE; +} + +void power_alg_init(struct poweralg_config_type *debug_config) +{ + /*------------------------------------------------------------- + 1. setup default poweralg data*/ + poweralg.charge_state = CHARGE_STATE_UNKNOWN; + poweralg.capacity_01p = 990; + poweralg.last_capacity_01p = poweralg.capacity_01p; + poweralg.fst_discharge_capacity_01p = 0; + poweralg.fst_discharge_acr_mAh = 0; + poweralg.is_need_calibrate_at_49p = TRUE; + poweralg.is_need_calibrate_at_14p = TRUE; + poweralg.is_charge_over_load = FALSE; + poweralg.is_china_ac_in = FALSE; + poweralg.is_cable_in = FALSE; + poweralg.is_voltage_stable = FALSE; + poweralg.is_software_charger_timeout = FALSE; + poweralg.state_start_time_ms = 0; + + if(get_cable_status() == SOURCE_USB) + { + poweralg.is_cable_in = TRUE; + poweralg.charging_source = SOURCE_USB; + ds2746_charger_control(CHARGE_SLOW); + } + else if (get_cable_status() == SOURCE_AC) + { + poweralg.is_cable_in = TRUE; + poweralg.is_china_ac_in = TRUE; + poweralg.charging_source = SOURCE_AC; + ds2746_charger_control(CHARGE_FAST); + } else{ + poweralg.charging_source = SOURCE_NONE; + } + /*------------------------------------------------------------- + 2. setup default config flags (board dependent)*/ + poweralg_config_init(&config); + + if (debug_config){ + config.debug_disable_shutdown = debug_config->debug_disable_shutdown; + config.debug_fake_room_temp = debug_config->debug_fake_room_temp; + config.debug_disable_hw_timer = debug_config->debug_disable_hw_timer; + config.debug_always_predict = debug_config->debug_always_predict; + } + + /* if ( BAHW_IsTestMode() ) + { + config.debug_disable_shutdown = TRUE; + config.debug_fake_room_temp = TRUE; + config.debug_disable_hw_timer = TRUE; + }*/ + + /*------------------------------------------------------------- + 3. setup default protect flags*/ + poweralg.protect_flags.is_charging_enable_available = TRUE; + poweralg.protect_flags.is_battery_dead = FALSE; + poweralg.protect_flags.is_charging_high_current_avaialble = FALSE; + poweralg.protect_flags.is_fake_room_temp = config.debug_fake_room_temp; + + /*------------------------------------------------------------- + 4. setup default battery structure*/ + battery_param_init(&poweralg.battery); + + /*pr_info("power alg inited with board name <%s>\n", HTC_BATT_BOARD_NAME);*/ +} + +void power_alg_preinit(void) +{ + /* make sure cable and battery is in when off mode charging*/ +} + +static BLOCKING_NOTIFIER_HEAD(ds2746_notifier_list); +int ds2746_register_notifier(struct notifier_block *nb) +{ +#if HTC_BATTERY_DS2746_DEBUG_ENABLE + pr_info("%s\n", __func__); +#endif + return blocking_notifier_chain_register(&ds2746_notifier_list, nb); +} + +int ds2746_unregister_notifier(struct notifier_block *nb) +{ + return blocking_notifier_chain_unregister(&ds2746_notifier_list, nb); +} + + +int ds2746_blocking_notify(unsigned long val, void *v) +{ + int chg_ctl; +#if HTC_BATTERY_DS2746_DEBUG_ENABLE + pr_info("%s\n", __func__); +#endif + + if (val == DS2784_CHARGING_CONTROL){ + chg_ctl = *(int *) v; + if (machine_is_passionc()){ + pr_info("[ds2746_batt] Switch charging %d\n", chg_ctl); + if (chg_ctl <= 2){ + gpio_direction_output(22, !(!!chg_ctl));/*PNC*/ + set_charger_ctrl(chg_ctl); + } + return 0; + } + else if (poweralg.battery.id_index != BATTERY_ID_UNKNOWN){ + /* only notify at changes */ + if (poweralg.charging_enable == chg_ctl) + return 0; + else + poweralg.charging_enable = chg_ctl; + } + else{ + /* poweralg.charging_enable = DISABLE; + v = DISABLE; + pr_info("[HTC_BATT] Unknow battery\n");*/ + if (poweralg.charging_enable == chg_ctl) + return 0; + else + poweralg.charging_enable = chg_ctl; + } + } + return blocking_notifier_call_chain(&ds2746_notifier_list, val, v); +} + + +int ds2746_get_battery_info(struct battery_info_reply *batt_info) +{ + batt_info->batt_id = poweralg.battery.id_index; /*Mbat ID*/ + batt_info->batt_vol = poweralg.battery.voltage_mV; /*VMbat*/ + batt_info->batt_temp = poweralg.battery.temp_01c; /*Temperature*/ + batt_info->batt_current = poweralg.battery.current_mA; /*Current*/ + batt_info->level = CEILING(poweralg.capacity_01p, 10); /*last_show%*/ + batt_info->charging_source = poweralg.charging_source; + batt_info->charging_enabled = poweralg.charging_enable; + batt_info->full_bat = poweralg.battery.charge_full_real_mAh; + return 0; +} +ssize_t htc_battery_show_attr(struct device_attribute *attr, char *buf) +{ + int len = 0; + pr_info("%s\n", __func__); + if (!strcmp(attr->attr.name, "batt_attr_text")){ + len += scnprintf(buf + + len, + PAGE_SIZE - + len, + "Percentage(%%): %d;\n" + "KADC(%%): %d;\n" + "RARC(%%): %d;\n" + "V_MBAT(mV): %d;\n" + "Main_battery_ID(Kohm): %d;\n" + "pd_M: %d;\n" + "Current(mA): %d;\n" + "Temp: %d;\n" + "Charging_source: %d;\n" + "ACR(mAh): %d;\n" + "FULL(mAh): %d;\n" + "1st_dis_percentage(%%): %d;\n" + "1st_dis_ACR: %d;\n", + CEILING(poweralg.capacity_01p, 10), + CEILING(poweralg.battery.KADC_01p, 10), + CEILING(poweralg.battery.RARC_01p, 10), + poweralg.battery.voltage_mV, + poweralg.battery.id_ohm, + poweralg.battery.pd_m, + poweralg.battery.current_mA, + CEILING(poweralg.battery.temp_01c, 10), + poweralg.charging_source, + poweralg.battery.charge_counter_mAh, + poweralg.battery.charge_full_real_mAh, + CEILING(poweralg.fst_discharge_capacity_01p, 10), + poweralg.fst_discharge_acr_mAh + ); + } + return len; +} + + +static int cable_status_handler_func(struct notifier_block *nfb, + unsigned long action, void *param) +{ + u32 cable_type = (u32) action; + pr_info("[ds2746_batt] cable change to %d\n", cable_type); + /* When the cable plug out, reset all the related flag, + Let algorithm machine to judge latest state */ + if (cable_type == 0){ + poweralg.is_cable_in = 0; + poweralg.is_china_ac_in = 0; + /*htc_batt_info.rep.OTP_Flag = 0; + htc_batt_info.rep.charging_sts_flag = 0; + htc_batt_info.full_charge_count = 0;*/ + } + else if (cable_type == 1){ + poweralg.is_cable_in = 1; + poweralg.is_china_ac_in = 0; + } + else if (cable_type == 2){ + poweralg.is_cable_in = 1; + poweralg.is_china_ac_in = 1; + } + else if (cable_type == 0xff){ + if (param) + config.full_level = *(INT32 *)param; + pr_info("[ds2746_batt] Set the full level to %d\n", config.full_level); + return NOTIFY_OK; + } + else if (cable_type == 0x10){ + poweralg.protect_flags.is_fake_room_temp = TRUE; + pr_info("[ds2746_batt] enable fake temp mode\n"); + return NOTIFY_OK; + } + + if (cable_type <= 2){ + poweralg.charging_source = cable_type; + ds2746_blocking_notify(DS2784_CHARGING_CONTROL, + &poweralg.charging_source); + } + return NOTIFY_OK; +} + +static struct notifier_block cable_status_handler = +{ + .notifier_call = cable_status_handler_func, +}; + +void ds2746_charger_control(int type) +{ + int chg_ctl = DISABLE; + int charge_type = type; + + switch (charge_type){ + case CHARGE_OFF: + /* CHARGER_EN is active low. Set to 1 to disable. */ + chg_ctl = DISABLE; + ds2746_blocking_notify(DS2784_CHARGING_CONTROL, &chg_ctl); + /*if (temp >= TEMP_CRITICAL) + pr_info("batt: charging OFF [OVERTEMP]\n"); + else if (htc_batt_info.rep.cooldown) + pr_info("batt: charging OFF [COOLDOWN]\n"); + else if (htc_batt_info.rep.battery_full) + pr_info("batt: charging OFF [FULL]\n"); + else*/ +#if HTC_BATTERY_DS2746_DEBUG_ENABLE + pr_info("batt: charging OFF\n"); +#endif + break; + case CHARGE_SLOW: + chg_ctl = ENABLE_SLOW_CHG; + ds2746_blocking_notify(DS2784_CHARGING_CONTROL, &chg_ctl); +#if HTC_BATTERY_DS2746_DEBUG_ENABLE + pr_info("batt: charging SLOW\n"); +#endif + break; + case CHARGE_FAST: + chg_ctl = ENABLE_FAST_CHG; + ds2746_blocking_notify(DS2784_CHARGING_CONTROL, &chg_ctl); +#if HTC_BATTERY_DS2746_DEBUG_ENABLE + pr_info("batt: charging FAST\n"); +#endif + break; + } +} + +static void ds2746_program_alarm(struct ds2746_device_info *di, int seconds) +{ + ktime_t low_interval = ktime_set(seconds - 10, 0); + ktime_t slack = ktime_set(20, 0); + ktime_t next; + + next = ktime_add(di->last_poll, low_interval); + + alarm_start_range(&di->alarm, next, ktime_add(next, slack)); +} + +static void ds2746_battery_work(struct work_struct *work) +{ + if (!htc_battery_initial) return; + struct ds2746_device_info *di = container_of(work, + struct ds2746_device_info, monitor_work); + unsigned long flags; + +#if HTC_BATTERY_DS2746_DEBUG_ENABLE + pr_info("[ds2746_batt] ds2746_battery_work*\n"); +#endif + do_power_alg(0); + get_state_check_interval_min_sec(); + di->last_poll = alarm_get_elapsed_realtime(); + + /* prevent suspend before starting the alarm */ + local_irq_save(flags); + + wake_unlock(&di->work_wake_lock); + if (poweralg.battery.is_power_on_reset) + ds2746_program_alarm(di, PREDIC_POLL); + else + ds2746_program_alarm(di, FAST_POLL); + + local_irq_restore(flags); +} + +static void ds2746_battery_alarm(struct alarm *alarm) +{ + if (!htc_battery_initial) return; + struct ds2746_device_info *di = container_of(alarm, struct ds2746_device_info, alarm); + wake_lock(&di->work_wake_lock); + queue_work(di->monitor_wqueue, &di->monitor_work); +} + +static int ds2746_battery_probe(struct platform_device *pdev) +{ + int rc; + struct ds2746_device_info *di; + struct ds2746_platform_data *pdata = pdev->dev.platform_data; + + pr_info("[ds2746_batt] ds2746_battery_prob\n"); + + poweralg.battery.thermal_id = pdata->func_get_thermal_id(); + + power_alg_preinit(); + power_alg_init(&debug_config); + + di = kzalloc(sizeof(*di), GFP_KERNEL); + if (!di){ + rc = -ENOMEM; + goto fail_register; + } + + di->update_time = jiffies; + platform_set_drvdata(pdev, di); + + di->dev = &pdev->dev; + + INIT_WORK(&di->monitor_work, ds2746_battery_work); + di->monitor_wqueue = create_singlethread_workqueue(dev_name(&pdev->dev)); + + /* init to something sane */ + di->last_poll = alarm_get_elapsed_realtime(); + + if (!di->monitor_wqueue){ + rc = -ESRCH; + goto fail_workqueue; + } + wake_lock_init(&di->work_wake_lock, WAKE_LOCK_SUSPEND, "ds2746-battery"); + alarm_init(&di->alarm, + ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP, + ds2746_battery_alarm); + wake_lock(&di->work_wake_lock); + queue_work(di->monitor_wqueue, &di->monitor_work); + htc_battery_initial = 1; + return 0; + + fail_workqueue : fail_register : kfree(di); + return rc; +} + + +static int ds2746_battery_remove(struct platform_device *pdev) +{ + struct ds2746_device_info *di = platform_get_drvdata(pdev); + + cancel_work_sync(&di->monitor_work); + destroy_workqueue(di->monitor_wqueue); + + return 0; +} + +/* FIXME: power down DQ master when not in use. */ +static int ds2746_suspend(struct device *dev) +{ + struct platform_device *pdev = to_platform_device(dev); + struct ds2746_device_info *di = platform_get_drvdata(pdev); + unsigned long flags; + pr_info("ds2746_batt:ds2746_suspend\n"); + /* If we are on battery, reduce our update rate until + * we next resume.*/ + if (poweralg.charging_source == SOURCE_NONE){ + local_irq_save(flags); + ds2746_program_alarm(di, SLOW_POLL); + di->slow_poll = 1; + local_irq_restore(flags); + } + /*gpio_direction_output(87, 0);*/ + return 0; +} +static void ds2746_resume(struct device *dev) +{ + struct platform_device *pdev = to_platform_device(dev); + struct ds2746_device_info *di = platform_get_drvdata(pdev); + unsigned long flags; + + /* We might be on a slow sample cycle. If we're + * resuming we should resample the battery state + * if it's been over a minute since we last did + * so, and move back to sampling every minute until + * we suspend again.*/ + /*gpio_direction_output(87, 1);*/ + ndelay(100 * 1000); + pr_info("ds2746_batt:ds2746_resume\n"); + if (di->slow_poll){ + local_irq_save(flags); + ds2746_program_alarm(di, FAST_POLL); + di->slow_poll = 0; + local_irq_restore(flags); + } +} + +static struct dev_pm_ops ds2746_pm_ops = { + .prepare = ds2746_suspend, + .complete = ds2746_resume, +}; + +MODULE_ALIAS("platform:ds2746-battery"); +static struct platform_driver ds2746_battery_driver = +{ + .driver = { + .name = "ds2746-battery", + .pm = &ds2746_pm_ops, + }, + .probe = ds2746_battery_probe, + .remove = ds2746_battery_remove, +}; + +static int __init ds2746_battery_init(void) +{ + int ret; + + pr_info("[ds2746_batt]ds2746_battery_init"); + wake_lock_init(&vbus_wake_lock, WAKE_LOCK_SUSPEND, "vbus_present"); + register_notifier_cable_status(&cable_status_handler); + + ret = ds2746_i2c_init(); + if (ret < 0){ + return ret; + } + + /*mutex_init(&htc_batt_info.lock);*/ + return platform_driver_register(&ds2746_battery_driver); +} + +static void __exit ds2746_battery_exit(void) +{ + ds2746_i2c_exit(); + platform_driver_unregister(&ds2746_battery_driver); +} + +module_init(ds2746_battery_init); +module_exit(ds2746_battery_exit); + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Andy.YS Wang "); +MODULE_DESCRIPTION("ds2746 battery driver"); + diff --git a/drivers/power/ds2746_param.c b/drivers/power/ds2746_param.c new file mode 100644 index 00000000..7744465c --- /dev/null +++ b/drivers/power/ds2746_param.c @@ -0,0 +1,857 @@ +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Copyright (c) 2010 High Tech Computer Corporation + +Module Name: + + ds2784_param.c + +Abstract: + + This module implements the battery formula based on power spec, including below concepts: + 1. adc converter + 2. voltage mapping to capacity + 3. over temperature algorithm + 4. id range algorithm + 5. ACR maintainance + + Add from TPE PMA: + 1. temperature index + 2. pd_m_coef_boot + 3. preserved_capacity_by_temp + Remove from TAO PMA: + 1. pd_temp + + To adapt different PMA/projects, we need to modify below tables: + 1. ID_RANGE: which battery is used in the project? + 2. FL_25: the full capacity in temp 25C. + 3. pd_m_bias_mA: the discharge current threshold to calculating pd_m + 4. M_PARAMTER_TABLE: the voltage-capacity mapping table + 5. TEMP_RANGE: how many temp condition we need to consider + 6. PD_M_COEF_TABLE(BOOT)/PD_M_RESL_TABLE(BOOT): voltage compensation based on current + 7. PD_T_COEF: voltage compensation based on temp + 8. CAPACITY_DEDUCTION_01p: the capacity deduction due to low temperature + +Original Auther: + + Andy.ys Wang June-01-2010 + +---------------------------------------------------------------------------------*/ + +#include +#include +#include +#include +#include +#include +#include + +/*======================================================================================== + +build flags + +========================================================================================*/ + +#define HTC_ENABLE_POWER_DEBUG 0 +#define HTC_ENABLE_DUMMY_BATTERY 0 + +/*======================================================================================== + +battery common parameter defines (independent on battery id yet...) + +========================================================================================*/ + +#define BATTERY_VOLTAGE_MIN 2000 +#define BATTERY_VOLTAGE_MAX 20000 + +/*======================================================================================== + +battery parameter helper functions + +========================================================================================*/ + +static INT32 get_id_index(struct battery_type *battery) +{ + int i; + + for (i = 0; i < BATTERY_ID_NUM - 1; i++) { + /* minus 1, unknown battery is not in ID_RANGE + [min, max)*/ + UINT32 resister_min = ID_RANGE[i*2]; + UINT32 resister_max = ID_RANGE[i*2 + 1]; + + if (resister_min <= battery->id_ohm && resister_max > battery->id_ohm) { + return i + 1; + } + } + + return BATTERY_ID_UNKNOWN; +} + +static INT32 get_temp_index(struct battery_type *battery) +{ + int i; + + for (i = 0; i < 255; i++) { + /* the table size shall not be greater then 255, to ensure no infinite looping + [min, max)*/ + INT32 temp = TEMP_RANGE[i]; + if (battery->temp_01c >= temp) + return i; + } + + printk(DRIVER_ZONE " invalid batt_temp (%d) or temp range mapping.\n", battery->temp_01c); + return -1; +} + +/*======================================================================================== + +temperature formula definitions + +========================================================================================*/ + +static INT32 get_temp_01c(struct battery_type *battery) +{ + int current_index = battery->temp_check_index; + int search_direction = 0; + + if (battery->last_temp_adc > battery->temp_adc) { + search_direction = -1; + } else { + search_direction = 1; + } + + while (current_index >= 0 && current_index < TEMP_NUM-1) { + + UINT32 temp_min = TEMP_MAP[current_index]; + UINT32 temp_max = TEMP_MAP[current_index + 1]; + + if (temp_max > battery->temp_adc && temp_min <= battery->temp_adc) { + battery->temp_check_index = current_index; + battery->last_temp_adc = battery->temp_adc; + return (TEMP_MAX-current_index)*10; + } + current_index += search_direction; + } + + return (TEMP_MIN-1)*10; +} + +/*======================================================================================== + +over temperature protection + +========================================================================================*/ + +static BOOL is_over_temp(struct battery_type *battery) +{ + /* stop charging*/ + if (battery->temp_01c < over_low_temp_lock_01c || battery->temp_01c >= over_high_temp_lock_01c) { + return TRUE; + } + + return FALSE; +} + +static BOOL is_not_over_temp(struct battery_type *battery) +{ + /* start charging*/ + if (battery->temp_01c >= over_low_temp_release_01c && + battery->temp_01c < over_high_temp_release_01c) { + return TRUE; + } + + return FALSE; +} + +static void __protect_flags_update(struct battery_type *battery, + struct protect_flags_type *flags) +{ + /* Flags: + is_charging_enable_available - Over temperature, need to stop charging + is_charging_high_current_avaialble - Temperature is too high so that we have to slow charge*/ + + if (is_over_temp(battery)) { + /* Ex: T<0 or T>45 */ + flags->is_charging_enable_available = FALSE; + flags->is_charging_high_current_avaialble = FALSE; +#if 0 + flags->is_battery_overtemp = TRUE; +#endif + } else if (is_not_over_temp(battery)) { + /* Ex: T<42 or T>3*/ + flags->is_charging_enable_available = TRUE; + flags->is_charging_high_current_avaialble = TRUE; +#if 0 + flags->is_battery_overtemp = FALSE; +#endif + } + + /* Flags: + is_battery_dead - If battery is dead, show special indicator for it*/ + if (battery->voltage_mV < BATTERY_DEAD_VOLTAGE_LEVEL) { + flags->is_battery_dead = TRUE; + } + else if (battery->voltage_mV > BATTERY_DEAD_VOLTAGE_RELEASE) { + flags->is_battery_dead = FALSE; + } +} + +/*======================================================================================== + +Voltage-Percentage mapping + +========================================================================================*/ + +/*------------------------------------------------------------------------ + Example: + p0 = (4200, 10000); 4.2V for 100% + p1 = (3900, 8000); 3.9V for 80% + p2 = (3700, 2000); 3.7V for 20% + p3 = (3300, 0); 3.3V for 0% + + if V = 4000, (3900<4000<4200) + P = (4000-3900) * (10000-8000)/(4200-3900) + 8000 = 8666*/ + +#define NUM_SAMPLED_POINTS_MAX 12 + +struct sampled_point_type { + + DWORD voltage; + DWORD capacity; +}; + +struct voltage_curve_translator { + + DWORD voltage_min; + DWORD voltage_max; + DWORD capacity_min; + DWORD capacity_max; + int sampled_point_count; + struct sampled_point_type sampled_points[NUM_SAMPLED_POINTS_MAX]; +}; + +static void voltage_curve_translator_init(struct voltage_curve_translator *t) +{ + memset(t, 0, sizeof(*t)); +} + +static void voltage_curve_translator_add(struct voltage_curve_translator *t, DWORD voltage, DWORD capacity) +{ + struct sampled_point_type *pt; + + if (t->sampled_point_count >= NUM_SAMPLED_POINTS_MAX) { + return; + } + + t->sampled_points[t->sampled_point_count].voltage = voltage; + t->sampled_points[t->sampled_point_count].capacity = capacity; + pt = &t->sampled_points[t->sampled_point_count]; + + t->sampled_point_count++; + + if (pt->voltage > t->voltage_max) + t->voltage_max = pt->voltage; + if (pt->voltage < t->voltage_min) + t->voltage_min = pt->voltage; + if (pt->capacity > t->capacity_max) + t->capacity_max = pt->capacity; + if (pt->capacity < t->capacity_min) + t->capacity_min = pt->capacity; + +#if HTC_ENABLE_POWER_DEBUG + printk(DRIVER_ZONE " kadc t: capacity=%d voltage=%d\n", capacity, voltage); +#endif /* HTC_ENABLE_POWER_DEBUG*/ +} + +static INT32 voltage_curve_translator_get(struct voltage_curve_translator *t, DWORD voltage) +{ + struct sampled_point_type *p0, *p1; + INT32 capacity; + int i; + + if (voltage > t->voltage_max) + voltage = t->voltage_max; + if (voltage < t->voltage_min) + voltage = t->voltage_min; + + p0 = &t->sampled_points[0]; + p1 = p0 + 1; + for (i = 0; i < t->sampled_point_count - 1 && voltage < p1->voltage; i++) { + p0++; + p1++; + } + + /* DIV ZERO check*/ + if (p0->voltage - p1->voltage == 0) { + return 0; + } + + /* INT32 overflow check: mv(4200) * capacity(10000), shall be no problem at all...*/ + capacity = (voltage - p1->voltage) * (p0->capacity - p1->capacity) / (p0->voltage - p1->voltage) + p1->capacity; + if (capacity > t->capacity_max) { + capacity = t->capacity_max; + } + if (capacity < t->capacity_min) { + capacity = t->capacity_min; + } + return capacity; +} + +/*======================================================================================== + +KADC mapping functions + +========================================================================================*/ + +static struct voltage_curve_translator __get_kadc_t; + +static INT32 get_kadc_001p(struct battery_type *battery) +{ + INT32 pd_m = 0; + INT32 pd_temp = 0; + + INT32 temp_01c = battery->temp_01c; + INT32 current_mA = battery->current_mA; + + UINT32 *m_paramtable; + + INT32 pd_m_coef; + INT32 pd_m_resl; + + INT32 capacity_deduction_01p = CAPACITY_DEDUCTION_01p[battery->temp_index]; + INT32 capacity_predict_001p; + /* 1. INT32 overflow check: assert abs(iChgCurrent_ma) <= 3000, iBattTemp_01c>-250, pd_t_coef <= 1000 + when calculating pd_temp: 0x7FFFFFFF / (500 * 3000 * 1000) =:= 1.4*/ + + if (battery->current_mA > 3000) + current_mA = 3000; + else if (battery->current_mA < -3000) + current_mA = -3000; + if (battery->temp_01c <= -250) + temp_01c = -250; + + /* 2. calculate pd_m and pd_temp*/ + + if (battery->is_power_on_reset) { + pd_m_coef = PD_M_COEF_TABLE_BOOT[battery->temp_index][battery->id_index]; + pd_m_resl = PD_M_RESL_TABLE_BOOT[battery->temp_index][battery->id_index]; + } + else{ + pd_m_coef = PD_M_COEF_TABLE[battery->temp_index][battery->id_index]; + pd_m_resl = PD_M_RESL_TABLE[battery->temp_index][battery->id_index]; + } + + if (battery->current_mA < -pd_m_bias_mA) { + /* ex: -150mA < -130mA*/ + pd_m = (abs(battery->current_mA) - pd_m_bias_mA) * pd_m_coef /pd_m_resl; + } + + if (battery->temp_01c < 250) { + pd_temp = ((250 - battery->temp_01c) * (abs(battery->current_mA) * PD_T_COEF[battery->id_index])) / (10 * 10000); + } + battery->pd_m = pd_m; + + /* 3. calculate KADC using M_PARAMTER_TABLE*/ + + m_paramtable = M_PARAMTER_TABLE[battery->id_index]; + if (m_paramtable) { + int i = 0; /* assume that m_paramtable has at least 2 items...the last capacity item must be 0 to end the loop...*/ + + voltage_curve_translator_init(&__get_kadc_t); + + while (1) { + INT32 capacity = m_paramtable[i]; + INT32 voltage = m_paramtable[i + 1]; + if (capacity == 10000) { + /* full capacity, no need to fix voltage level*/ + voltage_curve_translator_add(&__get_kadc_t, voltage, capacity); + } + else { + voltage_curve_translator_add(&__get_kadc_t, voltage - pd_temp, capacity); + } + + if (capacity == 0) + break; + + i += 2; + } + +#if HTC_ENABLE_POWER_DEBUG + printk(DRIVER_ZONE " pd_m=%d, pd_temp=%d\n", pd_m, pd_temp); +#endif /* HTC_ENABLE_POWER_DEBUG*/ + + capacity_predict_001p = voltage_curve_translator_get(&__get_kadc_t, battery->voltage_mV + pd_m); + } + else{ + capacity_predict_001p = (battery->voltage_mV - 3400) * 10000 / (4200 - 3400); + } + + return (capacity_predict_001p - capacity_deduction_01p * 10) * 10000 / (10000 - capacity_deduction_01p * 10); +} + +/*======================================================================================== + +coulomb counter+curve tracer + +========================================================================================*/ + +static INT32 get_software_acr_revise(struct battery_type *battery, UINT32 ms) +{ + INT32 kadc_01p = battery->KADC_01p; + INT32 ccbi_01p = battery->RARC_01p; + INT32 delta_01p = kadc_01p - ccbi_01p; + + DWORD C = 5; /* KADC = 15%~100%*/ + if (kadc_01p <= 150) { + C = 5; + } /* KADC = 0%~15%*/ + + if (delta_01p < 0) { + /* if KADC is less than RARC, p shall be lower*/ + return -(INT32) (C * ms * delta_01p * delta_01p) / 1000; + } + else{ + /* if KADC is larger than RARC, p shall be higher*/ + return (INT32) (C * ms * delta_01p * delta_01p) / 1000; + } +} + +/*======================================================================================== + +ds2746 gauge ic functions, to access ds2746 registers and convert ADC to battery param + +========================================================================================*/ + +static void __ds2746_clear_porf(void) +{ + UINT8 reg_data; + if (!ds2746_i2c_read_u8(®_data, 0x01)) { + printk(DRIVER_ZONE " clear porf error in read.\n"); + return; + } + + if (!ds2746_i2c_write_u8((reg_data & (~DS2746_STATUS_PORF)), 0x01)) { + printk(DRIVER_ZONE " clear porf error in write.\n"); + return; + } +} + +static void __ds2746_acr_update(struct battery_type *battery, int capacity_01p) +{ + printk(DRIVER_ZONE " acr update: P=%d, C=%d.\n", + capacity_01p, + battery->charge_counter_adc); + + ds2746_i2c_write_u8((battery->charge_counter_adc & 0xFF00) >> 8, 0x10); + ds2746_i2c_write_u8((battery->charge_counter_adc & 0x00FF), 0x11); + + if (battery->is_power_on_reset) { + __ds2746_clear_porf(); + } +} + +static void __ds2746_init_config(struct battery_type *battery) +{ + UINT8 reg_data; + + if (!ds2746_i2c_read_u8(®_data, 0x01)) { + printk(DRIVER_ZONE " init config error in read.\n"); + return; + } + + /* Erase SMOD and NBEN value in DS2746 status/config register*/ + reg_data &= ~(DS2746_STATUS_SMOD | DS2746_STATUS_NBEN); + if (!ds2746_i2c_write_u8(reg_data, 0x01)) { + printk(DRIVER_ZONE " init config error in write.\n"); + return; + } +} + +static BOOL __ds2746_get_reg_data(UINT8 *reg) +{ + memset(reg, 0, 12); + + if (!ds2746_i2c_read_u8(®[0], 0x01)) + return FALSE; + if (!ds2746_i2c_read_u8(®[2], 0x08)) + return FALSE; + if (!ds2746_i2c_read_u8(®[3], 0x09)) + return FALSE; + if (!ds2746_i2c_read_u8(®[4], 0x0a)) + return FALSE; + if (!ds2746_i2c_read_u8(®[5], 0x0b)) + return FALSE; + if (!ds2746_i2c_read_u8(®[6], 0x0c)) + return FALSE; + if (!ds2746_i2c_read_u8(®[7], 0x0d)) + return FALSE; + if (!ds2746_i2c_read_u8(®[8], 0x0e)) + return FALSE; + if (!ds2746_i2c_read_u8(®[9], 0x0f)) + return FALSE; + if (!ds2746_i2c_read_u8(®[10], 0x10)) + return FALSE; + if (!ds2746_i2c_read_u8(®[11], 0x11)) + return FALSE; + + return TRUE; +} + +static BOOL __ds2746_battery_adc_udpate(struct battery_type *battery) +{ + UINT8 reg[12]; + + if (!__ds2746_get_reg_data((UINT8 *) ®)) { + printk(DRIVER_ZONE " get ds2746 data failed...\n"); + return FALSE; + } + +#if HTC_ENABLE_POWER_DEBUG + printk(DRIVER_ZONE " [x0]%x [x8]%x %x %x %x %x %x %x %x %x %x\n", + reg[0], + reg[2], + reg[3], + reg[4], + reg[5], + reg[6], + reg[7], + reg[8], + reg[9], + reg[10], + reg[11]); +#endif + + if (!(reg[0] & DS2746_STATUS_AIN0) || !(reg[0] & DS2746_STATUS_AIN1)) { + printk(DRIVER_ZONE " AIN not ready...\n"); + return FALSE; + } + + if (reg[0] & DS2746_STATUS_PORF) { + battery->is_power_on_reset = TRUE; + } + else{ + battery->is_power_on_reset = FALSE; + } + + /* adc register value*/ + battery->voltage_adc = MAKEWORD(reg[7], reg[6]) >> 4; + battery->current_adc = MAKEWORD(reg[9], reg[8]); + if (battery->current_adc & 0x8000) { + battery->current_adc = -(0x10000 - battery->current_adc); + } + battery->current_adc /= 4; + battery->charge_counter_adc = MAKEWORD(reg[11], reg[10]); + if (battery->charge_counter_adc & 0x8000) { + battery->charge_counter_adc = -(0x10000 - battery->charge_counter_adc); + } + battery->id_adc = MAKEWORD(reg[5], reg[4]) >> 4; + battery->temp_adc = MAKEWORD(reg[3], reg[2]) >> 4; + if (support_ds2746_gauge_ic) { + /* we preserve 500mAh for capacity lower than 0%, however the 500mAh is still drained out...we need to do predict for correct ACR*/ + if ((battery->charge_counter_adc & 0xFFFF) >= 0xF000){ + printk(DRIVER_ZONE " ACR out of range (x%x)...\n", + battery->charge_counter_adc); + battery->is_power_on_reset = TRUE; + } + } + + return TRUE; +} + +/*======================================================================================== + +softwar acr functions, to accumulate ACR by software and revise by battery parameter + +========================================================================================*/ + +static void __software_charge_counter_update(struct battery_type *battery, UINT32 ms) +{ + /* if the charge counter is maintained by sw, batt_alg shall use this routine to update charge counter and related parameters*/ + INT32 capacity_deduction_01p = CAPACITY_DEDUCTION_01p[battery->temp_index]; + /* AEL(mAh): A low temp unusable battery capacity, calculated in runtime*/ + INT32 ael_mAh = capacity_deduction_01p *battery->charge_full_real_mAh / 1000; +#if HTC_ENABLE_POWER_DEBUG + printk(DRIVER_ZONE "chgctr update: I=%d ms=%d.\n", battery->current_mA, ms); +#endif /* HTC_ENABLE_POWER_DEBUG*/ + + /* ACRt(mAh): The total capacity battery owns, stored in battery->charge_counter_mAh*/ + battery->software_charge_counter_mAms += (INT32) (battery->current_mA * ms); + battery->charge_counter_mAh += (battery->software_charge_counter_mAms / 3600000); + battery->software_charge_counter_mAms -= (battery->software_charge_counter_mAms / 3600000) * 3600000; + + /* CCBI(0.1%): A software RARC*/ + battery->RARC_01p = (battery->charge_counter_mAh - ael_mAh) * 1000 / (battery->charge_full_real_mAh - ael_mAh); + /* store back the battery->charge_counter_mAh to battery->charge_counter_adc*/ + battery->charge_counter_adc = (battery->charge_counter_mAh + charge_counter_zero_base_mAh) * acr_adc_to_mv_coef / acr_adc_to_mv_resl; +} + +static void __software_charge_counter_revise(struct battery_type *battery, UINT32 ms) +{ + if (battery->current_mA < 0) { +#if HTC_ENABLE_POWER_DEBUG + printk(DRIVER_ZONE "chgctr revise: delta=%d.\n", get_software_acr_revise(battery, ms)); +#endif /* HTC_ENABLE_POWER_DEBUG*/ + + /* revise software charge counter by coulomb counter+curve tracer*/ + battery->software_charge_counter_mAms += get_software_acr_revise(battery, ms); + battery->charge_counter_mAh += (battery->software_charge_counter_mAms / 3600000); + battery->software_charge_counter_mAms -= (battery->software_charge_counter_mAms / 3600000) * 3600000; + /* store back the battery->charge_counter_mAh to battery->charge_counter_adc*/ + battery->charge_counter_adc = (battery->charge_counter_mAh + charge_counter_zero_base_mAh) * acr_adc_to_mv_coef / acr_adc_to_mv_resl; + } +} + +static void __software_acr_update(struct battery_type *battery) +{ + static BOOL s_bFirstEntry = TRUE; + static DWORD last_time_ms; + DWORD now_time_ms = BAHW_MyGetMSecs(); + + if (s_bFirstEntry) { + s_bFirstEntry = FALSE; + last_time_ms = now_time_ms; + } + +#if HTC_ENABLE_POWER_DEBUG + printk(DRIVER_ZONE "+acr update: adc=%d C=%d mams=%d.\n", + battery->charge_counter_adc, + battery->charge_counter_mAh, + battery->software_charge_counter_mAms); +#endif /* HTC_ENABLE_POWER_DEBUG*/ + + __software_charge_counter_update(battery, now_time_ms - last_time_ms); + __software_charge_counter_revise(battery, now_time_ms - last_time_ms); + +#if HTC_ENABLE_POWER_DEBUG + printk(DRIVER_ZONE "-acr update: adc=%d C=%d mams=%d.\n", + battery->charge_counter_adc, + battery->charge_counter_mAh, + battery->software_charge_counter_mAms); +#endif /* HTC_ENABLE_POWER_DEBUG*/ + + last_time_ms = now_time_ms; +} + +/*======================================================================================== + +battery param update, the coef are referenced from power spec + +========================================================================================*/ + +static BOOL __battery_param_udpate(struct battery_type *battery) +{ + static int batt_id_stable_counter = 0; + INT32 batt_id_index; + INT32 temp_01c; + + if (support_ds2746_gauge_ic) { + /* adc register value are read from __ds2746_battery_adc_udpate()*/ + if (!__ds2746_battery_adc_udpate(battery)) + return FALSE; + } + else{ + /* adc register value are read from BAHW_get_batt_info_all() + if ( !BAHW_get_batt_info_all(battery) ) return FALSE;*/ + } + + /*real physical value*/ + battery->voltage_mV = (battery->voltage_adc * voltage_adc_to_mv_coef / voltage_adc_to_mv_resl); + battery->current_mA = (battery->current_adc * current_adc_to_mv_coef / current_adc_to_mv_resl); + battery->discharge_mA = (battery->discharge_adc * discharge_adc_to_mv_coef / discharge_adc_to_mv_resl); + battery->charge_counter_mAh = (battery->charge_counter_adc * acr_adc_to_mv_coef / acr_adc_to_mv_resl) - charge_counter_zero_base_mAh; + battery->current_mA = battery->current_mA - battery->discharge_mA; + /* prevent from adc out of range*/ + if (battery->id_adc >= id_adc_resl) { + battery->id_adc = id_adc_resl - 1; + } + if (battery->id_adc <= 0) { + battery->id_adc = 1; + } + if (battery->temp_adc >= temp_adc_resl) { + battery->temp_adc = temp_adc_resl - 1; + } + if (battery->temp_adc <= 0) { + battery->temp_adc = 1; + } + + /* battery ID shall be ready first for temp/kadc calculation*/ + // if ( id_conversion ) battery->id_ohm = ((float)id_R_kohm / ((float)id_adc_resl/battery->id_adc - 1)) * 1000; // kohm -> ohm + // else battery->id_ohm = battery->id_adc; + battery->id_ohm = battery->id_adc; + calibrate_id_ohm(battery); + + batt_id_index = get_id_index(battery); + + if (is_allow_batt_id_change) { + /*! TODO: batt_id changes immediately; may need to modify in future*/ + if (batt_id_stable_counter >= 3 && batt_id_index != battery->id_index){ + /* if batt_id is stable but is different from previous one*/ + batt_id_stable_counter = 0; /* reset stable counter and set batt_id to new one*/ + } + } + + if (batt_id_stable_counter < 3) { + if (batt_id_stable_counter == 0) { + /* first time to get the batt id*/ + battery->id_index = batt_id_index; + battery->charge_full_design_mAh = FL_25[battery->id_index]; + battery->charge_full_real_mAh = battery->charge_full_design_mAh; + batt_id_stable_counter = 1; + } + else{ + /* 2nd and further time to get the batt id*/ + if (batt_id_index == battery->id_index) + batt_id_stable_counter++; + else + batt_id_stable_counter = 0; + } + } + + /* calculate temperature*/ + // battery->temp_01c = get_temp_c((float)temp_R_kohm / ((float)temp_adc_resl/battery->temp_adc - 1))*10; + temp_01c = get_temp_01c(battery); + if (temp_01c >= TEMP_MIN*10) + battery->temp_01c = temp_01c; + else + printk(DRIVER_ZONE " get temp_01c(%d) failed...\n", temp_01c); + battery->temp_index = get_temp_index(battery); + + /* calculate KADC and RARC*/ + battery->KADC_01p = CEILING(get_kadc_001p(battery), 10); + battery->RARC_01p = CEILING(10000 * battery->charge_counter_mAh / battery->charge_full_real_mAh, 10); + if (!support_ds2746_gauge_ic) { + __software_acr_update(battery); + } + + if (battery->voltage_mV voltage_mV> BATTERY_VOLTAGE_MAX) { + printk(DRIVER_ZONE " invalid V(%d).\n", battery->voltage_mV); + return FALSE; + } + + /*! star_lee 20100426 - minimum RARC is 0%*/ + if (battery->RARC_01p <= 0) { + battery->RARC_01p = 0; + } + + printk(DRIVER_ZONE " V=%d(%x) I=%d(%x) C=%d.%d/%d(%x) id=%d(%x) T=%d(%x) KADC=%d\n", + battery->voltage_mV, + battery->voltage_adc, + battery->current_mA, + battery->current_adc, + battery->charge_counter_mAh, + battery->software_charge_counter_mAms, + battery->charge_full_real_mAh, + battery->charge_counter_adc, + battery->id_index, + battery->id_adc, + battery->temp_01c, + battery->temp_adc, + battery->KADC_01p); + + return TRUE; +} + +/*======================================================================================== + +time functions + +========================================================================================*/ + +DWORD BAHW_MyGetMSecs(void) +{ + struct timespec now; + getnstimeofday(&now); + /*struct timespec t; + t.tv_sec = t.tv_nsec = 0; + clock_gettime(CLOCK_MONOTONIC, &t);*/ + return now.tv_sec * 1000 + now.tv_nsec / 1000000; +} + +/*======================================================================================== + +battery param public function + +========================================================================================*/ + +void battery_capacity_update(struct battery_type *battery, int capacity_01p) +{ + + /* ACR 500~500+FULL mapping to capacity 0~FULL*/ + battery->charge_counter_mAh = capacity_01p * battery->charge_full_real_mAh / 1000; + battery->charge_counter_adc = (battery->charge_counter_mAh + charge_counter_zero_base_mAh) * acr_adc_to_mv_resl / acr_adc_to_mv_coef; + battery->RARC_01p = capacity_01p; + if (support_ds2746_gauge_ic) { + __ds2746_acr_update(battery, capacity_01p); + } + + printk(DRIVER_ZONE "new RARC=%d C=%dmAh adc=%d.\n", + battery->RARC_01p, + battery->charge_counter_mAh, + battery->charge_counter_adc); + battery->is_power_on_reset = FALSE; +} + +BOOL battery_param_update(struct battery_type *battery, struct protect_flags_type *flags) +{ + if (!__battery_param_udpate(battery)) { + return FALSE; + } + + if (flags->is_fake_room_temp) { + battery->temp_01c = 250; + printk(DRIVER_ZONE "fake temp=%d(%x)\n", + battery->temp_01c, + battery->temp_adc); + } + __protect_flags_update(battery, flags); + +#if ! HTC_ENABLE_DUMMY_BATTERY + if (battery->id_index == BATTERY_ID_UNKNOWN) { + flags->is_charging_enable_available = FALSE; + } +#else /* HTC_ENABLE_DUMMY_BATTERY*/ + /* do not disable charging for debug stage*/ + flags->is_charging_enable_available = TRUE; +#endif /* HTC_ENABLE_DUMMY_BATTERY*/ + + return TRUE; +} + +void battery_param_init(struct battery_type *battery) +{ + /* set battery id to unknown to get battery id and related characters*/ + battery->id_index = BATTERY_ID_UNKNOWN; + + /* default to 25C unless we can get valid battery temp from adc*/ + battery->temp_01c = 250; + battery->last_temp_01c = battery->temp_01c; + battery->temp_check_index = 0; + battery->last_temp_adc = 0; + + battery->voltage_mV = 3800; + + /* this is used when accumulate current by software; initial it as 0mAs*/ + battery->software_charge_counter_mAms = 0; + + /* set POR at first by software; gauge ic will has correct value*/ + battery->is_power_on_reset = TRUE; + + if (support_ds2746_gauge_ic) { + __ds2746_init_config(battery); + } + + if (battery->thermal_id == THERMAL_1000) { + TEMP_MAP = TEMP_MAP_1000K; + printk(DRIVER_ZONE "Use 1000 Kohm thermal resistance"); + } else if (battery->thermal_id == THERMAL_600) { + TEMP_MAP = TEMP_MAP_600K; + printk(DRIVER_ZONE "Use 600 Kohm thermal resistance"); + } else { + printk(DRIVER_ZONE "Use default(300 Kohm) thermal resistance"); + } + + /*printk(DRIVER_ZONE "battery param inited with board name <%s>\n", HTC_BATT_BOARD_NAME);*/ +} + diff --git a/include/linux/ds2746_battery.h b/include/linux/ds2746_battery.h new file mode 100644 index 00000000..d8930f52 --- /dev/null +++ b/include/linux/ds2746_battery.h @@ -0,0 +1,148 @@ +/* + * Copyright (C) 2007 HTC Incorporated + * + * This software is licensed under the terms of the GNU General Public + * License version 2, as published by the Free Software Foundation, and + * may be copied, distributed, and modified under those terms. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ +#ifndef _DS2746_BATTERY_H_ +#define _DS2746_BATTERY_H_ +#include +#include +#include +#include + +enum ds2784_notify_evt_t { + DS2784_CHARGING_CONTROL = 0, + DS2784_LEVEL_UPDATE, + DS2784_BATTERY_FAULT, + DS2784_OVER_TEMP, + DS2784_NUM_EVENTS, +}; + +/* battery charging state*/ + +enum { + CHARGE_STATE_UNKNOWN, /* before anything is ready, we are in this state. shall default low current charge and show charging LED*/ + CHARGE_STATE_PREDICTION, /* in normal case, we need to enter prediction for 10 seconds for 1st KADC*/ + CHARGE_STATE_DISCHARGE, /* cable out state*/ + CHARGE_STATE_CHARGING, /* charging state*/ + CHARGE_STATE_PENDING, /* charging state but no good*/ + CHARGE_STATE_FULL_WAIT_STABLE, /* charging state but going full*/ + CHARGE_STATE_FULL_CHARGING, /* charging full, keep charging*/ + CHARGE_STATE_FULL_PENDING, /* charging full, stop charging*/ +}; + +enum { + THERMAL_300, + THERMAL_600, + THERMAL_1000, +}; + +/* power algorithm data structure and config data structure*/ + +struct poweralg_type +{ + int charge_state; + int capacity_01p; + int last_capacity_01p; + int fst_discharge_capacity_01p; + int fst_discharge_acr_mAh; + int charging_source; + int charging_enable; + BOOL is_need_calibrate_at_49p; + BOOL is_need_calibrate_at_14p; + BOOL is_charge_over_load; + struct battery_type battery; + struct protect_flags_type protect_flags; + BOOL is_china_ac_in; + BOOL is_cable_in; + BOOL is_voltage_stable; + BOOL is_software_charger_timeout; + UINT32 state_start_time_ms; +}; + +struct poweralg_config_type +{ + INT32 full_charging_mv; + INT32 full_charging_ma; + INT32 full_pending_ma; /* 0 to disable*/ + INT32 full_charging_timeout_sec; /* 0 to disable*/ + INT32 voltage_recharge_mv; /* 0 to disable*/ + INT32 capacity_recharge_p; /* 0 to disable*/ + INT32 voltage_exit_full_mv; /* 0 to disable*/ + INT32 wait_votlage_statble_sec; + INT32 predict_timeout_sec; + INT32 polling_time_in_charging_sec; + INT32 polling_time_in_discharging_sec; + + BOOL enable_full_calibration; + BOOL enable_weight_percentage; + INT32 software_charger_timeout_sec; /* 0 to disable*/ + + BOOL debug_disable_shutdown; + BOOL debug_fake_room_temp; + BOOL debug_disable_hw_timer; + BOOL debug_always_predict; + INT32 full_level; /* 0 to disable*/ +}; + +struct ds2746_platform_data { + int (*func_get_thermal_id)(void); +}; + +/* battery behavior constant*/ + +#define BATTERY_PERCENTAGE_UNKNOWN 0xFF +#define BATTERY_LOW_PERCENTAGE 10 /* in 1%*/ +#define BATTERY_CRITICAL_PERCENTAGE 5 /* in 1%*/ +#define BATTERY_EMPTY_PERCENTAGE 0 /* in 1%*/ + +/* battery algorithm public functions*/ + +int get_state_check_interval_min_sec( void); +BOOL do_power_alg( BOOL is_event_triggered); +void power_alg_init( struct poweralg_config_type *debug_config); +void power_alg_preinit( void); +int ds2746_blocking_notify( unsigned long val, void *v); +void ds2746_charger_control( int type); +int ds2746_i2c_write_u8( u8 value, u8 reg); +int ds2746_i2c_read_u8( u8* value, u8 reg); +void calibrate_id_ohm( struct battery_type *battery); +/* external function implemented by upper layer*/ + +/*extern void powerlog_to_file(struct poweralg_type* poweralg);*/ +/*extern void update_os_batt_status(struct poweralg_type* poweralg);*/ + +#ifdef CONFIG_BATTERY_DS2746 +extern int ds2746_register_notifier( struct notifier_block *nb); +extern int ds2746_unregister_notifier( struct notifier_block *nb); +extern int ds2746_get_battery_info( struct battery_info_reply *batt_info); +extern ssize_t htc_battery_show_attr( struct device_attribute *attr, char *buf); +#else +static int ds2746_register_notifier( struct notifier_block *nb) { + + return 0; +} +static int ds2746_unregister_notifier( struct notifier_block *nb) { + + return 0; +} +static int ds2746_get_battery_info( struct battery_info_reply *batt_info) { + + batt_info->level = 10; + return 0; +} +extern ssize_t htc_battery_show_attr( struct device_attribute *attr, char *buf) { + + return 0; +} + +#endif + +#endif diff --git a/include/linux/ds2746_battery_config.h b/include/linux/ds2746_battery_config.h new file mode 100644 index 00000000..2195d450 --- /dev/null +++ b/include/linux/ds2746_battery_config.h @@ -0,0 +1,44 @@ +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Copyright (c) 2010 High Tech Computer Corporation + +Module Name: + + batt_alg_config.c +Abstract: + + This module tells batt_alg.c module how to config power alg. + +Original Auther: + + Star Lee (star_lee) Apr-12-2010 + +---------------------------------------------------------------------------------*/ + +#define HTC_BATT_BOARD_NAME "ACE" + +static void poweralg_config_init(struct poweralg_config_type *config) +{ + config->full_charging_mv = 4110; + config->full_charging_ma = 50; + config->full_pending_ma = 0; /* disabled*/ + config->full_charging_timeout_sec = 60 * 60; + config->voltage_recharge_mv = 4150; + config->capacity_recharge_p = 0; /* disabled*/ + config->voltage_exit_full_mv = 4100; + config->wait_votlage_statble_sec = 1 * 60; + config->predict_timeout_sec = 10; + config->polling_time_in_charging_sec = 30; + config->polling_time_in_discharging_sec = 30; + + config->enable_full_calibration = TRUE; + config->enable_weight_percentage = TRUE; + config->software_charger_timeout_sec = 0; /* disabled*/ + + config->debug_disable_shutdown = FALSE; + config->debug_fake_room_temp = FALSE; + config->debug_disable_hw_timer = FALSE; + config->debug_always_predict = FALSE; + config->full_level = 0; +} + diff --git a/include/linux/ds2746_param.h b/include/linux/ds2746_param.h new file mode 100644 index 00000000..49733165 --- /dev/null +++ b/include/linux/ds2746_param.h @@ -0,0 +1,70 @@ +#ifndef __BATT_PARAM_H__ +#define __BATT_PARAM_H__ + +/* battery status and charging information*/ + +struct battery_type{ + + BOOL is_power_on_reset; + + INT32 voltage_mV; + INT32 current_mA; + INT32 discharge_mA; + INT32 charge_counter_mAh; + INT32 temp_01c; + INT32 last_temp_01c; + INT32 id_ohm; + INT32 vref_mv; + + INT32 voltage_adc; + INT32 current_adc; + INT32 discharge_adc; + INT32 charge_counter_adc; + INT32 temp_adc; + INT32 last_temp_adc; + INT32 id_adc; + INT32 vref_adc; + + INT32 id_index; + INT32 charge_full_design_mAh; + INT32 charge_full_real_mAh; + + INT32 temp_index; + INT32 temp_check_index; + + INT32 KADC_01p; + INT32 RARC_01p; + INT32 pd_m; + + INT32 software_charge_counter_mAms; + INT32 thermal_id; +}; + +struct protect_flags_type{ + + BOOL is_charging_enable_available; + BOOL is_charging_high_current_avaialble; + BOOL is_charging_indicator_available; + BOOL is_battery_dead; +#if 0 + BOOL is_battery_overtemp; +#endif + BOOL is_fake_room_temp; +}; + +/* ds2746 register definition*/ + +#define DS2746_STATUS_PORF (1 << 6) /* write to 0 as power-up sequence ready*/ +#define DS2746_STATUS_SMOD (1 << 5) /* write to 0 to disable DS2746 sleep mode*/ +#define DS2746_STATUS_NBEN (1 << 4) /* write to 0 to disable blanking of negative currents*/ +#define DS2746_STATUS_AIN0 (1 << 0) +#define DS2746_STATUS_AIN1 (1 << 1) + +/* function prototypes*/ + +void battery_capacity_update(struct battery_type *battery, int capacity_01p); +BOOL battery_param_update(struct battery_type *battery, struct protect_flags_type *flags); +DWORD BAHW_MyGetMSecs(void); +void battery_param_init(struct battery_type *battery); + +#endif /* __BATT_PARAM_H__*/ diff --git a/include/linux/ds2746_param_config.h b/include/linux/ds2746_param_config.h new file mode 100644 index 00000000..eea2b3e2 --- /dev/null +++ b/include/linux/ds2746_param_config.h @@ -0,0 +1,286 @@ +/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Copyright (c) 2010 High Tech Computer Corporation + +Module Name: + + ds2746_param_config.c + +Abstract: + + This module tells batt_param.c module what the battery characteristic is. + And also which charger/gauge component hardware uses, to decide if software/hardware function is available. + +Original Auther: + + Andy.ys Wang June-01-2010 + +---------------------------------------------------------------------------------*/ + + +#ifndef __BATT_PARAM_CONFIG_H__ +#define __BATT_PARAM_CONFIG_H__ +#define HTC_BATT_BOARD_NAME "ACE" + +/*======================================================================================== + +battery parameter defines (depend on board design) + +========================================================================================*/ + +static BOOL support_ds2746_gauge_ic = TRUE; + +enum BATTERY_ID_ENUM { + BATTERY_ID_UNKNOWN = 0, + BATTERY_ID_SONY_1300MAH_FORMOSA, + BATTERY_ID_SONY_1300MAH_HTE, + BATTERY_ID_SANYO_1300MAH_HTE, + BATTERY_ID_SANYO_1300MAH_TWS, + BATTERY_ID_NUM /* include unknown battery*/ +}; + +UINT32 ID_RANGE[] = +{ + /* id resister range = [min, max)*/ + 7150, 15500, /* Sony 1300mAh (Formosa) */ /* 7.1k~15k */ + 27500, 49500, /* Sony 1300mAh (HTE) */ /* 28k~49.5k */ + 15500, 27500, /* Sanyo 1300mAh (HTE) */ /* 16k~27k */ + 0, 7150, /* Samsung 1230mAh */ /* 0k~7k */ +}; + +/*This table is calculated according to temp formula for temp mapping. +If temp_adc is located on 0-95, then the temp_01c is 700. + 96-99, then the temp_01c is 690. + 100-102, then the temp_01c is 680. + ... + 1117777777-1145, then the temp_01c is 0. + 1146-1175, then the temp_01c is -1. + ... + 1433-2046, then the temp_01c is -11. +*/ +UINT32 TEMP_MAP_300K[] = +{ +0, 96, 100, 103, 107, 111, 115, 119, 123, 127, +133, 137, 143, 148, 154, 159, 165, 172, 178, 185, +192, 199, 207, 215, 223, 232, 241, 250, 260, 270, +280, 291, 301, 314, 326, 339, 352, 366, 380, 394, +410, 425, 442, 458, 476, 494, 512, 531, 551, 571, +592, 614, 636, 659, 682, 706, 730, 755, 780, 806, +833, 860, 887, 942, 943, 971, 1000, 1028, 1058, 1087, +1117, 1146, 1176, 1205, 1234, 1264, 1293, 1321, 1350, 1378, +1406, 1433, 2047, +}; + +UINT32 TEMP_MAP_600K[] = +{ +0,56,59,60,63,65,68,70,73,75,78,81,84,87,91,94,98, +102,105,110,114,118,123,128,133,138,144,149,156,161, +168,175,181,189,197,205,213,222,231,240,250,260,270, +281,293,304,317,329,343,356,371,385,401,417,433,450, +467,486,504,523,543,563,584,616,628,650,674,697,721, +746,772,798,824,851,878,906,934,962,991,1020, +1050,1079,2047, +}; + +UINT32 TEMP_MAP_1000K[] = +{ +0, 30, 31, 32, 34, 35, 36, 38, 39, 40, +42, 44, 45, 47, 49, 51, 53, 55, 57, 60, +62, 64, 67, 70, 73, 76, 79, 82, 86, 89, +93, 97, 101, 106, 111, 115, 120, 126, 131, 137, +143, 150, 156, 163, 171, 178, 187, 195, 204, 213, +223, 233, 244, 255, 267, 279, 292, 306, 320, 334, +350, 365, 382, 399, 418, 436, 456, 476, 497, 519, +542, 566, 590, 615, 641, 668, 695, 723, 752, 782, +812, 843, 2047, +}; + + +UINT32 *TEMP_MAP = TEMP_MAP_300K; + +UINT32 FL_25[] = +{ + 1280, /* Unknown battery */ + 1280, /* Sony 1300mAh (Formosa) */ + 1280, /* Sony 1300mAh (HTE) */ + 1250, /* Sanyo 1300mAh (HTE) */ + 1230, /* Samsung 1230mAh */ +}; + +UINT32 PD_M_COEF[] = +{ + /* for TAO PMA, this is defined as PD_M; for TPE PMA, this is defined as FT or t*/ + 24, /* Unknown battery */ + 24, /* Sony 1300mAh (Formosa) */ + 24, /* Sony 1300mAh (HTE) */ + 27, /* Sanyo 1300mAh (HTE) */ + 30, /* Samsung 1230mAh */ +}; + +UINT32 PD_M_RESL[] = +{ + /* for TAO PMA, this is defined as PD_M; for TPE PMA, this is defined as FT or t*/ + 100, /* Unknown battery */ + 100, /* Sony 1300mAh (Formosa) */ + 100, /* Sony 1300mAh (HTE) */ + 100, /* Sanyo 1300mAh (HTE) */ + 100, /* Samsung 1230mAh */ +}; + +UINT32 PD_T_COEF[] = +{ + /* Ex: 140 -> 0.014, 156 -> 0.0156*/ + 140, /* Unknown battery */ + 140, /* Sony 1300mAh (Formosa) */ + 140, /* Sony 1300mAh (HTE) */ + 156, /* Sanyo 1300mAh (HTE) */ + 250, /* Samsung 1230mAh */ +}; + +/*! star_lee 20100426 - update KADC discharge parameter */ +UINT32 M_PARAMETER_SONY_1300MAH_FORMOSA[] = +{ + /* capacity (in 0.01%) -> voltage (in mV)*/ + 10000, 4100, 5500, 3839, 2400, 3759, 400, 3667, 0, 3397, +}; + +UINT32 M_PARAMETER_Samsung_1230MAH_FORMOSA[] = +{ + /* capacity (in 0.01%) -> voltage (in mV)*/ + 10000, 4135, 7500, 3960, 4700, 3800, 1700, 3727, 900, 3674, 300, 3640, 0, 3420, +}; + +UINT32 *M_PARAMTER_TABLE[] = +{ + /* Unknown battery */ + (UINT32 *) (M_PARAMETER_SONY_1300MAH_FORMOSA), + /* same as Sony 1300mAh (Formosa) currently... */ + /* Sony 1300mAh (Formosa) */ + (UINT32 *) (M_PARAMETER_SONY_1300MAH_FORMOSA), + /* Sony 1300mAh (HTE) */ + (UINT32 *) (M_PARAMETER_SONY_1300MAH_FORMOSA), + /* same as Sony 1300mAh (Formosa) currently... */ + /* Sanyo 1300mAh (HTE) */ + (UINT32 *) (M_PARAMETER_SONY_1300MAH_FORMOSA), + /* same as Sony 1300mAh (Formosa) currently... */ + /* Samsung 1230mAh */ + (UINT32 *) (M_PARAMETER_Samsung_1230MAH_FORMOSA), + /* same as Sony 1300mAh (Formosa) currently... */ +}; + +INT32 TEMP_RANGE[] = +{ + /* mapping temp to temp_index*/ + 200, /* ~20C */ + 100, /* 20~10C */ + 50, /* 10~5C */ + 0, /* 5~0C */ -5, /* 0~-5C */ -10, /* -5~-10C */ -3000, + /* -10C~ */ +}; + +UINT32 *PD_M_COEF_TABLE_BOOT[] = +{ + /* mapping current to pd_m_coef table when booting*/ + (UINT32 *) (PD_M_COEF), /* ~20C, using PD_M_COEF */ + (UINT32 *) (PD_M_COEF), /* 20~10C, using PD_M_COEF */ + (UINT32 *) (PD_M_COEF), /* 10~5C, using PD_M_COEF */ + (UINT32 *) (PD_M_COEF), /* 5~0C, using PD_M_COEF */ + (UINT32 *) (PD_M_COEF), /* 0~-5C, using PD_M_COEF */ + (UINT32 *) (PD_M_COEF), /* -5~-10C, using PD_M_COEF */ + (UINT32 *) (PD_M_COEF), /* -10C~, using PD_M_COEF */ +}; + +UINT32 *PD_M_COEF_TABLE[] = +{ + /* mapping current to pd_m_coef table*/ + (UINT32 *) (PD_M_COEF), /* ~20C, using PD_M_COEF */ + (UINT32 *) (PD_M_COEF), /* 20~10C, using PD_M_COEF */ + (UINT32 *) (PD_M_COEF), /* 10~5C, using PD_M_COEF */ + (UINT32 *) (PD_M_COEF), /* 5~0C, using PD_M_COEF */ + (UINT32 *) (PD_M_COEF), /* 0~-5C, using PD_M_COEF */ + (UINT32 *) (PD_M_COEF), /* -5~-10C, using PD_M_COEF */ + (UINT32 *) (PD_M_COEF), /* -10C~, using PD_M_COEF */ +}; + +UINT32 *PD_M_RESL_TABLE_BOOT[] = +{ + /* mapping current to pd_m_coef table when booting*/ + (UINT32 *) (PD_M_RESL), /* ~20C, using PD_M_RESL */ + (UINT32 *) (PD_M_RESL), /* 20~10C, using PD_M_RESL */ + (UINT32 *) (PD_M_RESL), /* 10~5C, using PD_M_RESL */ + (UINT32 *) (PD_M_RESL), /* 5~0C, using PD_M_RESL */ + (UINT32 *) (PD_M_RESL), /* 0~-5C, using PD_M_RESL */ + (UINT32 *) (PD_M_RESL), /* -5~-10C, using PD_M_RESL */ + (UINT32 *) (PD_M_RESL), /* -10C~, using PD_M_RESL */ +}; + +UINT32 *PD_M_RESL_TABLE[] = +{ + /* mapping current to pd_m_coef table*/ + (UINT32 *) (PD_M_RESL), /* ~20C, using PD_M_RESL */ + (UINT32 *) (PD_M_RESL), /* 20~10C, using PD_M_RESL */ + (UINT32 *) (PD_M_RESL), /* 10~5C, using PD_M_RESL */ + (UINT32 *) (PD_M_RESL), /* 5~0C, using PD_M_RESL */ + (UINT32 *) (PD_M_RESL), /* 0~-5C, using PD_M_RESL */ + (UINT32 *) (PD_M_RESL), /* -5~-10C, using PD_M_RESL */ + (UINT32 *) (PD_M_RESL), /* -10C~, using PD_M_RESL */ +}; + +UINT32 CAPACITY_DEDUCTION_01p[] = +{ + 0, /* ~20C, upper capacity 100 is usable */ + 0, /* 20~10C, upper capacity 95 is usable */ + 0, /* 10~5C, upper capacity 92 is usable */ + 0, /* 5~0C, upper capacity 90 is usable */ + 0, /* 0~-5C, upper capacity 87 is usable */ + 0, /* -5~-10C, upper capacity 85 is usable */ + 0, /* -10C~, upper capacity 85 is usable */ +}; + +/*======================================================================================== + +battery formula coef definition, can be re-programable + +========================================================================================*/ + +/* adc converter*/ + +static INT32 voltage_adc_to_mv_coef = 244; +static INT32 voltage_adc_to_mv_resl = 100; +static INT32 current_adc_to_mv_coef = 625; +static INT32 current_adc_to_mv_resl = 1580; +static INT32 discharge_adc_to_mv_coef = 625; +static INT32 discharge_adc_to_mv_resl = 1580; +static INT32 acr_adc_to_mv_coef = 625; +static INT32 acr_adc_to_mv_resl = 1580; +static INT32 charge_counter_zero_base_mAh = 500; + +static INT32 id_adc_resl = 2047; +static INT32 temp_adc_resl = 2047; + +/* kadc parameter*/ + +static INT32 pd_m_bias_mA; /* the bias current when calculating pd_m*/ + +/* over temperature algorithm*/ + +static INT32 over_high_temp_lock_01c = 450; +static INT32 over_high_temp_release_01c = 420; +static INT32 over_low_temp_lock_01c; /*over_low_temp_lock_01c = 0*/ +static INT32 over_low_temp_release_01c = 30; + +/* function config*/ + +static BOOL is_allow_batt_id_change = FALSE; + +/*boot up voltage*/ + +/*dead battery is voltage < M_0*/ +#define BATTERY_DEAD_VOLTAGE_LEVEL 3420 +#define BATTERY_DEAD_VOLTAGE_RELEASE 3450 + +#define TEMP_MAX 70 +#define TEMP_MIN -11 +#define TEMP_NUM 83 + +#endif diff --git a/include/linux/tps65200.h b/include/linux/tps65200.h new file mode 100644 index 00000000..6048cecb --- /dev/null +++ b/include/linux/tps65200.h @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2007 HTC Incorporated + * + * This software is licensed under the terms of the GNU General Public + * License version 2, as published by the Free Software Foundation, and + * may be copied, distributed, and modified under those terms. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ +#ifndef _TPS65200_H_ +#define _TPS65200_H_ +#include +#include + +#ifdef CONFIG_TPS65200 +extern int tps_set_charger_ctrl(u32 ctl); +#else +static int tps_set_charger_ctrl(u32 ctl) {return 0 ; } +#endif +#endif diff --git a/include/linux/wrapper_types.h b/include/linux/wrapper_types.h new file mode 100644 index 00000000..742755fe --- /dev/null +++ b/include/linux/wrapper_types.h @@ -0,0 +1,92 @@ +#ifndef __WRAPPER_TYPES_H_ +#define __WRAPPER_TYPES_H_ + +#define DRIVER_ZONE "[D:BATT]" +#define DRIVER_BATTERY (1<<9) + +/* The left side of these typedefs are machine and compiler dependent */ +typedef signed char INT8; +typedef unsigned char UINT8; +typedef signed short INT16; +typedef unsigned short UINT16; +typedef signed int INT32; +typedef unsigned int UINT32; +typedef struct _INT64{ + + UINT32 u0, u1, u2; INT32 u3; +} INT64; +typedef struct _UINT64{ + + UINT32 u0, u1, u2, u3; +} UINT64; +typedef struct _INT128{ + + UINT32 u0, u1, u2; INT32 u3; +} INT128; +typedef struct _UINT128{ + + UINT32 u0, u1, u2, u3; +} UINT128; + +typedef INT8 * PINT8; +typedef UINT8 *PUINT8; +typedef INT16 * PINT16; +typedef UINT16 * PUINT16; +typedef INT32 *PINT32; +typedef UINT32 *PUINT32; +typedef INT64 * PINT64; +typedef UINT64 * PUINT64; +typedef INT128 * PINT128; +typedef UINT128 * PUINT128; +typedef const void *PCVOID; +typedef void **PPVOID; +/*typedef unsigned char uchar;*/ +typedef void (*PFNVOID)( void); +typedef char CHAR; +typedef UINT8 BYTE; +typedef UINT8 UCHAR; +typedef UINT32 ULONG; +typedef INT32 LONG; +typedef UINT32 DWORD; +typedef UINT32 UINT; +typedef UINT32 BOOL; +typedef UINT16 WORD; +typedef UINT16 USHORT; +typedef INT32 INT; +typedef void *LPVOID; +typedef void *PVOID; +typedef void VOID; +typedef void *HLOCAL; +typedef CHAR * LPCHAR; +typedef CHAR * PBYTE; +typedef INT16 * LPCWSTR; +typedef UINT8 *LPTSTR; +typedef UINT8 *LPCSTR; +typedef UINT8 *LPCTSTR; +typedef BYTE * LPBYTE; +typedef DWORD *LPDWORD; +typedef DWORD *PDWORD; +typedef CHAR TCHAR; +typedef UINT32 HINSTANCE; +typedef UINT32 HKEY; +typedef UINT32 HMODULE; +typedef UINT32 FARPROC; +typedef UINT32 HRESULT; +typedef UINT32 HREGNOTIFY; +typedef UINT32 LPSTARTUPINFO; +typedef UINT32 LPPROCESS_INFORMATION; +typedef UINT32 REGISTRYNOTIFYCALLBACK; +typedef UINT32 NOTIFICATIONCONDITION; +typedef UINT32 REGSAM; +typedef UINT32 PHKEY; + +#define FALSE 0 +#define TRUE 1 +#define INFINITE 0x7fffffffffffffffL + +#define MAKEWORD(a, b) ((WORD)(((BYTE)(a)) | ((WORD)((BYTE)(b))) << 8)) +#define LOBYTE(w) ((BYTE)(w)) +#define HIBYTE(w) ((BYTE)(((WORD)(w) >> 8) & 0xFF)) +#define CEILING(n, precision) ((n+precision-1)/precision) /* ex: CEILING(989, 10)=99, means 98.9 mapping to 99*/ + +#endif From 31bc15c159b902cbc7256480b3add922c9218fc1 Mon Sep 17 00:00:00 2001 From: Markinus Date: Mon, 15 Nov 2010 16:23:26 +0100 Subject: [PATCH 10/10] htcleo: fixed USB charging problems in some configurations and cleanups --- arch/arm/mach-msm/board-htcleo.c | 1 + arch/arm/mach-msm/htc_battery.c | 15 ++- .../include/mach/board-htcleo-battery.h | 102 ------------------ arch/arm/mach-msm/include/mach/htc_battery.h | 1 + 4 files changed, 15 insertions(+), 104 deletions(-) delete mode 100644 arch/arm/mach-msm/include/mach/board-htcleo-battery.h diff --git a/arch/arm/mach-msm/board-htcleo.c b/arch/arm/mach-msm/board-htcleo.c index 3db89f33..0fe32396 100644 --- a/arch/arm/mach-msm/board-htcleo.c +++ b/arch/arm/mach-msm/board-htcleo.c @@ -719,6 +719,7 @@ static struct htc_battery_platform_data htc_battery_pdev_data = { .gpio_mbat_in = -1, .gpio_mchg_en_n = HTCLEO_GPIO_BATTERY_CHARGER_ENABLE, .gpio_iset = HTCLEO_GPIO_BATTERY_CHARGER_CURRENT, + .gpio_power = HTCLEO_GPIO_POWER_USB, .guage_driver = GUAGE_DS2746, .charger = LINEAR_CHARGER, .m2a_cable_detect = 0, diff --git a/arch/arm/mach-msm/htc_battery.c b/arch/arm/mach-msm/htc_battery.c index d898e10e..ef989184 100644 --- a/arch/arm/mach-msm/htc_battery.c +++ b/arch/arm/mach-msm/htc_battery.c @@ -114,6 +114,7 @@ struct htc_battery_info { int gpio_usb_id; int gpio_mchg_en_n; int gpio_iset; + int gpio_power; int guage_driver; int m2a_cable_detect; int force_no_rpc; @@ -368,10 +369,20 @@ static int init_batt_gpio(void) if (htc_batt_info.gpio_mchg_en_n > 0 && gpio_request(htc_batt_info.gpio_mchg_en_n, "charger_en") < 0) goto gpio_failed; + else + gpio_direction_output(htc_batt_info.gpio_mchg_en_n, 1); if (htc_batt_info.gpio_iset > 0 && gpio_request(htc_batt_info.gpio_iset, "charge_current") < 0) goto gpio_failed; + else + gpio_direction_output(htc_batt_info.gpio_iset, 1); + if (htc_batt_info.gpio_power > 0 && + gpio_request(htc_batt_info.gpio_power, "usb_power") < 0) + goto gpio_failed; + else + gpio_direction_output(htc_batt_info.gpio_power, 0); + return 0; gpio_failed: @@ -387,7 +398,6 @@ gpio_failed: int battery_charging_ctrl(enum batt_ctl_t ctl) { int result = 0; - if (!htc_battery_initial) return 0; switch (ctl) { @@ -1699,9 +1709,10 @@ static int htc_battery_probe(struct platform_device *pdev) { int rc = 0; struct htc_battery_platform_data *pdata = pdev->dev.platform_data; - + htc_batt_info.device_id = pdev->id; htc_batt_info.gpio_usb_id = pdata->gpio_usb_id; + htc_batt_info.gpio_power = pdata->gpio_power; htc_batt_info.guage_driver = pdata->guage_driver; htc_batt_info.m2a_cable_detect = pdata->m2a_cable_detect; htc_batt_info.force_no_rpc = pdata->force_no_rpc; diff --git a/arch/arm/mach-msm/include/mach/board-htcleo-battery.h b/arch/arm/mach-msm/include/mach/board-htcleo-battery.h deleted file mode 100644 index bc7c9ec2..00000000 --- a/arch/arm/mach-msm/include/mach/board-htcleo-battery.h +++ /dev/null @@ -1,102 +0,0 @@ -#ifndef __LEO_BATTERY__ -#define __LEO_BATTERY__ - -#include - -#define LEO_BATTERY_CAPACITY 1230 -#define LEO_BATTERY_EMPTY 500 - -// from board-htcleo-power.c -extern int is_ac_power_supplied(void); - -// from board-htcleo-log.c -extern double log(double x); - -#define RAW_DATA_SIZE 10 - - -struct battery_status -{ - int timestamp; - - int voltage_uV; /* units of uV */ - int current_uA; /* units of uA */ - int current_avg_uA; - int charge_uAh; - - s16 temp_C; /* units of 0.1 C */ - - u8 percentage; /* battery percentage */ - u8 charge_source; - u8 status_reg; - u8 battery_full; /* battery full (don't charge) */ - - u8 cooldown; /* was overtemp */ - u8 charge_mode; -} __attribute__((packed)); - - -#define SOURCE_NONE 0 -#define SOURCE_USB 1 -#define SOURCE_AC 2 - -#define CHARGE_OFF 0 -#define CHARGE_SLOW 1 -#define CHARGE_FAST 2 - -#define TEMP_CRITICAL 600 /* no charging at all */ -#define TEMP_HOT 500 /* no fast charge, no charge > 4.1v */ -#define TEMP_WARM 450 /* no fast charge above this */ - -#define TEMP_HOT_MAX_MV 4100 /* stop charging here when hot */ -#define TEMP_HOT_MIN_MV 3800 /* resume charging here when hot */ -#define CE_DISABLE_MIN_MV 4100 - - -/* When we're awake or running on wall power, sample the battery -* gauge every FAST_POLL seconds. If we're asleep and on battery -* power, sample every SLOW_POLL seconds -*/ -#define FAST_POLL (1 * 60) -#define SLOW_POLL (10 * 60) - - -struct htcleo_device_info -{ - struct device *dev; - - /* DS2784 data, valid after calling htcleo_battery_read_status() */ - char raw[RAW_DATA_SIZE]; /* raw HTCLEO data */ - uint32_t raw_status; - - struct battery_status status; - - struct power_supply bat; - struct workqueue_struct *monitor_wqueue; - struct work_struct monitor_work; - struct alarm alarm; - struct wake_lock work_wake_lock; - - // int (*charge)(int on, int fast); - // struct w1_slave *w1_slave; - struct i2c_client *client; - - u8 dummy; /* dummy battery flag */ - u8 last_charge_mode; /* previous charger state */ - u8 slow_poll; - - ktime_t last_poll; - ktime_t last_charge_seen; -}; - -static struct htcleo_device_info * mydi = NULL; - -#define psy_to_dev_info(x) container_of((x), struct htcleo_device_info, bat) - -static struct wake_lock vbus_wake_lock; - - -#define to_htcleo_device_info(x) container_of((x), struct htcleo_device_info, bat); - -#endif - diff --git a/arch/arm/mach-msm/include/mach/htc_battery.h b/arch/arm/mach-msm/include/mach/htc_battery.h index d4e758dc..a820efc4 100644 --- a/arch/arm/mach-msm/include/mach/htc_battery.h +++ b/arch/arm/mach-msm/include/mach/htc_battery.h @@ -84,6 +84,7 @@ struct htc_battery_platform_data { int gpio_usb_id; int gpio_mchg_en_n; int gpio_iset; + int gpio_power; int guage_driver; int m2a_cable_detect; int charger;