From patchwork Thu Apr 21 11:04:21 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Peter Griffin X-Patchwork-Id: 66369 Delivered-To: patch@linaro.org Received: by 10.140.93.198 with SMTP id d64csp74209qge; Thu, 21 Apr 2016 04:06:55 -0700 (PDT) X-Received: by 10.66.119.177 with SMTP id kv17mr19850149pab.124.1461236815022; Thu, 21 Apr 2016 04:06:55 -0700 (PDT) Return-Path: Received: from bombadil.infradead.org (bombadil.infradead.org. [2001:1868:205::9]) by mx.google.com with ESMTPS id f22si177685pfj.46.2016.04.21.04.06.54 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Thu, 21 Apr 2016 04:06:55 -0700 (PDT) Received-SPF: pass (google.com: best guess record for domain of linux-arm-kernel-bounces+patch=linaro.org@lists.infradead.org designates 2001:1868:205::9 as permitted sender) client-ip=2001:1868:205::9; Authentication-Results: mx.google.com; dkim=neutral (body hash did not verify) header.i=@linaro.org; spf=pass (google.com: best guess record for domain of linux-arm-kernel-bounces+patch=linaro.org@lists.infradead.org designates 2001:1868:205::9 as permitted sender) smtp.mailfrom=linux-arm-kernel-bounces+patch=linaro.org@lists.infradead.org; dmarc=fail (p=NONE dis=NONE) header.from=linaro.org Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.80.1 #2 (Red Hat Linux)) id 1atCQW-0002IH-6d; Thu, 21 Apr 2016 11:05:40 +0000 Received: from mail-wm0-x230.google.com ([2a00:1450:400c:c09::230]) by bombadil.infradead.org with esmtps (Exim 4.80.1 #2 (Red Hat Linux)) id 1atCQ0-0000jU-Mw for linux-arm-kernel@lists.infradead.org; Thu, 21 Apr 2016 11:05:10 +0000 Received: by mail-wm0-x230.google.com with SMTP id u206so126275890wme.1 for ; Thu, 21 Apr 2016 04:04:48 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=Eia/xsUPV6GDaDoKN8RdJYfCZWsHdYKT7akN09O9kuI=; b=klywr86A/XEl+uEEbvYlYWZUgGYVhhgoQluZmjrEqyTEmSj1sO7xrEBdnFIn/44yBB HXQTj2DgF3gAOFNwtBOZ4chXOK9KLieFrO4NMcvv+/TIC/xXuwRIsLTiA2MZyoSwpaPy LSw84DShumqP7aGIjzSM4ShtbEddJ+mfCutJ4= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=Eia/xsUPV6GDaDoKN8RdJYfCZWsHdYKT7akN09O9kuI=; b=mUj4Y5bKmSsvZ7D3RguXOdu4o7ZYQ3zPULQfiZleoM8Nkxln5aRURaZnGgm1dsYLcB qorbqQVIgmBCEm+f4O9SHeSw4aR1oamUayXR618dyJWjVixCAcG+5K55nTx4sqhKEr0+ N3eM7dssSkw1G0JjXUm02/UqFtoR2Gd3l8M3unRozfQaqOyRujg1Wi37kdczjK2AJ8xC 5HkMETBorq7hb8VcL9I45QLdPjv2m9guJjRywa1y6jwev+pMFBA7y24q1iD3I1x8TXvq XpCNIjbbXpwJLAP7BV44wdUh4bqSW9kL7cpX03RZdd2kzPQOycxR/LRxit4cokvLGlqZ xULg== X-Gm-Message-State: AOPr4FWfzwSwbL5dvM8lJA7YzsBTpDUFspJMZJl71Xgec/2EajqYgH8Dk4+bdnUKKSxhmYRp X-Received: by 10.194.175.168 with SMTP id cb8mr13744395wjc.56.1461236687259; Thu, 21 Apr 2016 04:04:47 -0700 (PDT) Received: from localhost.localdomain (cpc84787-aztw28-2-0-cust15.18-1.cable.virginm.net. [82.37.140.16]) by smtp.gmail.com with ESMTPSA id v143sm9184279wmv.4.2016.04.21.04.04.45 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Thu, 21 Apr 2016 04:04:46 -0700 (PDT) From: Peter Griffin To: linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, srinivas.kandagatla@gmail.com, maxime.coquelin@st.com, patrice.chotard@st.com, vinod.koul@intel.com Subject: [PATCH 04/18] dmaengine: st_fdma: Add xp70 firmware loading mechanism. Date: Thu, 21 Apr 2016 12:04:21 +0100 Message-Id: <1461236675-10176-5-git-send-email-peter.griffin@linaro.org> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1461236675-10176-1-git-send-email-peter.griffin@linaro.org> References: <1461236675-10176-1-git-send-email-peter.griffin@linaro.org> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20160421_040509_204484_9EC30995 X-CRM114-Status: GOOD ( 19.59 ) X-Spam-Score: -2.7 (--) X-Spam-Report: SpamAssassin version 3.4.0 on bombadil.infradead.org summary: Content analysis details: (-2.7 points) pts rule name description ---- ---------------------- -------------------------------------------------- -0.7 RCVD_IN_DNSWL_LOW RBL: Sender listed at http://www.dnswl.org/, low trust [2a00:1450:400c:c09:0:0:0:230 listed in] [list.dnswl.org] -0.0 SPF_PASS SPF: sender matches SPF record -1.9 BAYES_00 BODY: Bayes spam probability is 0 to 1% [score: 0.0000] 0.1 DKIM_SIGNED Message has a DKIM or DK signature, not necessarily valid -0.1 DKIM_VALID Message has at least one valid DKIM or DK signature -0.1 DKIM_VALID_AU Message has a valid DKIM or DK signature from author's domain X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.20 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: devicetree@vger.kernel.org, arnd@arndb.de, peter.griffin@linaro.org, broonie@kernel.org, dmaengine@vger.kernel.org, lee.jones@linaro.org, ludovic.barre@st.com MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patch=linaro.org@lists.infradead.org This patch adds the code to load the xp70 fdma firmware using the asynchronous request_firmware_nowait call so as not to delay bootup of builtin code. Signed-off-by: Peter Griffin --- drivers/dma/st_fdma.c | 196 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 196 insertions(+) -- 1.9.1 _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel diff --git a/drivers/dma/st_fdma.c b/drivers/dma/st_fdma.c index 9bf0100..5fcaf10 100644 --- a/drivers/dma/st_fdma.c +++ b/drivers/dma/st_fdma.c @@ -83,6 +83,162 @@ static struct st_fdma_desc *to_st_fdma_desc(struct virt_dma_desc *vd) return container_of(vd, struct st_fdma_desc, vdesc); } +static void *st_fdma_seg_to_mem(struct st_fdma_dev *fdev, u64 da, int len) +{ + int i; + resource_size_t base = fdev->io_res->start; + const struct st_fdma_ram *fdma_mem = fdev->drvdata->fdma_mem; + void *ptr = NULL; + + for (i = 0; i < fdev->drvdata->num_mem; i++) { + int mem_off = da - (base + fdma_mem[i].offset); + + /* next mem if da is too small */ + if (mem_off < 0) + continue; + + /* next mem if da is too large */ + if (mem_off + len > fdma_mem[i].size) + continue; + + ptr = fdev->io_base + fdma_mem[i].offset + mem_off; + break; + } + + return ptr; +} + +static int +st_fdma_elf_sanity_check(struct st_fdma_dev *fdev, const struct firmware *fw) +{ + const char *fw_name = fdev->fw_name; + struct elf32_hdr *ehdr; + char class; + + if (!fw) { + dev_err(fdev->dev, "failed to load %s\n", fw_name); + return -EINVAL; + } + + if (fw->size < sizeof(*ehdr)) { + dev_err(fdev->dev, "Image is too small\n"); + return -EINVAL; + } + + ehdr = (struct elf32_hdr *)fw->data; + + /* We only support ELF32 at this point */ + class = ehdr->e_ident[EI_CLASS]; + if (class != ELFCLASS32) { + dev_err(fdev->dev, "Unsupported class: %d\n", class); + return -EINVAL; + } + + if (ehdr->e_ident[EI_DATA] != ELFDATA2LSB) { + dev_err(fdev->dev, "Unsupported firmware endianness" + "(%d) expected (%d)\n", ehdr->e_ident[EI_DATA], + ELFDATA2LSB); + return -EINVAL; + } + + if (fw->size < ehdr->e_shoff + sizeof(struct elf32_shdr)) { + dev_err(fdev->dev, "Image is too small (%u)\n", fw->size); + return -EINVAL; + } + + if (memcmp(ehdr->e_ident, ELFMAG, SELFMAG)) { + dev_err(fdev->dev, "Image is corrupted (bad magic)\n"); + return -EINVAL; + } + + if (ehdr->e_phnum != fdev->drvdata->num_mem) { + dev_err(fdev->dev, "spurious nb of segments (%d) expected (%d)" + "\n", ehdr->e_phnum, fdev->drvdata->num_mem); + return -EINVAL; + } + + if (ehdr->e_type != ET_EXEC) { + dev_err(fdev->dev, "Unsupported ELF header type (%d) expected" + " (%d)\n", ehdr->e_type, ET_EXEC); + return -EINVAL; + } + + if (ehdr->e_machine != EM_SLIM) { + dev_err(fdev->dev, "Unsupported ELF header machine (%d) " + "expected (%d)\n", ehdr->e_machine, EM_SLIM); + return -EINVAL; + } + if (ehdr->e_phoff > fw->size) { + dev_err(fdev->dev, "Firmware size is too small\n"); + return -EINVAL; + } + + return 0; +} + +static int +st_fdma_elf_load_segments(struct st_fdma_dev *fdev, const struct firmware *fw) +{ + struct device *dev = fdev->dev; + struct elf32_hdr *ehdr; + struct elf32_phdr *phdr; + int i, mem_loaded = 0; + const u8 *elf_data = fw->data; + + ehdr = (struct elf32_hdr *)elf_data; + phdr = (struct elf32_phdr *)(elf_data + ehdr->e_phoff); + + /* + * go through the available ELF segments + * the program header's paddr member to contain device addresses. + * We then go through the physically contiguous memory regions which we + * allocated (and mapped) earlier on the probe, + * and "translate" device address to kernel addresses, + * so we can copy the segments where they are expected. + */ + for (i = 0; i < ehdr->e_phnum; i++, phdr++) { + u32 da = phdr->p_paddr; + u32 memsz = phdr->p_memsz; + u32 filesz = phdr->p_filesz; + u32 offset = phdr->p_offset; + void *dst; + + if (phdr->p_type != PT_LOAD) + continue; + + dev_dbg(dev, "phdr: type %d da %#x ofst:%#x memsz %#x filesz %#x\n", + phdr->p_type, da, offset, memsz, filesz); + + if (filesz > memsz) { + dev_err(dev, "bad phdr filesz 0x%x memsz 0x%x\n", + filesz, memsz); + break; + } + + if (offset + filesz > fw->size) { + dev_err(dev, "truncated fw: need 0x%x avail 0x%zx\n", + offset + filesz, fw->size); + break; + } + + dst = st_fdma_seg_to_mem(fdev, da, memsz); + if (!dst) { + dev_err(dev, "bad phdr da 0x%x mem 0x%x\n", da, memsz); + break; + } + + if (phdr->p_filesz) + memcpy(dst, elf_data + phdr->p_offset, filesz); + + if (memsz > filesz) + memset(dst + filesz, 0, memsz - filesz); + + mem_loaded++; + } + + return (mem_loaded != fdev->drvdata->num_mem) ? -EIO : 0; +} + static void st_fdma_enable(struct st_fdma_dev *fdev) { unsigned long hw_id, hw_ver, fw_rev; @@ -125,6 +281,37 @@ static int st_fdma_disable(struct st_fdma_dev *fdev) return readl(fdev->io_base + FDMA_EN_OFST); } +static int st_fdma_get_fw(struct st_fdma_dev *fdev) +{ + const struct firmware *fw; + int ret; + + atomic_set(&fdev->fw_loaded, 0); + + dev_info(fdev->dev, "Loading firmware: %s\n", fdev->fw_name); + + ret = request_firmware(&fw, fdev->fw_name, fdev->dev); + if (ret) { + dev_err(fdev->dev, "request_firmware err: %d\n", ret); + return ret; + } + + ret = st_fdma_elf_sanity_check(fdev, fw); + if (ret) + goto out; + + st_fdma_disable(fdev); + ret = st_fdma_elf_load_segments(fdev, fw); + if (ret) + goto out; + + st_fdma_enable(fdev); + atomic_set(&fdev->fw_loaded, 1); +out: + release_firmware(fw); + return ret; +} + static int st_fdma_dreq_get(struct st_fdma_chan *fchan) { struct st_fdma_dev *fdev = fchan->fdev; @@ -738,6 +925,15 @@ static int st_fdma_slave_config(struct dma_chan *chan, struct dma_slave_config *slave_cfg) { struct st_fdma_chan *fchan = to_st_fdma_chan(chan); + int ret; + + if (!atomic_read(&fchan->fdev->fw_loaded)) { + ret = st_fdma_get_fw(fchan->fdev); + if (ret) + dev_err(fchan->fdev->dev, "%s: fdma fw load failed\n" + , __func__); + } + memcpy(&fchan->scfg, slave_cfg, sizeof(fchan->scfg)); return 0; }