From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from phobos.denx.de (phobos.denx.de [85.214.62.61]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 2B731C04A95 for ; Mon, 26 Sep 2022 00:17:43 +0000 (UTC) Received: from h2850616.stratoserver.net (localhost [IPv6:::1]) by phobos.denx.de (Postfix) with ESMTP id C9A8D848C2; Mon, 26 Sep 2022 02:17:40 +0200 (CEST) Authentication-Results: phobos.denx.de; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: phobos.denx.de; spf=pass smtp.mailfrom=u-boot-bounces@lists.denx.de Authentication-Results: phobos.denx.de; dkim=pass (2048-bit key; unprotected) header.d=linaro.org header.i=@linaro.org header.b="O9UVoQB0"; dkim-atps=neutral Received: by phobos.denx.de (Postfix, from userid 109) id 2370E848C2; Mon, 26 Sep 2022 02:17:39 +0200 (CEST) Received: from mail-pf1-x431.google.com (mail-pf1-x431.google.com [IPv6:2607:f8b0:4864:20::431]) (using TLSv1.3 with cipher TLS_AES_128_GCM_SHA256 (128/128 bits)) (No client certificate requested) by phobos.denx.de (Postfix) with ESMTPS id 25E9584AEB for ; Mon, 26 Sep 2022 02:17:36 +0200 (CEST) Authentication-Results: phobos.denx.de; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: phobos.denx.de; spf=pass smtp.mailfrom=takahiro.akashi@linaro.org Received: by mail-pf1-x431.google.com with SMTP id i6so938874pfb.2 for ; Sun, 25 Sep 2022 17:17:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=in-reply-to:content-disposition:mime-version:references :mail-followup-to:message-id:subject:cc:to:from:date:from:to:cc :subject:date; bh=4u8LxkFNlt6ae5G1Xu/2lWEJhL5pf4/3kvPYaQxT/Ks=; b=O9UVoQB0kZmjn5KkmwIP/ETUoYRhnxreMIh0AqCpOi1K+DILG/k8xgfnB890NmBghL 0HlSSnOAiSM3CdfT3ybPeOgVSHKieNv7DX4TXpKU7GVRI9vmETJUsOxmJY7J6FDDxr5I fE5OhLR34zDgrp0Y3V/vktT5r8IjZnE3FHQ6zTU5T7E1XgKeuZWf1QUliKANxvpUE6Ku Exn1oLOms7jgJHFfe6s/kGeQwpmjU/KyMm1lNjK1Ng+7PUTwFfDwSiLJ1cRHV9W1nZH4 pzAFbox+YZecT6ExczUPWobdWditKNsxIMlks/N6bkzP5v4Yf97bmYw1sm0ZebGw+n0q m2gw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=in-reply-to:content-disposition:mime-version:references :mail-followup-to:message-id:subject:cc:to:from:date :x-gm-message-state:from:to:cc:subject:date; bh=4u8LxkFNlt6ae5G1Xu/2lWEJhL5pf4/3kvPYaQxT/Ks=; b=sAMhXkD9eHqMKK9LexltW6HcC4OhabNMTfDpzCamzxd3Mw+6OizgcdfW56evV/5+QH xPmWq3F3Dj65XoBK0OvyW+zlrd2vw03h0WhJ9dI/By4a3Mud1vi11NWTStSI/UpO6xcK q03MPJTfVhYnEfYr7xCGWV4Y0CbjWJXB1BS3tY21P6OBQctQMDQtmjMsm4gCw8ztzuFh 8aiTilRjtNRwDvpL+vOeGjTdQSXp2wnDYt0l6y81PJGT5Ix7hh3WsW69cUJ66mn/6WiJ +kVtiqlfGcJ9IImTo5Wj0ixGP8v78ku1XBN1p4OLAKNW32D3bZypY1odzo28Z7KZSHmq wPzg== X-Gm-Message-State: ACrzQf2n3khr/JCx7v5syOhAxbYX9b9jCkLNCbVrwp1xX+cTpY6Hjz+R whF5dsFHH8gXo8WR9BETzpyIdg== X-Google-Smtp-Source: AMsMyM7Zbux6u2OK6k/pPQeSMB+AxPtoFL7Xsz14NVKQ2VOK+2OUXo6cK4Hcz4OQI5/EE3ErFTqm2g== X-Received: by 2002:a62:e80c:0:b0:54a:817b:a6ac with SMTP id c12-20020a62e80c000000b0054a817ba6acmr21026954pfi.59.1664151454270; Sun, 25 Sep 2022 17:17:34 -0700 (PDT) Received: from laputa ([2400:4050:c3e1:100:de10:5d34:d7df:e257]) by smtp.gmail.com with ESMTPSA id r12-20020a17090a940c00b001f5513f6fb9sm5364690pjo.14.2022.09.25.17.17.30 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 25 Sep 2022 17:17:33 -0700 (PDT) Date: Mon, 26 Sep 2022 09:17:28 +0900 From: AKASHI Takahiro To: Simon Glass Cc: U-Boot Mailing List , Tom Rini , Heinrich Schuchardt , Marek Vasut , Masahisa Kojima , Pavel Herrmann Subject: Re: [PATCH 14/45] dm: blk: Add udevice functions Message-ID: <20220926001728.GB7925@laputa> Mail-Followup-To: AKASHI Takahiro , Simon Glass , U-Boot Mailing List , Tom Rini , Heinrich Schuchardt , Marek Vasut , Masahisa Kojima , Pavel Herrmann References: <20220925150248.2524421-1-sjg@chromium.org> <20220925150248.2524421-15-sjg@chromium.org> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20220925150248.2524421-15-sjg@chromium.org> X-BeenThere: u-boot@lists.denx.de X-Mailman-Version: 2.1.39 Precedence: list List-Id: U-Boot discussion List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: u-boot-bounces@lists.denx.de Sender: "U-Boot" X-Virus-Scanned: clamav-milter 0.103.6 at phobos.denx.de X-Virus-Status: Clean Hi Simon, On Sun, Sep 25, 2022 at 09:02:17AM -0600, Simon Glass wrote: > At present we have functions called blk_dread(), etc., which take a > struct blk_desc * to refer to the block device. Add some functions which > use udevice instead, since this is more in keeping with how driver model > is supposed to work. Unfortunately, NAK. I have already added similar functions in disk/disk-uclass.c with my commit 59da9d4782cd ("dm: disk: add read/write interfaces with udevice"). dev_read()/dev_write() works well with UCLASS_BLK (as intended). I remember that you also ack'ed that patch. -Takahiro Akashi > Update one of the tests to use this. > > Signed-off-by: Simon Glass > --- > > drivers/block/blk-uclass.c | 51 +++++++++++++++++++++++++------------- > include/blk.h | 39 ++++++++++++++++++++++++++++- > test/dm/usb.c | 11 +++++--- > 3 files changed, 80 insertions(+), 21 deletions(-) > > diff --git a/drivers/block/blk-uclass.c b/drivers/block/blk-uclass.c > index f8157c8d6ae..7070fd15c89 100644 > --- a/drivers/block/blk-uclass.c > +++ b/drivers/block/blk-uclass.c > @@ -444,53 +444,70 @@ int blk_get_device(int uclass_id, int devnum, struct udevice **devp) > return device_probe(*devp); > } > > -unsigned long blk_dread(struct blk_desc *block_dev, lbaint_t start, > - lbaint_t blkcnt, void *buffer) > +long blk_read(struct udevice *dev, lbaint_t start, lbaint_t blkcnt, void *buf) > { > - struct udevice *dev = block_dev->bdev; > + struct blk_desc *desc = dev_get_uclass_plat(dev); > const struct blk_ops *ops = blk_get_ops(dev); > ulong blks_read; > > if (!ops->read) > return -ENOSYS; > > - if (blkcache_read(block_dev->uclass_id, block_dev->devnum, > - start, blkcnt, block_dev->blksz, buffer)) > + if (blkcache_read(desc->uclass_id, desc->devnum, > + start, blkcnt, desc->blksz, buf)) > return blkcnt; > - blks_read = ops->read(dev, start, blkcnt, buffer); > + blks_read = ops->read(dev, start, blkcnt, buf); > if (blks_read == blkcnt) > - blkcache_fill(block_dev->uclass_id, block_dev->devnum, > - start, blkcnt, block_dev->blksz, buffer); > + blkcache_fill(desc->uclass_id, desc->devnum, start, blkcnt, > + desc->blksz, buf); > > return blks_read; > } > > -unsigned long blk_dwrite(struct blk_desc *block_dev, lbaint_t start, > - lbaint_t blkcnt, const void *buffer) > +long blk_write(struct udevice *dev, lbaint_t start, lbaint_t blkcnt, > + const void *buf) > { > - struct udevice *dev = block_dev->bdev; > + struct blk_desc *desc = dev_get_uclass_plat(dev); > const struct blk_ops *ops = blk_get_ops(dev); > > if (!ops->write) > return -ENOSYS; > > - blkcache_invalidate(block_dev->uclass_id, block_dev->devnum); > - return ops->write(dev, start, blkcnt, buffer); > + blkcache_invalidate(desc->uclass_id, desc->devnum); > + > + return ops->write(dev, start, blkcnt, buf); > } > > -unsigned long blk_derase(struct blk_desc *block_dev, lbaint_t start, > - lbaint_t blkcnt) > +long blk_erase(struct udevice *dev, lbaint_t start, lbaint_t blkcnt) > { > - struct udevice *dev = block_dev->bdev; > + struct blk_desc *desc = dev_get_uclass_plat(dev); > const struct blk_ops *ops = blk_get_ops(dev); > > if (!ops->erase) > return -ENOSYS; > > - blkcache_invalidate(block_dev->uclass_id, block_dev->devnum); > + blkcache_invalidate(desc->uclass_id, desc->devnum); > + > return ops->erase(dev, start, blkcnt); > } > > +ulong blk_dread(struct blk_desc *desc, lbaint_t start, lbaint_t blkcnt, > + void *buffer) > +{ > + return blk_read(desc->bdev, start, blkcnt, buffer); > +} > + > +ulong blk_dwrite(struct blk_desc *desc, lbaint_t start, lbaint_t blkcnt, > + const void *buffer) > +{ > + return blk_write(desc->bdev, start, blkcnt, buffer); > +} > + > +ulong blk_derase(struct blk_desc *desc, lbaint_t start, lbaint_t blkcnt) > +{ > + return blk_erase(desc->bdev, start, blkcnt); > +} > + > int blk_get_from_parent(struct udevice *parent, struct udevice **devp) > { > struct udevice *dev; > diff --git a/include/blk.h b/include/blk.h > index cdc6f0fc7eb..8614d1420ac 100644 > --- a/include/blk.h > +++ b/include/blk.h > @@ -273,6 +273,43 @@ unsigned long blk_dwrite(struct blk_desc *block_dev, lbaint_t start, > unsigned long blk_derase(struct blk_desc *block_dev, lbaint_t start, > lbaint_t blkcnt); > > +/** > + * blk_read() - Read from a block device > + * > + * @dev: Device to read from > + * @start: Start block for the read > + * @blkcnt: Number of blocks to read > + * @buf: Place to put the data > + * @return number of blocks read (which may be less than @blkcnt), > + * or -ve on error. This never returns 0 unless @blkcnt is 0 > + */ > +long blk_read(struct udevice *dev, lbaint_t start, lbaint_t blkcnt, > + void *buffer); > + > +/** > + * blk_write() - Write to a block device > + * > + * @dev: Device to write to > + * @start: Start block for the write > + * @blkcnt: Number of blocks to write > + * @buf: Data to write > + * @return number of blocks written (which may be less than @blkcnt), > + * or -ve on error. This never returns 0 unless @blkcnt is 0 > + */ > +long blk_write(struct udevice *dev, lbaint_t start, lbaint_t blkcnt, > + const void *buffer); > + > +/** > + * blk_erase() - Erase part of a block device > + * > + * @dev: Device to erase > + * @start: Start block for the erase > + * @blkcnt: Number of blocks to erase > + * @return number of blocks erased (which may be less than @blkcnt), > + * or -ve on error. This never returns 0 unless @blkcnt is 0 > + */ > +long blk_erase(struct udevice *dev, lbaint_t start, lbaint_t blkcnt); > + > /** > * blk_find_device() - Find a block device > * > @@ -428,7 +465,7 @@ const char *blk_get_devtype(struct udevice *dev); > > /** > * blk_get_by_device() - Get the block device descriptor for the given device > - * @dev: Instance of a storage device > + * @dev: Instance of a storage device (the parent of the block device) > * > * Return: With block device descriptor on success , NULL if there is no such > * block device. > diff --git a/test/dm/usb.c b/test/dm/usb.c > index 5d6ceefce0b..445b21a560b 100644 > --- a/test/dm/usb.c > +++ b/test/dm/usb.c > @@ -43,19 +43,24 @@ DM_TEST(dm_test_usb_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT); > */ > static int dm_test_usb_flash(struct unit_test_state *uts) > { > - struct udevice *dev; > - struct blk_desc *dev_desc; > + struct blk_desc *dev_desc, *chk; > + struct udevice *dev, *blk; > char cmp[1024]; > > state_set_skip_delays(true); > ut_assertok(usb_init()); > ut_assertok(uclass_get_device(UCLASS_MASS_STORAGE, 0, &dev)); > ut_assertok(blk_get_device_by_str("usb", "0", &dev_desc)); > + chk = blk_get_by_device(dev); > + ut_asserteq_ptr(chk, dev_desc); > + > + ut_assertok(device_find_first_child_by_uclass(dev, UCLASS_BLK, &blk)); > + ut_asserteq_ptr(chk, blk_get_by_device(dev)); > > /* Read a few blocks and look for the string we expect */ > ut_asserteq(512, dev_desc->blksz); > memset(cmp, '\0', sizeof(cmp)); > - ut_asserteq(2, blk_dread(dev_desc, 0, 2, cmp)); > + ut_asserteq(2, blk_read(blk, 0, 2, cmp)); > ut_assertok(strcmp(cmp, "this is a test")); > ut_assertok(usb_stop()); > > -- > 2.37.3.998.g577e59143f-goog >