Hi ,Avi, According to EXT_CSD_FFU_STATUS can report the status of the FFU process. If it necessary to check Error in downloading firmware(value: 0x12) before we continue to execute mmc_ffu_install? Thanks. 2014-07-30 22:08 GMT+08:00 Avi Shchislowski <Avi.Shchislowski@xxxxxxxxxxx>: > Hi Gwendal > From spec perspective there should not be any problem to read the EXT_CSD value in FFU mode, the spec refer to read/write commands > But if it causes issues I will read the EXT_CSD before entering FFU mode. > > Please let me know. > > Thanks > Avi. > > > -----Original Message----- > From: Gwendal Grignou [mailto:gwendal@xxxxxxxxxx] > Sent: Wednesday, July 30, 2014 3:32 AM > To: Gwendal Grignou > Cc: Avi Shchislowski; linux-mmc@xxxxxxxxxxxxxxx; cjb@xxxxxxxxxx; Grant Grundler; Alex Lemberg > Subject: Re: [RFC PATCH 1/1 v8]mmc: Support-FFU-for-eMMC-v5.0 > > I take it back, we can still use the 2 ioctl approach: > We just need to remove the mmc_send_ext_csd() between the calls to set MMC_FFU_MODE_SET and MMC_FFU_MODE_NORMAL. > Your patch v7 did not have this error, I introduced it in the comments I made on v7. > > Gwendal. > > On Tue, Jul 29, 2014 at 5:14 PM, Gwendal Grignou <gwendal@xxxxxxxxxxxx> wrote: >> Avi, >> We should revisit the 2 ioctls approach: Accroding to the spec: >> """When in FFU_MODE and host sends other commands which are not part >> of the recommended flow, device behavior may be undefined.""" >> >> To be safe, no command should be sent to the device which are not >> strictly necessary for the downloading the firmware. >> Therefore, we should restrict to only the firmware download command >> while in FFU mode. With the 2 ioctls approach, any commands can be >> send in between the 2 ioctl calls. >> Moreover, we read ext_csd while in FFU mode. we should get rid of that >> call as well. >> >> Gwendal. >> >> On Mon, Jul 21, 2014 at 11:01 AM, Gwendal Grignou <gwendal@xxxxxxxxxxxx> wrote: >>> Avi, >>> >>> The patch still does not work for me. After the upgrade, the eMMC is >>> not in a good state timing out every IOs. A power cycle fixes the >>> problem. >>> I am investigating how the reset patch is working. >>> >>> Gwendal. >>> >>> >>> On Wed, Jul 16, 2014 at 8:47 AM, Avi Shchislowski >>> <Avi.Shchislowski@xxxxxxxxxxx> wrote: >>>> >>>> The Field Firmware Update (FFU) feature is new for eMMC 5.0 spec (Jedec: JESD84-B50.pdf) >>>> >>>> http://www.jedec.org/standards-documents/technology-focus-areas/flas >>>> h-memory-ssds-ufs-emmc/e-mmc >>>> >>>> An ioctl has been added to provide the new firmware image's file name to the mmc driver and udev is then used to retrieve its data. >>>> >>>> Two new ioctls have been added: >>>> 1. FFU download firmware - transfer the new firmware data from user >>>> space to the eMMC device 2. FFU install - initializes the new >>>> firmware update >>>> >>>> >>>> Signed-off-by: Avi Shchislowski <avi.shchislowski@xxxxxxxxxxx> >>>> Signed-off-by: Alex Lemberg <alex.lemberg@xxxxxxxxxxx> >>>> >>>> --- >>>> V8: >>>> - Modified according to Gwendal Grignou comments and patch: >>>> [PATCH] Fix on top of sandisk patches >>>> >>>> V7: >>>> - fixed mangled white space >>>> >>>> V5: >>>> - provides udev (request_firmware) implementation as advised in >>>> patch >>>> v2 comments. >>>> >>>> diff --git a/drivers/mmc/card/Kconfig b/drivers/mmc/card/Kconfig >>>> index 5562308..19ba729 100644 >>>> --- a/drivers/mmc/card/Kconfig >>>> +++ b/drivers/mmc/card/Kconfig >>>> @@ -68,3 +68,11 @@ config MMC_TEST >>>> >>>> This driver is only of interest to those developing or >>>> testing a host driver. Most people should say N here. >>>> + >>>> +config MMC_FFU >>>> + bool "FFU SUPPORT" >>>> + depends on MMC != n >>>> + help >>>> + This is an option to run firmware update on eMMC 5.0. >>>> + Field firmware updates (FFU) enables features enhancment >>>> + in the field. >>>> diff --git a/drivers/mmc/card/Makefile b/drivers/mmc/card/Makefile >>>> index c73b406..1e9223b 100644 >>>> --- a/drivers/mmc/card/Makefile >>>> +++ b/drivers/mmc/card/Makefile >>>> @@ -8,3 +8,4 @@ obj-$(CONFIG_MMC_TEST) += mmc_test.o >>>> >>>> obj-$(CONFIG_SDIO_UART) += sdio_uart.o >>>> >>>> +obj-$(CONFIG_MMC_FFU) += ffu.o >>>> diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c >>>> index 7b5424f..3ed900b 100644 >>>> --- a/drivers/mmc/card/block.c >>>> +++ b/drivers/mmc/card/block.c >>>> @@ -41,6 +41,7 @@ >>>> #include <linux/mmc/host.h> >>>> #include <linux/mmc/mmc.h> >>>> #include <linux/mmc/sd.h> >>>> +#include <linux/mmc/ffu.h> >>>> >>>> #include <asm/uaccess.h> >>>> >>>> @@ -523,8 +524,18 @@ static int mmc_blk_ioctl_cmd(struct >>>> block_device *bdev, >>>> >>>> mrq.cmd = &cmd; >>>> >>>> + if (cmd.opcode == MMC_FFU_DOWNLOAD_OP) { >>>> + err = mmc_ffu_download(card, idata->buf); >>>> + goto cmd_done; >>>> + } >>>> + >>>> mmc_get_card(card); >>>> >>>> + if (cmd.opcode == MMC_FFU_INSTALL_OP) { >>>> + err = mmc_ffu_install(card); >>>> + goto cmd_rel_host; >>>> + } >>>> + >>>> err = mmc_blk_part_switch(card, md); >>>> if (err) >>>> goto cmd_rel_host; >>>> diff --git a/drivers/mmc/card/ffu.c b/drivers/mmc/card/ffu.c new >>>> file mode 100644 index 0000000..783673e >>>> --- /dev/null >>>> +++ b/drivers/mmc/card/ffu.c >>>> @@ -0,0 +1,607 @@ >>>> +/* >>>> + * * ffu.c >>>> + * >>>> + * Copyright 2007-2008 Pierre Ossman >>>> + * >>>> + * Modified by SanDisk Corp., Copyright (c) 2013 SanDisk Corp. >>>> + * >>>> + * This program is free software; you can redistribute it and/or >>>> +modify >>>> + * it under the terms of the GNU General Public License as >>>> +published by >>>> + * the Free Software Foundation; either version 2 of the License, >>>> +or (at >>>> + * your option) any later version. >>>> + * >>>> + * This program includes bug.h, card.h, host.h, mmc.h, >>>> +scatterlist.h, >>>> + * slab.h, ffu.h & swap.h header files >>>> + * The original, unmodified version of this program - the >>>> +mmc_test.c >>>> + * file - is obtained under the GPL v2.0 license that is available >>>> +via >>>> + * http://www.gnu.org/licenses/, >>>> + * or http://www.opensource.org/licenses/gpl-2.0.php >>>> +*/ >>>> + >>>> +#include <linux/bug.h> >>>> +#include <linux/errno.h> >>>> +#include <linux/mmc/card.h> >>>> +#include <linux/mmc/host.h> >>>> +#include <linux/mmc/mmc.h> >>>> +#include <linux/scatterlist.h> >>>> +#include <linux/slab.h> >>>> +#include <linux/swap.h> >>>> +#include <linux/mmc/ffu.h> >>>> +#include <linux/firmware.h> >>>> + >>>> +/** >>>> + * struct mmc_ffu_pages - pages allocated by 'alloc_pages()'. >>>> + * @page: first page in the allocation >>>> + * @order: order of the number of pages allocated */ struct >>>> +mmc_ffu_pages { >>>> + struct page *page; >>>> + unsigned int order; >>>> +}; >>>> + >>>> +/** >>>> + * struct mmc_ffu_mem - allocated memory. >>>> + * @arr: array of allocations >>>> + * @cnt: number of allocations >>>> + */ >>>> +struct mmc_ffu_mem { >>>> + struct mmc_ffu_pages *arr; >>>> + unsigned int cnt; >>>> +}; >>>> + >>>> +struct mmc_ffu_area { >>>> + unsigned long max_sz; >>>> + unsigned int max_tfr; >>>> + unsigned int max_segs; >>>> + unsigned int max_seg_sz; >>>> + unsigned int blocks; >>>> + unsigned int sg_len; >>>> + struct mmc_ffu_mem *mem; >>>> + struct scatterlist *sg; >>>> +}; >>>> + >>>> +static void mmc_ffu_prepare_mrq(struct mmc_card *card, >>>> + struct mmc_request *mrq, struct scatterlist *sg, unsigned int sg_len, >>>> + u32 arg, unsigned int blocks, unsigned int blksz) { >>>> + BUG_ON(!mrq || !mrq->cmd || !mrq->data || !mrq->stop); >>>> + >>>> + if (blocks > 1) >>>> + mrq->cmd->opcode = MMC_WRITE_MULTIPLE_BLOCK; >>>> + else >>>> + mrq->cmd->opcode = MMC_WRITE_BLOCK; >>>> + >>>> + mrq->cmd->arg = arg; >>>> + if (!mmc_card_blockaddr(card)) >>>> + mrq->cmd->arg <<= 9; >>>> + >>>> + mrq->cmd->flags = MMC_RSP_R1 | MMC_CMD_ADTC; >>>> + if (blocks == 1) { >>>> + mrq->stop = NULL; >>>> + } else { >>>> + mrq->stop->opcode = MMC_STOP_TRANSMISSION; >>>> + mrq->stop->arg = 0; >>>> + mrq->stop->flags = MMC_RSP_R1B | MMC_CMD_AC; >>>> + } >>>> + >>>> + mrq->data->blksz = blksz; >>>> + mrq->data->blocks = blocks; >>>> + mrq->data->flags = MMC_DATA_WRITE; >>>> + mrq->data->sg = sg; >>>> + mrq->data->sg_len = sg_len; >>>> + >>>> + mmc_set_data_timeout(mrq->data, card); } >>>> + >>>> +/* >>>> + * Checks that a normal transfer didn't have any errors */ static >>>> +int mmc_ffu_check_result(struct mmc_request *mrq) { >>>> + BUG_ON(!mrq || !mrq->cmd || !mrq->data); >>>> + >>>> + if (mrq->cmd->error != 0) >>>> + return -EINVAL; >>>> + >>>> + if (mrq->data->error != 0) >>>> + return -EINVAL; >>>> + >>>> + if (mrq->stop != NULL && mrq->stop->error != 0) >>>> + return -1; >>>> + >>>> + if (mrq->data->bytes_xfered != (mrq->data->blocks * mrq->data->blksz)) >>>> + return -EINVAL; >>>> + >>>> + return 0; >>>> +} >>>> + >>>> +static int mmc_ffu_busy(struct mmc_command *cmd) { >>>> + return !(cmd->resp[0] & R1_READY_FOR_DATA) || >>>> + (R1_CURRENT_STATE(cmd->resp[0]) == R1_STATE_PRG); } >>>> + >>>> +static int mmc_ffu_wait_busy(struct mmc_card *card) { >>>> + int ret, busy = 0; >>>> + struct mmc_command cmd = {0}; >>>> + >>>> + memset(&cmd, 0, sizeof(struct mmc_command)); >>>> + cmd.opcode = MMC_SEND_STATUS; >>>> + cmd.arg = card->rca << 16; >>>> + cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC; >>>> + >>>> + do { >>>> + ret = mmc_wait_for_cmd(card->host, &cmd, 0); >>>> + if (ret) >>>> + break; >>>> + >>>> + if (!busy && mmc_ffu_busy(&cmd)) { >>>> + busy = 1; >>>> + if (card->host->caps & MMC_CAP_WAIT_WHILE_BUSY) { >>>> + pr_warn("%s: Warning: Host did not " >>>> + "wait for busy state to end.\n", >>>> + mmc_hostname(card->host)); >>>> + } >>>> + } >>>> + >>>> + } while (mmc_ffu_busy(&cmd)); >>>> + >>>> + return ret; >>>> +} >>>> + >>>> +/* >>>> + * transfer with certain parameters */ static int >>>> +mmc_ffu_simple_transfer(struct mmc_card *card, >>>> + struct scatterlist *sg, unsigned int sg_len, u32 arg, >>>> + unsigned int blocks, unsigned int blksz) { >>>> + struct mmc_request mrq = {0}; >>>> + struct mmc_command cmd = {0}; >>>> + struct mmc_command stop = {0}; >>>> + struct mmc_data data = {0}; >>>> + >>>> + mrq.cmd = &cmd; >>>> + mrq.data = &data; >>>> + mrq.stop = &stop; >>>> + mmc_ffu_prepare_mrq(card, &mrq, sg, sg_len, arg, blocks, blksz); >>>> + mmc_wait_for_req(card->host, &mrq); >>>> + >>>> + mmc_ffu_wait_busy(card); >>>> + >>>> + return mmc_ffu_check_result(&mrq); } >>>> + >>>> +/* >>>> + * Map memory into a scatterlist. >>>> + */ >>>> +static unsigned int mmc_ffu_map_sg(struct mmc_ffu_mem *mem, int size, >>>> + struct scatterlist *sglist, unsigned int max_segs, >>>> + unsigned int max_seg_sz) >>>> +{ >>>> + struct scatterlist *sg = sglist; >>>> + unsigned int i; >>>> + unsigned long sz = size; >>>> + unsigned int sctr_len = 0; >>>> + unsigned long len; >>>> + >>>> + sg_init_table(sglist, max_segs); >>>> + >>>> + for (i = 0; i < mem->cnt && sz; i++, sz -= len) { >>>> + len = PAGE_SIZE * (1 << mem->arr[i].order); >>>> + >>>> + if (len > sz) { >>>> + len = sz; >>>> + sz = 0; >>>> + } >>>> + >>>> + sg_set_page(sg, mem->arr[i].page, len, 0); >>>> + sg = sg_next(sg); >>>> + sctr_len += 1; >>>> + } >>>> + sg_mark_end(sg); >>>> + >>>> + return sctr_len; >>>> +} >>>> + >>>> +static void mmc_ffu_free_mem(struct mmc_ffu_mem *mem) { >>>> + if (!mem) >>>> + return; >>>> + >>>> + while (mem->cnt--) >>>> + __free_pages(mem->arr[mem->cnt].page, >>>> + mem->arr[mem->cnt].order); >>>> + >>>> + kfree(mem->arr); >>>> + kfree(mem); >>>> +} >>>> + >>>> +/* >>>> + * Cleanup struct mmc_ffu_area. >>>> + */ >>>> +static int mmc_ffu_area_cleanup(struct mmc_ffu_area *area) { >>>> + kfree(area->sg); >>>> + mmc_ffu_free_mem(area->mem); >>>> + >>>> + return 0; >>>> +} >>>> + >>>> +/* >>>> + * Allocate a lot of memory, preferably max_sz but at least min_sz. >>>> +In case >>>> + * there isn't much memory do not exceed 1/16th total low mem pages. >>>> +Also do >>>> + * not exceed a maximum number of segments and try not to make >>>> +segments much >>>> + * bigger than maximum segment size. >>>> + */ >>>> +static struct mmc_ffu_mem *mmc_ffu_alloc_mem(unsigned long min_sz, >>>> + unsigned long max_sz, unsigned int max_segs, unsigned int >>>> +max_seg_sz) { >>>> + unsigned long max_page_cnt = DIV_ROUND_UP(max_sz, PAGE_SIZE); >>>> + unsigned long min_page_cnt = DIV_ROUND_UP(min_sz, PAGE_SIZE); >>>> + unsigned long max_seg_page_cnt = DIV_ROUND_UP(max_seg_sz, PAGE_SIZE); >>>> + unsigned long page_cnt = 0; >>>> + /* we divide by 16 to ensure we will not allocate a big amount >>>> + * of unnecessary pages */ >>>> + unsigned long limit = nr_free_buffer_pages() >> 4; >>>> + struct mmc_ffu_mem *mem; >>>> + gfp_t flags = GFP_KERNEL | GFP_DMA | __GFP_NOWARN | >>>> +__GFP_NORETRY; >>>> + >>>> + if (max_page_cnt > limit) >>>> + max_page_cnt = limit; >>>> + >>>> + if (min_page_cnt > max_page_cnt) >>>> + min_page_cnt = max_page_cnt; >>>> + >>>> + if (max_segs * max_seg_page_cnt > max_page_cnt) >>>> + max_segs = DIV_ROUND_UP(max_page_cnt, >>>> + max_seg_page_cnt); >>>> + >>>> + mem = kzalloc(sizeof(struct mmc_ffu_mem), GFP_KERNEL); >>>> + if (!mem) >>>> + return NULL; >>>> + >>>> + mem->arr = kzalloc(sizeof(struct mmc_ffu_pages) * max_segs, >>>> + GFP_KERNEL); >>>> + if (!mem->arr) >>>> + goto out_free; >>>> + >>>> + while (max_page_cnt) { >>>> + struct page *page; >>>> + unsigned int order; >>>> + >>>> + order = get_order(max_seg_page_cnt << PAGE_SHIFT); >>>> + >>>> + do { >>>> + page = alloc_pages(flags, order); >>>> + } while (!page && order--); >>>> + >>>> + if (!page) >>>> + goto out_free; >>>> + >>>> + mem->arr[mem->cnt].page = page; >>>> + mem->arr[mem->cnt].order = order; >>>> + mem->cnt += 1; >>>> + if (max_page_cnt <= (1UL << order)) >>>> + break; >>>> + max_page_cnt -= 1UL << order; >>>> + page_cnt += 1UL << order; >>>> + } >>>> + >>>> + if (page_cnt < min_page_cnt) >>>> + goto out_free; >>>> + >>>> + return mem; >>>> + >>>> +out_free: >>>> + mmc_ffu_free_mem(mem); >>>> + return NULL; >>>> +} >>>> + >>>> +/* >>>> + * Initialize an area for data transfers. >>>> + * Copy the data to the allocated pages. >>>> + */ >>>> +static int mmc_ffu_area_init(struct mmc_ffu_area *area, struct mmc_card *card, >>>> + const u8 *data, int size) >>>> +{ >>>> + int ret; >>>> + int i; >>>> + int length = 0; >>>> + >>>> + area->max_tfr = size; >>>> + >>>> + /* Try to allocate enough memory for a max. sized transfer. Less is OK >>>> + * because the same memory can be mapped into the scatterlist more than >>>> + * once. Also, take into account the limits imposed on scatterlist >>>> + * segments by the host driver. >>>> + */ >>>> + area->mem = mmc_ffu_alloc_mem(1, area->max_tfr, area->max_segs, >>>> + area->max_seg_sz); >>>> + if (!area->mem) >>>> + return -ENOMEM; >>>> + >>>> + /* copy data to page */ >>>> + for (i = 0; i < area->mem->cnt; i++) { >>>> + if (length > size) { >>>> + ret = -EINVAL; >>>> + goto out_free; >>>> + } >>>> + >>>> + memcpy(page_address(area->mem->arr[i].page), data + length, >>>> + min(size - length, (int)area->max_seg_sz)); >>>> + length += area->max_seg_sz; >>>> + } >>>> + >>>> + area->sg = kmalloc(sizeof(struct scatterlist) * area->mem->cnt, >>>> + GFP_KERNEL); >>>> + if (!area->sg) { >>>> + ret = -ENOMEM; >>>> + goto out_free; >>>> + } >>>> + >>>> + area->sg_len = mmc_ffu_map_sg(area->mem, size, area->sg, >>>> + area->max_segs, area->mem->cnt); >>>> + >>>> + return 0; >>>> + >>>> +out_free: >>>> + mmc_ffu_area_cleanup(area); >>>> + return ret; >>>> +} >>>> + >>>> +static int mmc_ffu_write(struct mmc_card *card, const u8 *src, u32 arg, >>>> + int size) >>>> +{ >>>> + int rc; >>>> + struct mmc_ffu_area area; >>>> + int max_tfr; >>>> + >>>> + area.sg = NULL; >>>> + area.mem = NULL; >>>> + area.max_segs = card->host->max_segs; >>>> + area.max_seg_sz = card->host->max_seg_size & ~(CARD_BLOCK_SIZE - 1); >>>> + do { >>>> + max_tfr = size; >>>> + if (max_tfr >> 9 > card->host->max_blk_count) >>>> + max_tfr = card->host->max_blk_count << 9; >>>> + if (max_tfr > card->host->max_req_size) >>>> + max_tfr = card->host->max_req_size; >>>> + if (DIV_ROUND_UP(max_tfr, area.max_seg_sz) > area.max_segs) >>>> + max_tfr = area.max_segs * area.max_seg_sz; >>>> + >>>> + rc = mmc_ffu_area_init(&area, card, src, max_tfr); >>>> + if (rc != 0) >>>> + goto exit; >>>> + >>>> + rc = mmc_ffu_simple_transfer(card, area.sg, area.sg_len, arg, >>>> + max_tfr / CARD_BLOCK_SIZE, CARD_BLOCK_SIZE); >>>> + if (rc != 0) >>>> + goto exit; >>>> + >>>> + src += max_tfr; >>>> + size -= max_tfr; >>>> + } while (size > 0); >>>> + >>>> +exit: >>>> + mmc_ffu_area_cleanup(&area); >>>> + return rc; >>>> +} >>>> + >>>> +/* Flush all scheduled work from the MMC work queue. >>>> + * and initialize the MMC device */ static int >>>> +mmc_ffu_restart(struct mmc_card *card) { >>>> + struct mmc_host *host = card->host; >>>> + int err = 0; >>>> + >>>> + mmc_cache_ctrl(host, 0); >>>> + err = mmc_power_save_host(host); >>>> + if (err) { >>>> + pr_warn("%s: going to sleep failed (%d)!!!\n", >>>> + __func__ , err); >>>> + goto exit; >>>> + } >>>> + >>>> + err = mmc_power_restore_host(host); >>>> + >>>> +exit: >>>> + >>>> + return err; >>>> +} >>>> + >>>> +int mmc_ffu_download(struct mmc_card *card, const char *name) { >>>> + u8 ext_csd[CARD_BLOCK_SIZE]; >>>> + int err; >>>> + int ret; >>>> + u32 arg; >>>> + u32 fw_prog_bytes; >>>> + const struct firmware *fw; >>>> + >>>> + /* Check if FFU is supported */ >>>> + if (!card->ext_csd.ffu_capable) { >>>> + pr_err("FFU: %s: error FFU is not supported %d rev %d\n", >>>> + mmc_hostname(card->host), card->ext_csd.ffu_capable, >>>> + card->ext_csd.rev); >>>> + return -EOPNOTSUPP; >>>> + } >>>> + >>>> + if (strlen(name) > 512) { >>>> + pr_err("FFU: %s: %.20s is not a valid argument\n", >>>> + mmc_hostname(card->host), name); >>>> + return -EINVAL; >>>> + } >>>> + >>>> + /* setup FW data buffer */ >>>> + err = request_firmware(&fw, name, &card->dev); >>>> + if (err) { >>>> + pr_err("FFU: %s: Firmware request failed %d\n", >>>> + mmc_hostname(card->host), err); >>>> + return err; >>>> + } >>>> + if ((fw->size % CARD_BLOCK_SIZE)) { >>>> + pr_warn("FFU: %s: Warning %zd firmware data size " >>>> + "is not aligned!!!\n", mmc_hostname(card->host), >>>> + fw->size); >>>> + } >>>> + >>>> + mmc_get_card(card); >>>> + >>>> + /* set device to FFU mode */ >>>> + err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_MODE_CONFIG, >>>> + MMC_FFU_MODE_SET, card->ext_csd.generic_cmd6_time); >>>> + if (err) { >>>> + pr_err("FFU: %s: error %d FFU is not supported\n", >>>> + mmc_hostname(card->host), err); >>>> + goto exit; >>>> + } >>>> + >>>> + /* Read the EXT_CSD */ >>>> + err = mmc_send_ext_csd(card, ext_csd); >>>> + if (err) { >>>> + pr_err("FFU: %s: error %d sending ext_csd\n", >>>> + mmc_hostname(card->host), err); >>>> + goto exit; >>>> + } >>>> + >>>> + /* set CMD ARG */ >>>> + arg = ext_csd[EXT_CSD_FFU_ARG] | >>>> + ext_csd[EXT_CSD_FFU_ARG + 1] << 8 | >>>> + ext_csd[EXT_CSD_FFU_ARG + 2] << 16 | >>>> + ext_csd[EXT_CSD_FFU_ARG + 3] << 24; >>>> + >>>> + err = mmc_ffu_write(card, fw->data, arg, (int)fw->size); >>>> + >>>> + /* host switch back to work in normal MMC Read/Write commands */ >>>> + ret = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, >>>> + EXT_CSD_MODE_CONFIG, MMC_FFU_MODE_NORMAL, >>>> + card->ext_csd.generic_cmd6_time); >>>> + if (ret) { >>>> + err = ret; >>>> + goto exit; >>>> + } >>>> + >>>> + /* Read the EXT_CSD */ >>>> + err = mmc_send_ext_csd(card, ext_csd); >>>> + if (err) { >>>> + pr_err("FFU: %s: error %d sending ext_csd\n", >>>> + mmc_hostname(card->host), err); >>>> + goto exit; >>>> + } >>>> + >>>> + /* check that the eMMC has received the payload */ >>>> + fw_prog_bytes = ext_csd[EXT_CSD_NUM_OF_FW_SEC_PROG] | >>>> + ext_csd[EXT_CSD_NUM_OF_FW_SEC_PROG + 1] << 8 | >>>> + ext_csd[EXT_CSD_NUM_OF_FW_SEC_PROG + 2] << 16 | >>>> + ext_csd[EXT_CSD_NUM_OF_FW_SEC_PROG + 3] << 24; >>>> + >>>> + /* convert sector to bytes */ >>>> + fw_prog_bytes *= >>>> + CARD_BLOCK_SIZE << (ext_csd[EXT_CSD_DATA_SECTOR_SIZE] * 3); >>>> + if (fw_prog_bytes != fw->size) { >>>> + err = -EINVAL; >>>> + pr_err("FFU: %s: error %d number of programmed fw sector\n", >>>> + mmc_hostname(card->host), err); >>>> + } >>>> + >>>> +exit: >>>> + release_firmware(fw); >>>> + mmc_put_card(card); >>>> + return err; >>>> +} >>>> +EXPORT_SYMBOL(mmc_ffu_download); >>>> + >>>> +int mmc_ffu_install(struct mmc_card *card) { >>>> + u8 ext_csd[CARD_BLOCK_SIZE]; >>>> + int err; >>>> + u32 ffu_data_len; >>>> + u32 timeout; >>>> + >>>> + /* Check if FFU is supported */ >>>> + if (!card->ext_csd.ffu_capable) { >>>> + pr_err("FFU: %s: error FFU is not supported\n", >>>> + mmc_hostname(card->host)); >>>> + return -EOPNOTSUPP; >>>> + } >>>> + >>>> + err = mmc_send_ext_csd(card, ext_csd); >>>> + if (err) { >>>> + pr_err("FFU: %s: error %d sending ext_csd\n", >>>> + mmc_hostname(card->host), err); >>>> + return err; >>>> + } >>>> + >>>> + /* check mode operation */ >>>> + if (!FFU_FEATURES(ext_csd[EXT_CSD_FFU_FEATURES])) { >>>> + /* restart the eMMC */ >>>> + err = mmc_ffu_restart(card); >>>> + if (err) { >>>> + pr_err("FFU: %s: install error %d:\n", >>>> + mmc_hostname(card->host), err); >>>> + return err; >>>> + } >>>> + } else { >>>> + >>>> + ffu_data_len = ext_csd[EXT_CSD_NUM_OF_FW_SEC_PROG]| >>>> + ext_csd[EXT_CSD_NUM_OF_FW_SEC_PROG + 1] << 8 | >>>> + ext_csd[EXT_CSD_NUM_OF_FW_SEC_PROG + 2] << 16 | >>>> + ext_csd[EXT_CSD_NUM_OF_FW_SEC_PROG + 3] << >>>> + 24; >>>> + >>>> + if (!ffu_data_len) { >>>> + err = -EPERM; >>>> + return err; >>>> + } >>>> + /* set device to FFU mode */ >>>> + err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, >>>> + EXT_CSD_MODE_CONFIG, 0x1, >>>> + card->ext_csd.generic_cmd6_time); >>>> + >>>> + if (err) { >>>> + pr_err("FFU: %s: error %d FFU is not supported\n", >>>> + mmc_hostname(card->host), err); >>>> + return err; >>>> + } >>>> + >>>> + timeout = ext_csd[EXT_CSD_OPERATION_CODE_TIMEOUT]; >>>> + if (timeout == 0 || timeout > 0x17) { >>>> + timeout = 0x17; >>>> + pr_warn("FFU: %s: operation code timeout is out " >>>> + "of range. Using maximum timeout.\n", >>>> + mmc_hostname(card->host)); >>>> + } >>>> + >>>> + /* timeout is at millisecond resolution */ >>>> + timeout = (100 * (1 << timeout) / 1000) + 1; >>>> + >>>> + /* set ext_csd to install mode */ >>>> + err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, >>>> + EXT_CSD_MODE_OPERATION_CODES, >>>> + MMC_FFU_INSTALL_SET, timeout); >>>> + >>>> + if (err) { >>>> + pr_err("FFU: %s: error %d setting install mode\n", >>>> + mmc_hostname(card->host), err); >>>> + return err; >>>> + } >>>> + } >>>> + >>>> + /* read ext_csd */ >>>> + err = mmc_send_ext_csd(card, ext_csd); >>>> + if (err) { >>>> + pr_err("FFU: %s: error %d sending ext_csd\n", >>>> + mmc_hostname(card->host), err); >>>> + return err; >>>> + } >>>> + >>>> + /* return status */ >>>> + err = ext_csd[EXT_CSD_FFU_STATUS]; >>>> + if (err) { >>>> + pr_err("FFU: %s: error %d FFU install:\n", >>>> + mmc_hostname(card->host), err); >>>> + return -EINVAL; >>>> + } >>>> + >>>> + return 0; >>>> +} >>>> +EXPORT_SYMBOL(mmc_ffu_install); >>>> diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c index >>>> 98e9eb0..a29065a 100644 >>>> --- a/drivers/mmc/core/mmc.c >>>> +++ b/drivers/mmc/core/mmc.c >>>> @@ -571,6 +571,14 @@ static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd) >>>> card->ext_csd.data_sector_size = 512; >>>> } >>>> >>>> + /* eMMC v5 or later */ >>>> + if (card->ext_csd.rev >= 7) { >>>> + card->ext_csd.ffu_capable = >>>> + ((ext_csd[EXT_CSD_SUPPORTED_MODE] & 1) == 1) && >>>> + ((ext_csd[EXT_CSD_FW_CONFIG] & 1) == 0); >>>> + } else { >>>> + card->ext_csd.ffu_capable = false; >>>> + } >>>> out: >>>> return err; >>>> } >>>> diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h >>>> index b730272..bc6f6d0 100644 >>>> --- a/include/linux/mmc/card.h >>>> +++ b/include/linux/mmc/card.h >>>> @@ -87,6 +87,7 @@ struct mmc_ext_csd { >>>> unsigned int data_tag_unit_size; /* DATA TAG UNIT size */ >>>> unsigned int boot_ro_lock; /* ro lock support */ >>>> bool boot_ro_lockable; >>>> + bool ffu_capable; /* FFU support */ >>>> u8 raw_exception_status; /* 54 */ >>>> u8 raw_partition_support; /* 160 */ >>>> u8 raw_rpmb_size_mult; /* 168 */ >>>> diff --git a/include/linux/mmc/ffu.h b/include/linux/mmc/ffu.h new >>>> file mode 100644 index 0000000..7e4133d >>>> --- /dev/null >>>> +++ b/include/linux/mmc/ffu.h >>>> @@ -0,0 +1,51 @@ >>>> +/* >>>> + * >>>> + * ffu.h >>>> + * >>>> + * Copyright (c) 2013 SanDisk Corp. >>>> + * >>>> + * This program is free software; you can redistribute it and/or >>>> +modify >>>> + * it under the terms of the GNU General Public License as >>>> +published by >>>> + * the Free Software Foundation; either version 2 of the License, >>>> +or (at >>>> + * your option) any later version. >>>> + * >>>> + * This program was created by SanDisk Corp >>>> + * The ffu.h file is obtained under the GPL v2.0 license that is >>>> + * available via http://www.gnu.org/licenses/, >>>> + * or http://www.opensource.org/licenses/gpl-2.0.php >>>> +*/ >>>> + >>>> +#if !defined(_FFU_H_) >>>> +#define _FFU_H_ >>>> + >>>> +#include <linux/mmc/card.h> >>>> + >>>> +#define CARD_BLOCK_SIZE 512 >>>> + >>>> +/* >>>> + * eMMC5.0 Field Firmware Update (FFU) opcodes */ #define >>> Something is wrong here. This patch would not compile, some carriage >>> returns are missing. >>>> +MMC_FFU_DOWNLOAD_OP 302 #define MMC_FFU_INSTALL_OP 303 >>> Here too. >>>> + >>>> +#define MMC_FFU_MODE_SET 0x1 >>>> +#define MMC_FFU_MODE_NORMAL 0x0 >>>> +#define MMC_FFU_INSTALL_SET 0x1 >>>> + >>>> +#ifdef CONFIG_MMC_FFU >>>> +#define MMC_FFU_FEATURES 0x1 >>>> +#define FFU_FEATURES(ffu_features) (ffu_features & >>>> +MMC_FFU_FEATURES) >>>> + >>>> +int mmc_ffu_download(struct mmc_card *card, const char *name); int >>>> +mmc_ffu_install(struct mmc_card *card); #else static inline int >>> Here too. >>>> +mmc_ffu_download(struct mmc_card *card, const char *name) { >>>> + return -ENOSYS; >>>> +} >>>> +static inline int mmc_ffu_install(struct mmc_card *card) { >>>> + return -ENOSYS; >>>> +} >>>> +#endif >>>> +#endif /* FFU_H_ */ >>>> diff --git a/include/linux/mmc/mmc.h b/include/linux/mmc/mmc.h index >>>> 50bcde3..3651449 100644 >>>> --- a/include/linux/mmc/mmc.h >>>> +++ b/include/linux/mmc/mmc.h >>>> @@ -272,6 +272,9 @@ struct _mmc_csd { >>>> * EXT_CSD fields >>>> */ >>>> >>>> +#define EXT_CSD_FFU_STATUS 26 /* R */ >>>> +#define EXT_CSD_MODE_OPERATION_CODES 29 /* W */ >>>> +#define EXT_CSD_MODE_CONFIG 30 /* R/W */ >>>> #define EXT_CSD_FLUSH_CACHE 32 /* W */ >>>> #define EXT_CSD_CACHE_CTRL 33 /* R/W */ >>>> #define EXT_CSD_POWER_OFF_NOTIFICATION 34 /* R/W */ >>>> @@ -290,6 +293,7 @@ struct _mmc_csd { >>>> #define EXT_CSD_SANITIZE_START 165 /* W */ >>>> #define EXT_CSD_WR_REL_PARAM 166 /* RO */ >>>> #define EXT_CSD_RPMB_MULT 168 /* RO */ >>>> +#define EXT_CSD_FW_CONFIG 169 /* R/W */ >>>> #define EXT_CSD_BOOT_WP 173 /* R/W */ >>>> #define EXT_CSD_ERASE_GROUP_DEF 175 /* R/W */ >>>> #define EXT_CSD_PART_CONFIG 179 /* R/W */ >>>> @@ -325,6 +329,11 @@ struct _mmc_csd { >>>> #define EXT_CSD_POWER_OFF_LONG_TIME 247 /* RO */ >>>> #define EXT_CSD_GENERIC_CMD6_TIME 248 /* RO */ >>>> #define EXT_CSD_CACHE_SIZE 249 /* RO, 4 bytes */ >>>> +#define EXT_CSD_NUM_OF_FW_SEC_PROG 302 /* RO, 4 bytes */ >>>> +#define EXT_CSD_FFU_ARG 487 /* RO, 4 bytes */ >>>> +#define EXT_CSD_OPERATION_CODE_TIMEOUT 491 /* RO */ >>>> +#define EXT_CSD_FFU_FEATURES 492 /* RO */ >>>> +#define EXT_CSD_SUPPORTED_MODE 493 /* RO */ >>>> #define EXT_CSD_TAG_UNIT_SIZE 498 /* RO */ >>>> #define EXT_CSD_DATA_TAG_SUPPORT 499 /* RO */ >>>> #define EXT_CSD_MAX_PACKED_WRITES 500 /* RO */ >>>> -- >>>> To unsubscribe from this list: send the line "unsubscribe linux-mmc" >>>> in the body of a message to majordomo@xxxxxxxxxxxxxxx More majordomo >>>> info at http://vger.kernel.org/majordomo-info.html >>>> >>>> -- >>>> To unsubscribe from this list: send the line "unsubscribe linux-mmc" >>>> in the body of a message to majordomo@xxxxxxxxxxxxxxx More majordomo >>>> info at http://vger.kernel.org/majordomo-info.html -- To unsubscribe from this list: send the line "unsubscribe linux-mmc" in the body of a message to majordomo@xxxxxxxxxxxxxxx More majordomo info at http://vger.kernel.org/majordomo-info.html
