From mboxrd@z Thu Jan 1 00:00:00 1970 From: bgolaszewski@baylibre.com (Bartosz Golaszewski) Date: Mon, 31 Oct 2016 15:45:35 +0100 Subject: [PATCH v2 2/5] ARM: bus: da8xx-mstpri: new driver In-Reply-To: <1477925138-23457-1-git-send-email-bgolaszewski@baylibre.com> References: <1477925138-23457-1-git-send-email-bgolaszewski@baylibre.com> Message-ID: <1477925138-23457-3-git-send-email-bgolaszewski@baylibre.com> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org Create the driver for the da8xx master peripheral priority configuration and implement support for writing to the three Master Priority registers on da850 SoCs. Signed-off-by: Bartosz Golaszewski --- .../devicetree/bindings/bus/ti,da850-mstpri.txt | 20 ++ drivers/bus/Kconfig | 9 + drivers/bus/Makefile | 2 + drivers/bus/da8xx-mstpri.c | 269 +++++++++++++++++++++ 4 files changed, 300 insertions(+) create mode 100644 Documentation/devicetree/bindings/bus/ti,da850-mstpri.txt create mode 100644 drivers/bus/da8xx-mstpri.c diff --git a/Documentation/devicetree/bindings/bus/ti,da850-mstpri.txt b/Documentation/devicetree/bindings/bus/ti,da850-mstpri.txt new file mode 100644 index 0000000..72daefc --- /dev/null +++ b/Documentation/devicetree/bindings/bus/ti,da850-mstpri.txt @@ -0,0 +1,20 @@ +* Device tree bindings for Texas Instruments da8xx master peripheral + priority driver + +DA8XX SoCs feature a set of registers allowing to change the priority of all +peripherals classified as masters. + +Documentation: +OMAP-L138 (DA850) - http://www.ti.com/lit/ug/spruh82c/spruh82c.pdf + +Required properties: + +- compatible: "ti,da850-mstpri" - for da850 based boards +- reg: offset and length of the mstpri registers + +Example for da850-lcdk is shown below. + +mstpri { + compatible = "ti,da850-mstpri"; + reg = <0x14110 0x0c>; +}; diff --git a/drivers/bus/Kconfig b/drivers/bus/Kconfig index 7875105..f5db3a7 100644 --- a/drivers/bus/Kconfig +++ b/drivers/bus/Kconfig @@ -167,4 +167,13 @@ config VEXPRESS_CONFIG help Platform configuration infrastructure for the ARM Ltd. Versatile Express. + +config DA8XX_MSTPRI + bool "TI da8xx master peripheral priority driver" + depends on ARCH_DAVINCI_DA8XX + help + Driver for Texas Instruments da8xx master peripheral priority + configuration. Allows to adjust the priorities of all master + peripherals. + endmenu diff --git a/drivers/bus/Makefile b/drivers/bus/Makefile index c6cfa6b..2adb540 100644 --- a/drivers/bus/Makefile +++ b/drivers/bus/Makefile @@ -21,3 +21,5 @@ obj-$(CONFIG_SIMPLE_PM_BUS) += simple-pm-bus.o obj-$(CONFIG_TEGRA_ACONNECT) += tegra-aconnect.o obj-$(CONFIG_UNIPHIER_SYSTEM_BUS) += uniphier-system-bus.o obj-$(CONFIG_VEXPRESS_CONFIG) += vexpress-config.o + +obj-$(CONFIG_DA8XX_MSTPRI) += da8xx-mstpri.o diff --git a/drivers/bus/da8xx-mstpri.c b/drivers/bus/da8xx-mstpri.c new file mode 100644 index 0000000..85f0b53 --- /dev/null +++ b/drivers/bus/da8xx-mstpri.c @@ -0,0 +1,269 @@ +/* + * TI da8xx master peripheral priority driver + * + * Copyright (C) 2016 BayLibre SAS + * + * Author: + * Bartosz Golaszewski + * + * 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 +#include +#include +#include +#include +#include + +/* + * REVISIT: Linux doesn't have a good framework for the kind of performance + * knobs this driver controls. We can't use device tree properties as it deals + * with hardware configuration rather than description. We also don't want to + * commit to maintaining some random sysfs attributes. + * + * For now we just hardcode the register values for the boards that need + * some changes (as is the case for the LCD controller on da850-lcdk - the + * first board we support here). When linux gets an appropriate framework, + * we'll easily convert the driver to it. + */ + +#define DA8XX_MSTPRI0_OFFSET 0 +#define DA8XX_MSTPRI1_OFFSET 4 +#define DA8XX_MSTPRI2_OFFSET 8 + +enum { + DA8XX_MSTPRI_ARM_I = 0, + DA8XX_MSTPRI_ARM_D, + DA8XX_MSTPRI_UPP, + DA8XX_MSTPRI_SATA, + DA8XX_MSTPRI_PRU0, + DA8XX_MSTPRI_PRU1, + DA8XX_MSTPRI_EDMA30TC0, + DA8XX_MSTPRI_EDMA30TC1, + DA8XX_MSTPRI_EDMA31TC0, + DA8XX_MSTPRI_VPIF_DMA_0, + DA8XX_MSTPRI_VPIF_DMA_1, + DA8XX_MSTPRI_EMAC, + DA8XX_MSTPRI_USB0CFG, + DA8XX_MSTPRI_USB0CDMA, + DA8XX_MSTPRI_UHPI, + DA8XX_MSTPRI_USB1, + DA8XX_MSTPRI_LCDC, +}; + +struct da8xx_mstpri_descr { + int reg; + int shift; + int mask; +}; + +static const struct da8xx_mstpri_descr da8xx_mstpri_priority_list[] = { + [DA8XX_MSTPRI_ARM_I] = { + .reg = DA8XX_MSTPRI0_OFFSET, + .shift = 0, + .mask = 0x0000000f, + }, + [DA8XX_MSTPRI_ARM_D] = { + .reg = DA8XX_MSTPRI0_OFFSET, + .shift = 4, + .mask = 0x000000f0, + }, + [DA8XX_MSTPRI_UPP] = { + .reg = DA8XX_MSTPRI0_OFFSET, + .shift = 16, + .mask = 0x000f0000, + }, + [DA8XX_MSTPRI_SATA] = { + .reg = DA8XX_MSTPRI0_OFFSET, + .shift = 20, + .mask = 0x00f00000, + }, + [DA8XX_MSTPRI_PRU0] = { + .reg = DA8XX_MSTPRI1_OFFSET, + .shift = 0, + .mask = 0x0000000f, + }, + [DA8XX_MSTPRI_PRU1] = { + .reg = DA8XX_MSTPRI1_OFFSET, + .shift = 4, + .mask = 0x000000f0, + }, + [DA8XX_MSTPRI_EDMA30TC0] = { + .reg = DA8XX_MSTPRI1_OFFSET, + .shift = 8, + .mask = 0x00000f00, + }, + [DA8XX_MSTPRI_EDMA30TC1] = { + .reg = DA8XX_MSTPRI1_OFFSET, + .shift = 12, + .mask = 0x0000f000, + }, + [DA8XX_MSTPRI_EDMA31TC0] = { + .reg = DA8XX_MSTPRI1_OFFSET, + .shift = 16, + .mask = 0x000f0000, + }, + [DA8XX_MSTPRI_VPIF_DMA_0] = { + .reg = DA8XX_MSTPRI1_OFFSET, + .shift = 24, + .mask = 0x0f000000, + }, + [DA8XX_MSTPRI_VPIF_DMA_1] = { + .reg = DA8XX_MSTPRI1_OFFSET, + .shift = 28, + .mask = 0xf0000000, + }, + [DA8XX_MSTPRI_EMAC] = { + .reg = DA8XX_MSTPRI2_OFFSET, + .shift = 0, + .mask = 0x0000000f, + }, + [DA8XX_MSTPRI_USB0CFG] = { + .reg = DA8XX_MSTPRI2_OFFSET, + .shift = 8, + .mask = 0x00000f00, + }, + [DA8XX_MSTPRI_USB0CDMA] = { + .reg = DA8XX_MSTPRI2_OFFSET, + .shift = 12, + .mask = 0x0000f000, + }, + [DA8XX_MSTPRI_UHPI] = { + .reg = DA8XX_MSTPRI2_OFFSET, + .shift = 20, + .mask = 0x00f00000, + }, + [DA8XX_MSTPRI_USB1] = { + .reg = DA8XX_MSTPRI2_OFFSET, + .shift = 24, + .mask = 0x0f000000, + }, + [DA8XX_MSTPRI_LCDC] = { + .reg = DA8XX_MSTPRI2_OFFSET, + .shift = 28, + .mask = 0xf0000000, + }, +}; + +struct da8xx_mstpri_priority { + int which; + u32 val; +}; + +struct da8xx_mstpri_board_priorities { + const char *board; + const struct da8xx_mstpri_priority *priorities; + size_t numprio; +}; + +/* + * Default memory settings of da850 do not meet the throughput/latency + * requirements of tilcdc. This results in the image displayed being + * incorrect and the following warning being displayed by the LCDC + * drm driver: + * + * tilcdc da8xx_lcdc.0: tilcdc_crtc_irq(0x00000020): FIFO underfow + */ +static const struct da8xx_mstpri_priority da850_lcdk_priorities[] = { + { + .which = DA8XX_MSTPRI_LCDC, + .val = 0, + }, + { + .which = DA8XX_MSTPRI_EDMA30TC1, + .val = 0, + }, + { + .which = DA8XX_MSTPRI_EDMA30TC0, + .val = 1, + }, +}; + +static const struct da8xx_mstpri_board_priorities da8xx_mstpri_board_confs[] = { + { + .board = "ti,da850-lcdk", + .priorities = da850_lcdk_priorities, + .numprio = ARRAY_SIZE(da850_lcdk_priorities), + }, +}; + +static const struct da8xx_mstpri_board_priorities * +da8xx_mstpri_get_board_prio(void) +{ + const struct da8xx_mstpri_board_priorities *board_prio; + int i; + + for (i = 0; i < ARRAY_SIZE(da8xx_mstpri_board_confs); i++) { + board_prio = &da8xx_mstpri_board_confs[i]; + + if (of_machine_is_compatible(board_prio->board)) + return board_prio; + } + + return NULL; +} + +static int da8xx_mstpri_probe(struct platform_device *pdev) +{ + const struct da8xx_mstpri_board_priorities *prio_list; + const struct da8xx_mstpri_descr *prio_descr; + const struct da8xx_mstpri_priority *prio; + struct device *dev = &pdev->dev; + struct resource *res; + void __iomem *mstpri; + u32 reg; + int i; + + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + mstpri = devm_ioremap_resource(dev, res); + if (IS_ERR(mstpri)) { + dev_err(dev, "unable to map MSTPRI registers\n"); + return PTR_ERR(mstpri); + } + + prio_list = da8xx_mstpri_get_board_prio(); + if (!prio_list) { + dev_err(dev, "no master priotities defined for board '%s'\n", + of_flat_dt_get_machine_name()); + return -EINVAL; + } + + for (i = 0; i < prio_list->numprio; i++) { + prio = &prio_list->priorities[i]; + prio_descr = &da8xx_mstpri_priority_list[prio->which]; + + if (prio_descr->reg + sizeof(u32) > resource_size(res)) { + dev_warn(dev, "register offset out of range\n"); + continue; + } + + reg = readl(mstpri + prio_descr->reg); + reg &= ~prio_descr->mask; + reg |= prio->val << prio_descr->shift; + + writel(reg, mstpri + prio_descr->reg); + } + + return 0; +} + +static const struct of_device_id da8xx_mstpri_of_match[] = { + { .compatible = "ti,da850-mstpri", }, + { }, +}; + +static struct platform_driver da8xx_mstpri_driver = { + .probe = da8xx_mstpri_probe, + .driver = { + .name = "da8xx-mstpri", + .of_match_table = da8xx_mstpri_of_match, + }, +}; +module_platform_driver(da8xx_mstpri_driver); + +MODULE_AUTHOR("Bartosz Golaszewski "); +MODULE_DESCRIPTION("TI da8xx master peripheral priority driver"); +MODULE_LICENSE("GPL v2"); -- 2.9.3 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Bartosz Golaszewski Subject: [PATCH v2 2/5] ARM: bus: da8xx-mstpri: new driver Date: Mon, 31 Oct 2016 15:45:35 +0100 Message-ID: <1477925138-23457-3-git-send-email-bgolaszewski@baylibre.com> References: <1477925138-23457-1-git-send-email-bgolaszewski@baylibre.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1477925138-23457-1-git-send-email-bgolaszewski@baylibre.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Kevin Hilman , Michael Turquette , Sekhar Nori , Rob Herring , Frank Rowand , Mark Rutland , Peter Ujfalusi , Russell King Cc: linux-devicetree , LKML , linux-drm , Bartosz Golaszewski , Tomi Valkeinen , Jyri Sarha , arm-soc , Laurent Pinchart List-Id: devicetree@vger.kernel.org Q3JlYXRlIHRoZSBkcml2ZXIgZm9yIHRoZSBkYTh4eCBtYXN0ZXIgcGVyaXBoZXJhbCBwcmlvcml0 eQpjb25maWd1cmF0aW9uIGFuZCBpbXBsZW1lbnQgc3VwcG9ydCBmb3Igd3JpdGluZyB0byB0aGUg dGhyZWUKTWFzdGVyIFByaW9yaXR5IHJlZ2lzdGVycyBvbiBkYTg1MCBTb0NzLgoKU2lnbmVkLW9m Zi1ieTogQmFydG9zeiBHb2xhc3pld3NraSA8YmdvbGFzemV3c2tpQGJheWxpYnJlLmNvbT4KLS0t CiAuLi4vZGV2aWNldHJlZS9iaW5kaW5ncy9idXMvdGksZGE4NTAtbXN0cHJpLnR4dCAgICB8ICAy MCArKwogZHJpdmVycy9idXMvS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg fCAgIDkgKwogZHJpdmVycy9idXMvTWFrZWZpbGUgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgfCAgIDIgKwogZHJpdmVycy9idXMvZGE4eHgtbXN0cHJpLmMgICAgICAgICAgICAgICAgICAg ICAgICAgfCAyNjkgKysrKysrKysrKysrKysrKysrKysrCiA0IGZpbGVzIGNoYW5nZWQsIDMwMCBp bnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVl L2JpbmRpbmdzL2J1cy90aSxkYTg1MC1tc3RwcmkudHh0CiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJp dmVycy9idXMvZGE4eHgtbXN0cHJpLmMKCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2Rldmlj ZXRyZWUvYmluZGluZ3MvYnVzL3RpLGRhODUwLW1zdHByaS50eHQgYi9Eb2N1bWVudGF0aW9uL2Rl dmljZXRyZWUvYmluZGluZ3MvYnVzL3RpLGRhODUwLW1zdHByaS50eHQKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMC4uNzJkYWVmYwotLS0gL2Rldi9udWxsCisrKyBiL0RvY3VtZW50 YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9idXMvdGksZGE4NTAtbXN0cHJpLnR4dApAQCAtMCww ICsxLDIwIEBACisqIERldmljZSB0cmVlIGJpbmRpbmdzIGZvciBUZXhhcyBJbnN0cnVtZW50cyBk YTh4eCBtYXN0ZXIgcGVyaXBoZXJhbAorICBwcmlvcml0eSBkcml2ZXIKKworREE4WFggU29DcyBm ZWF0dXJlIGEgc2V0IG9mIHJlZ2lzdGVycyBhbGxvd2luZyB0byBjaGFuZ2UgdGhlIHByaW9yaXR5 IG9mIGFsbAorcGVyaXBoZXJhbHMgY2xhc3NpZmllZCBhcyBtYXN0ZXJzLgorCitEb2N1bWVudGF0 aW9uOgorT01BUC1MMTM4IChEQTg1MCkgLSBodHRwOi8vd3d3LnRpLmNvbS9saXQvdWcvc3BydWg4 MmMvc3BydWg4MmMucGRmCisKK1JlcXVpcmVkIHByb3BlcnRpZXM6CisKKy0gY29tcGF0aWJsZToJ CSJ0aSxkYTg1MC1tc3RwcmkiIC0gZm9yIGRhODUwIGJhc2VkIGJvYXJkcworLSByZWc6CQkJb2Zm c2V0IGFuZCBsZW5ndGggb2YgdGhlIG1zdHByaSByZWdpc3RlcnMKKworRXhhbXBsZSBmb3IgZGE4 NTAtbGNkayBpcyBzaG93biBiZWxvdy4KKworbXN0cHJpIHsKKwljb21wYXRpYmxlID0gInRpLGRh ODUwLW1zdHByaSI7CisJcmVnID0gPDB4MTQxMTAgMHgwYz47Cit9OwpkaWZmIC0tZ2l0IGEvZHJp dmVycy9idXMvS2NvbmZpZyBiL2RyaXZlcnMvYnVzL0tjb25maWcKaW5kZXggNzg3NTEwNS4uZjVk YjNhNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9idXMvS2NvbmZpZworKysgYi9kcml2ZXJzL2J1cy9L Y29uZmlnCkBAIC0xNjcsNCArMTY3LDEzIEBAIGNvbmZpZyBWRVhQUkVTU19DT05GSUcKIAloZWxw CiAJICBQbGF0Zm9ybSBjb25maWd1cmF0aW9uIGluZnJhc3RydWN0dXJlIGZvciB0aGUgQVJNIEx0 ZC4KIAkgIFZlcnNhdGlsZSBFeHByZXNzLgorCitjb25maWcgREE4WFhfTVNUUFJJCisJYm9vbCAi VEkgZGE4eHggbWFzdGVyIHBlcmlwaGVyYWwgcHJpb3JpdHkgZHJpdmVyIgorCWRlcGVuZHMgb24g QVJDSF9EQVZJTkNJX0RBOFhYCisJaGVscAorCSAgRHJpdmVyIGZvciBUZXhhcyBJbnN0cnVtZW50 cyBkYTh4eCBtYXN0ZXIgcGVyaXBoZXJhbCBwcmlvcml0eQorCSAgY29uZmlndXJhdGlvbi4gQWxs b3dzIHRvIGFkanVzdCB0aGUgcHJpb3JpdGllcyBvZiBhbGwgbWFzdGVyCisJICBwZXJpcGhlcmFs cy4KKwogZW5kbWVudQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9idXMvTWFrZWZpbGUgYi9kcml2ZXJz L2J1cy9NYWtlZmlsZQppbmRleCBjNmNmYTZiLi4yYWRiNTQwIDEwMDY0NAotLS0gYS9kcml2ZXJz L2J1cy9NYWtlZmlsZQorKysgYi9kcml2ZXJzL2J1cy9NYWtlZmlsZQpAQCAtMjEsMyArMjEsNSBA QCBvYmotJChDT05GSUdfU0lNUExFX1BNX0JVUykJKz0gc2ltcGxlLXBtLWJ1cy5vCiBvYmotJChD T05GSUdfVEVHUkFfQUNPTk5FQ1QpCSs9IHRlZ3JhLWFjb25uZWN0Lm8KIG9iai0kKENPTkZJR19V TklQSElFUl9TWVNURU1fQlVTKQkrPSB1bmlwaGllci1zeXN0ZW0tYnVzLm8KIG9iai0kKENPTkZJ R19WRVhQUkVTU19DT05GSUcpCSs9IHZleHByZXNzLWNvbmZpZy5vCisKK29iai0kKENPTkZJR19E QThYWF9NU1RQUkkpCSs9IGRhOHh4LW1zdHByaS5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL2J1cy9k YTh4eC1tc3RwcmkuYyBiL2RyaXZlcnMvYnVzL2RhOHh4LW1zdHByaS5jCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAuLjg1ZjBiNTMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJz L2J1cy9kYTh4eC1tc3RwcmkuYwpAQCAtMCwwICsxLDI2OSBAQAorLyoKKyAqIFRJIGRhOHh4IG1h c3RlciBwZXJpcGhlcmFsIHByaW9yaXR5IGRyaXZlcgorICoKKyAqIENvcHlyaWdodCAoQykgMjAx NiBCYXlMaWJyZSBTQVMKKyAqCisgKiBBdXRob3I6CisgKiAgIEJhcnRvc3ogR29sYXN6ZXdza2kg PGJnb2xhc3pld3NraUBiYXlsaWJyZS5jb20uY29tPgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBm cmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgKiBp dCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNp b24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisg Ki8KKworI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L29mLmg+Cisj aW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+CisjaW5jbHVkZSA8bGludXgvaW8uaD4K KyNpbmNsdWRlIDxsaW51eC9yZWdtYXAuaD4KKyNpbmNsdWRlIDxsaW51eC9vZl9mZHQuaD4KKwor LyoKKyAqIFJFVklTSVQ6IExpbnV4IGRvZXNuJ3QgaGF2ZSBhIGdvb2QgZnJhbWV3b3JrIGZvciB0 aGUga2luZCBvZiBwZXJmb3JtYW5jZQorICoga25vYnMgdGhpcyBkcml2ZXIgY29udHJvbHMuIFdl IGNhbid0IHVzZSBkZXZpY2UgdHJlZSBwcm9wZXJ0aWVzIGFzIGl0IGRlYWxzCisgKiB3aXRoIGhh cmR3YXJlIGNvbmZpZ3VyYXRpb24gcmF0aGVyIHRoYW4gZGVzY3JpcHRpb24uIFdlIGFsc28gZG9u J3Qgd2FudCB0bworICogY29tbWl0IHRvIG1haW50YWluaW5nIHNvbWUgcmFuZG9tIHN5c2ZzIGF0 dHJpYnV0ZXMuCisgKgorICogRm9yIG5vdyB3ZSBqdXN0IGhhcmRjb2RlIHRoZSByZWdpc3RlciB2 YWx1ZXMgZm9yIHRoZSBib2FyZHMgdGhhdCBuZWVkCisgKiBzb21lIGNoYW5nZXMgKGFzIGlzIHRo ZSBjYXNlIGZvciB0aGUgTENEIGNvbnRyb2xsZXIgb24gZGE4NTAtbGNkayAtIHRoZQorICogZmly c3QgYm9hcmQgd2Ugc3VwcG9ydCBoZXJlKS4gV2hlbiBsaW51eCBnZXRzIGFuIGFwcHJvcHJpYXRl IGZyYW1ld29yaywKKyAqIHdlJ2xsIGVhc2lseSBjb252ZXJ0IHRoZSBkcml2ZXIgdG8gaXQuCisg Ki8KKworI2RlZmluZSBEQThYWF9NU1RQUkkwX09GRlNFVAkJMAorI2RlZmluZSBEQThYWF9NU1RQ UkkxX09GRlNFVAkJNAorI2RlZmluZSBEQThYWF9NU1RQUkkyX09GRlNFVAkJOAorCitlbnVtIHsK KwlEQThYWF9NU1RQUklfQVJNX0kgPSAwLAorCURBOFhYX01TVFBSSV9BUk1fRCwKKwlEQThYWF9N U1RQUklfVVBQLAorCURBOFhYX01TVFBSSV9TQVRBLAorCURBOFhYX01TVFBSSV9QUlUwLAorCURB OFhYX01TVFBSSV9QUlUxLAorCURBOFhYX01TVFBSSV9FRE1BMzBUQzAsCisJREE4WFhfTVNUUFJJ X0VETUEzMFRDMSwKKwlEQThYWF9NU1RQUklfRURNQTMxVEMwLAorCURBOFhYX01TVFBSSV9WUElG X0RNQV8wLAorCURBOFhYX01TVFBSSV9WUElGX0RNQV8xLAorCURBOFhYX01TVFBSSV9FTUFDLAor CURBOFhYX01TVFBSSV9VU0IwQ0ZHLAorCURBOFhYX01TVFBSSV9VU0IwQ0RNQSwKKwlEQThYWF9N U1RQUklfVUhQSSwKKwlEQThYWF9NU1RQUklfVVNCMSwKKwlEQThYWF9NU1RQUklfTENEQywKK307 CisKK3N0cnVjdCBkYTh4eF9tc3RwcmlfZGVzY3IgeworCWludCByZWc7CisJaW50IHNoaWZ0Owor CWludCBtYXNrOworfTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBkYTh4eF9tc3RwcmlfZGVzY3Ig ZGE4eHhfbXN0cHJpX3ByaW9yaXR5X2xpc3RbXSA9IHsKKwlbREE4WFhfTVNUUFJJX0FSTV9JXSA9 IHsKKwkJLnJlZyA9IERBOFhYX01TVFBSSTBfT0ZGU0VULAorCQkuc2hpZnQgPSAwLAorCQkubWFz ayA9IDB4MDAwMDAwMGYsCisJfSwKKwlbREE4WFhfTVNUUFJJX0FSTV9EXSA9IHsKKwkJLnJlZyA9 IERBOFhYX01TVFBSSTBfT0ZGU0VULAorCQkuc2hpZnQgPSA0LAorCQkubWFzayA9IDB4MDAwMDAw ZjAsCisJfSwKKwlbREE4WFhfTVNUUFJJX1VQUF0gPSB7CisJCS5yZWcgPSBEQThYWF9NU1RQUkkw X09GRlNFVCwKKwkJLnNoaWZ0ID0gMTYsCisJCS5tYXNrID0gMHgwMDBmMDAwMCwKKwl9LAorCVtE QThYWF9NU1RQUklfU0FUQV0gPSB7CisJCS5yZWcgPSBEQThYWF9NU1RQUkkwX09GRlNFVCwKKwkJ LnNoaWZ0ID0gMjAsCisJCS5tYXNrID0gMHgwMGYwMDAwMCwKKwl9LAorCVtEQThYWF9NU1RQUklf UFJVMF0gPSB7CisJCS5yZWcgPSBEQThYWF9NU1RQUkkxX09GRlNFVCwKKwkJLnNoaWZ0ID0gMCwK KwkJLm1hc2sgPSAweDAwMDAwMDBmLAorCX0sCisJW0RBOFhYX01TVFBSSV9QUlUxXSA9IHsKKwkJ LnJlZyA9IERBOFhYX01TVFBSSTFfT0ZGU0VULAorCQkuc2hpZnQgPSA0LAorCQkubWFzayA9IDB4 MDAwMDAwZjAsCisJfSwKKwlbREE4WFhfTVNUUFJJX0VETUEzMFRDMF0gPSB7CisJCS5yZWcgPSBE QThYWF9NU1RQUkkxX09GRlNFVCwKKwkJLnNoaWZ0ID0gOCwKKwkJLm1hc2sgPSAweDAwMDAwZjAw LAorCX0sCisJW0RBOFhYX01TVFBSSV9FRE1BMzBUQzFdID0geworCQkucmVnID0gREE4WFhfTVNU UFJJMV9PRkZTRVQsCisJCS5zaGlmdCA9IDEyLAorCQkubWFzayA9IDB4MDAwMGYwMDAsCisJfSwK KwlbREE4WFhfTVNUUFJJX0VETUEzMVRDMF0gPSB7CisJCS5yZWcgPSBEQThYWF9NU1RQUkkxX09G RlNFVCwKKwkJLnNoaWZ0ID0gMTYsCisJCS5tYXNrID0gMHgwMDBmMDAwMCwKKwl9LAorCVtEQThY WF9NU1RQUklfVlBJRl9ETUFfMF0gPSB7CisJCS5yZWcgPSBEQThYWF9NU1RQUkkxX09GRlNFVCwK KwkJLnNoaWZ0ID0gMjQsCisJCS5tYXNrID0gMHgwZjAwMDAwMCwKKwl9LAorCVtEQThYWF9NU1RQ UklfVlBJRl9ETUFfMV0gPSB7CisJCS5yZWcgPSBEQThYWF9NU1RQUkkxX09GRlNFVCwKKwkJLnNo aWZ0ID0gMjgsCisJCS5tYXNrID0gMHhmMDAwMDAwMCwKKwl9LAorCVtEQThYWF9NU1RQUklfRU1B Q10gPSB7CisJCS5yZWcgPSBEQThYWF9NU1RQUkkyX09GRlNFVCwKKwkJLnNoaWZ0ID0gMCwKKwkJ Lm1hc2sgPSAweDAwMDAwMDBmLAorCX0sCisJW0RBOFhYX01TVFBSSV9VU0IwQ0ZHXSA9IHsKKwkJ LnJlZyA9IERBOFhYX01TVFBSSTJfT0ZGU0VULAorCQkuc2hpZnQgPSA4LAorCQkubWFzayA9IDB4 MDAwMDBmMDAsCisJfSwKKwlbREE4WFhfTVNUUFJJX1VTQjBDRE1BXSA9IHsKKwkJLnJlZyA9IERB OFhYX01TVFBSSTJfT0ZGU0VULAorCQkuc2hpZnQgPSAxMiwKKwkJLm1hc2sgPSAweDAwMDBmMDAw LAorCX0sCisJW0RBOFhYX01TVFBSSV9VSFBJXSA9IHsKKwkJLnJlZyA9IERBOFhYX01TVFBSSTJf T0ZGU0VULAorCQkuc2hpZnQgPSAyMCwKKwkJLm1hc2sgPSAweDAwZjAwMDAwLAorCX0sCisJW0RB OFhYX01TVFBSSV9VU0IxXSA9IHsKKwkJLnJlZyA9IERBOFhYX01TVFBSSTJfT0ZGU0VULAorCQku c2hpZnQgPSAyNCwKKwkJLm1hc2sgPSAweDBmMDAwMDAwLAorCX0sCisJW0RBOFhYX01TVFBSSV9M Q0RDXSA9IHsKKwkJLnJlZyA9IERBOFhYX01TVFBSSTJfT0ZGU0VULAorCQkuc2hpZnQgPSAyOCwK KwkJLm1hc2sgPSAweGYwMDAwMDAwLAorCX0sCit9OworCitzdHJ1Y3QgZGE4eHhfbXN0cHJpX3By aW9yaXR5IHsKKwlpbnQgd2hpY2g7CisJdTMyIHZhbDsKK307CisKK3N0cnVjdCBkYTh4eF9tc3Rw cmlfYm9hcmRfcHJpb3JpdGllcyB7CisJY29uc3QgY2hhciAqYm9hcmQ7CisJY29uc3Qgc3RydWN0 IGRhOHh4X21zdHByaV9wcmlvcml0eSAqcHJpb3JpdGllczsKKwlzaXplX3QgbnVtcHJpbzsKK307 CisKKy8qCisgKiBEZWZhdWx0IG1lbW9yeSBzZXR0aW5ncyBvZiBkYTg1MCBkbyBub3QgbWVldCB0 aGUgdGhyb3VnaHB1dC9sYXRlbmN5CisgKiByZXF1aXJlbWVudHMgb2YgdGlsY2RjLiBUaGlzIHJl c3VsdHMgaW4gdGhlIGltYWdlIGRpc3BsYXllZCBiZWluZworICogaW5jb3JyZWN0IGFuZCB0aGUg Zm9sbG93aW5nIHdhcm5pbmcgYmVpbmcgZGlzcGxheWVkIGJ5IHRoZSBMQ0RDCisgKiBkcm0gZHJp dmVyOgorICoKKyAqICAgdGlsY2RjIGRhOHh4X2xjZGMuMDogdGlsY2RjX2NydGNfaXJxKDB4MDAw MDAwMjApOiBGSUZPIHVuZGVyZm93CisgKi8KK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZGE4eHhfbXN0 cHJpX3ByaW9yaXR5IGRhODUwX2xjZGtfcHJpb3JpdGllc1tdID0geworCXsKKwkJLndoaWNoID0g REE4WFhfTVNUUFJJX0xDREMsCisJCS52YWwgPSAwLAorCX0sCisJeworCQkud2hpY2ggPSBEQThY WF9NU1RQUklfRURNQTMwVEMxLAorCQkudmFsID0gMCwKKwl9LAorCXsKKwkJLndoaWNoID0gREE4 WFhfTVNUUFJJX0VETUEzMFRDMCwKKwkJLnZhbCA9IDEsCisJfSwKK307CisKK3N0YXRpYyBjb25z dCBzdHJ1Y3QgZGE4eHhfbXN0cHJpX2JvYXJkX3ByaW9yaXRpZXMgZGE4eHhfbXN0cHJpX2JvYXJk X2NvbmZzW10gPSB7CisJeworCQkuYm9hcmQgPSAidGksZGE4NTAtbGNkayIsCisJCS5wcmlvcml0 aWVzID0gZGE4NTBfbGNka19wcmlvcml0aWVzLAorCQkubnVtcHJpbyA9IEFSUkFZX1NJWkUoZGE4 NTBfbGNka19wcmlvcml0aWVzKSwKKwl9LAorfTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBkYTh4 eF9tc3RwcmlfYm9hcmRfcHJpb3JpdGllcyAqCitkYTh4eF9tc3RwcmlfZ2V0X2JvYXJkX3ByaW8o dm9pZCkKK3sKKwljb25zdCBzdHJ1Y3QgZGE4eHhfbXN0cHJpX2JvYXJkX3ByaW9yaXRpZXMgKmJv YXJkX3ByaW87CisJaW50IGk7CisKKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShkYTh4eF9t c3RwcmlfYm9hcmRfY29uZnMpOyBpKyspIHsKKwkJYm9hcmRfcHJpbyA9ICZkYTh4eF9tc3Rwcmlf Ym9hcmRfY29uZnNbaV07CisKKwkJaWYgKG9mX21hY2hpbmVfaXNfY29tcGF0aWJsZShib2FyZF9w cmlvLT5ib2FyZCkpCisJCQlyZXR1cm4gYm9hcmRfcHJpbzsKKwl9CisKKwlyZXR1cm4gTlVMTDsK K30KKworc3RhdGljIGludCBkYTh4eF9tc3RwcmlfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2Rldmlj ZSAqcGRldikKK3sKKwljb25zdCBzdHJ1Y3QgZGE4eHhfbXN0cHJpX2JvYXJkX3ByaW9yaXRpZXMg KnByaW9fbGlzdDsKKwljb25zdCBzdHJ1Y3QgZGE4eHhfbXN0cHJpX2Rlc2NyICpwcmlvX2Rlc2Ny OworCWNvbnN0IHN0cnVjdCBkYTh4eF9tc3RwcmlfcHJpb3JpdHkgKnByaW87CisJc3RydWN0IGRl dmljZSAqZGV2ID0gJnBkZXYtPmRldjsKKwlzdHJ1Y3QgcmVzb3VyY2UgKnJlczsKKwl2b2lkIF9f aW9tZW0gKm1zdHByaTsKKwl1MzIgcmVnOworCWludCBpOworCisJcmVzID0gcGxhdGZvcm1fZ2V0 X3Jlc291cmNlKHBkZXYsIElPUkVTT1VSQ0VfTUVNLCAwKTsKKwltc3RwcmkgPSBkZXZtX2lvcmVt YXBfcmVzb3VyY2UoZGV2LCByZXMpOworCWlmIChJU19FUlIobXN0cHJpKSkgeworCQlkZXZfZXJy KGRldiwgInVuYWJsZSB0byBtYXAgTVNUUFJJIHJlZ2lzdGVyc1xuIik7CisJCXJldHVybiBQVFJf RVJSKG1zdHByaSk7CisJfQorCisJcHJpb19saXN0ID0gZGE4eHhfbXN0cHJpX2dldF9ib2FyZF9w cmlvKCk7CisJaWYgKCFwcmlvX2xpc3QpIHsKKwkJZGV2X2VycihkZXYsICJubyBtYXN0ZXIgcHJp b3RpdGllcyBkZWZpbmVkIGZvciBib2FyZCAnJXMnXG4iLAorCQkJb2ZfZmxhdF9kdF9nZXRfbWFj aGluZV9uYW1lKCkpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwlmb3IgKGkgPSAwOyBpIDwg cHJpb19saXN0LT5udW1wcmlvOyBpKyspIHsKKwkJcHJpbyA9ICZwcmlvX2xpc3QtPnByaW9yaXRp ZXNbaV07CisJCXByaW9fZGVzY3IgPSAmZGE4eHhfbXN0cHJpX3ByaW9yaXR5X2xpc3RbcHJpby0+ d2hpY2hdOworCisJCWlmIChwcmlvX2Rlc2NyLT5yZWcgKyBzaXplb2YodTMyKSA+IHJlc291cmNl X3NpemUocmVzKSkgeworCQkJZGV2X3dhcm4oZGV2LCAicmVnaXN0ZXIgb2Zmc2V0IG91dCBvZiBy YW5nZVxuIik7CisJCQljb250aW51ZTsKKwkJfQorCisJCXJlZyA9IHJlYWRsKG1zdHByaSArIHBy aW9fZGVzY3ItPnJlZyk7CisJCXJlZyAmPSB+cHJpb19kZXNjci0+bWFzazsKKwkJcmVnIHw9IHBy aW8tPnZhbCA8PCBwcmlvX2Rlc2NyLT5zaGlmdDsKKworCQl3cml0ZWwocmVnLCBtc3RwcmkgKyBw cmlvX2Rlc2NyLT5yZWcpOworCX0KKworCXJldHVybiAwOworfQorCitzdGF0aWMgY29uc3Qgc3Ry dWN0IG9mX2RldmljZV9pZCBkYTh4eF9tc3Rwcmlfb2ZfbWF0Y2hbXSA9IHsKKwl7IC5jb21wYXRp YmxlID0gInRpLGRhODUwLW1zdHByaSIsIH0sCisJeyB9LAorfTsKKworc3RhdGljIHN0cnVjdCBw bGF0Zm9ybV9kcml2ZXIgZGE4eHhfbXN0cHJpX2RyaXZlciA9IHsKKwkucHJvYmUgPSBkYTh4eF9t c3RwcmlfcHJvYmUsCisJLmRyaXZlciA9IHsKKwkJLm5hbWUgPSAiZGE4eHgtbXN0cHJpIiwKKwkJ Lm9mX21hdGNoX3RhYmxlID0gZGE4eHhfbXN0cHJpX29mX21hdGNoLAorCX0sCit9OworbW9kdWxl X3BsYXRmb3JtX2RyaXZlcihkYTh4eF9tc3RwcmlfZHJpdmVyKTsKKworTU9EVUxFX0FVVEhPUigi QmFydG9zeiBHb2xhc3pld3NraSA8YmdvbGFzemV3c2tpQGJheWxpYnJlLmNvbT4iKTsKK01PRFVM RV9ERVNDUklQVElPTigiVEkgZGE4eHggbWFzdGVyIHBlcmlwaGVyYWwgcHJpb3JpdHkgZHJpdmVy Iik7CitNT0RVTEVfTElDRU5TRSgiR1BMIHYyIik7Ci0tIAoyLjkuMwoKX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApk cmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Au b3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S965039AbcJaOrP (ORCPT ); Mon, 31 Oct 2016 10:47:15 -0400 Received: from mail-wm0-f50.google.com ([74.125.82.50]:36315 "EHLO mail-wm0-f50.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S964955AbcJaOrI (ORCPT ); Mon, 31 Oct 2016 10:47:08 -0400 From: Bartosz Golaszewski To: Kevin Hilman , Michael Turquette , Sekhar Nori , Rob Herring , Frank Rowand , Mark Rutland , Peter Ujfalusi , Russell King Cc: LKML , arm-soc , linux-drm , linux-devicetree , Jyri Sarha , Tomi Valkeinen , David Airlie , Laurent Pinchart , Bartosz Golaszewski Subject: [PATCH v2 2/5] ARM: bus: da8xx-mstpri: new driver Date: Mon, 31 Oct 2016 15:45:35 +0100 Message-Id: <1477925138-23457-3-git-send-email-bgolaszewski@baylibre.com> X-Mailer: git-send-email 2.1.4 In-Reply-To: <1477925138-23457-1-git-send-email-bgolaszewski@baylibre.com> References: <1477925138-23457-1-git-send-email-bgolaszewski@baylibre.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Create the driver for the da8xx master peripheral priority configuration and implement support for writing to the three Master Priority registers on da850 SoCs. Signed-off-by: Bartosz Golaszewski --- .../devicetree/bindings/bus/ti,da850-mstpri.txt | 20 ++ drivers/bus/Kconfig | 9 + drivers/bus/Makefile | 2 + drivers/bus/da8xx-mstpri.c | 269 +++++++++++++++++++++ 4 files changed, 300 insertions(+) create mode 100644 Documentation/devicetree/bindings/bus/ti,da850-mstpri.txt create mode 100644 drivers/bus/da8xx-mstpri.c diff --git a/Documentation/devicetree/bindings/bus/ti,da850-mstpri.txt b/Documentation/devicetree/bindings/bus/ti,da850-mstpri.txt new file mode 100644 index 0000000..72daefc --- /dev/null +++ b/Documentation/devicetree/bindings/bus/ti,da850-mstpri.txt @@ -0,0 +1,20 @@ +* Device tree bindings for Texas Instruments da8xx master peripheral + priority driver + +DA8XX SoCs feature a set of registers allowing to change the priority of all +peripherals classified as masters. + +Documentation: +OMAP-L138 (DA850) - http://www.ti.com/lit/ug/spruh82c/spruh82c.pdf + +Required properties: + +- compatible: "ti,da850-mstpri" - for da850 based boards +- reg: offset and length of the mstpri registers + +Example for da850-lcdk is shown below. + +mstpri { + compatible = "ti,da850-mstpri"; + reg = <0x14110 0x0c>; +}; diff --git a/drivers/bus/Kconfig b/drivers/bus/Kconfig index 7875105..f5db3a7 100644 --- a/drivers/bus/Kconfig +++ b/drivers/bus/Kconfig @@ -167,4 +167,13 @@ config VEXPRESS_CONFIG help Platform configuration infrastructure for the ARM Ltd. Versatile Express. + +config DA8XX_MSTPRI + bool "TI da8xx master peripheral priority driver" + depends on ARCH_DAVINCI_DA8XX + help + Driver for Texas Instruments da8xx master peripheral priority + configuration. Allows to adjust the priorities of all master + peripherals. + endmenu diff --git a/drivers/bus/Makefile b/drivers/bus/Makefile index c6cfa6b..2adb540 100644 --- a/drivers/bus/Makefile +++ b/drivers/bus/Makefile @@ -21,3 +21,5 @@ obj-$(CONFIG_SIMPLE_PM_BUS) += simple-pm-bus.o obj-$(CONFIG_TEGRA_ACONNECT) += tegra-aconnect.o obj-$(CONFIG_UNIPHIER_SYSTEM_BUS) += uniphier-system-bus.o obj-$(CONFIG_VEXPRESS_CONFIG) += vexpress-config.o + +obj-$(CONFIG_DA8XX_MSTPRI) += da8xx-mstpri.o diff --git a/drivers/bus/da8xx-mstpri.c b/drivers/bus/da8xx-mstpri.c new file mode 100644 index 0000000..85f0b53 --- /dev/null +++ b/drivers/bus/da8xx-mstpri.c @@ -0,0 +1,269 @@ +/* + * TI da8xx master peripheral priority driver + * + * Copyright (C) 2016 BayLibre SAS + * + * Author: + * Bartosz Golaszewski + * + * 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 +#include +#include +#include +#include +#include + +/* + * REVISIT: Linux doesn't have a good framework for the kind of performance + * knobs this driver controls. We can't use device tree properties as it deals + * with hardware configuration rather than description. We also don't want to + * commit to maintaining some random sysfs attributes. + * + * For now we just hardcode the register values for the boards that need + * some changes (as is the case for the LCD controller on da850-lcdk - the + * first board we support here). When linux gets an appropriate framework, + * we'll easily convert the driver to it. + */ + +#define DA8XX_MSTPRI0_OFFSET 0 +#define DA8XX_MSTPRI1_OFFSET 4 +#define DA8XX_MSTPRI2_OFFSET 8 + +enum { + DA8XX_MSTPRI_ARM_I = 0, + DA8XX_MSTPRI_ARM_D, + DA8XX_MSTPRI_UPP, + DA8XX_MSTPRI_SATA, + DA8XX_MSTPRI_PRU0, + DA8XX_MSTPRI_PRU1, + DA8XX_MSTPRI_EDMA30TC0, + DA8XX_MSTPRI_EDMA30TC1, + DA8XX_MSTPRI_EDMA31TC0, + DA8XX_MSTPRI_VPIF_DMA_0, + DA8XX_MSTPRI_VPIF_DMA_1, + DA8XX_MSTPRI_EMAC, + DA8XX_MSTPRI_USB0CFG, + DA8XX_MSTPRI_USB0CDMA, + DA8XX_MSTPRI_UHPI, + DA8XX_MSTPRI_USB1, + DA8XX_MSTPRI_LCDC, +}; + +struct da8xx_mstpri_descr { + int reg; + int shift; + int mask; +}; + +static const struct da8xx_mstpri_descr da8xx_mstpri_priority_list[] = { + [DA8XX_MSTPRI_ARM_I] = { + .reg = DA8XX_MSTPRI0_OFFSET, + .shift = 0, + .mask = 0x0000000f, + }, + [DA8XX_MSTPRI_ARM_D] = { + .reg = DA8XX_MSTPRI0_OFFSET, + .shift = 4, + .mask = 0x000000f0, + }, + [DA8XX_MSTPRI_UPP] = { + .reg = DA8XX_MSTPRI0_OFFSET, + .shift = 16, + .mask = 0x000f0000, + }, + [DA8XX_MSTPRI_SATA] = { + .reg = DA8XX_MSTPRI0_OFFSET, + .shift = 20, + .mask = 0x00f00000, + }, + [DA8XX_MSTPRI_PRU0] = { + .reg = DA8XX_MSTPRI1_OFFSET, + .shift = 0, + .mask = 0x0000000f, + }, + [DA8XX_MSTPRI_PRU1] = { + .reg = DA8XX_MSTPRI1_OFFSET, + .shift = 4, + .mask = 0x000000f0, + }, + [DA8XX_MSTPRI_EDMA30TC0] = { + .reg = DA8XX_MSTPRI1_OFFSET, + .shift = 8, + .mask = 0x00000f00, + }, + [DA8XX_MSTPRI_EDMA30TC1] = { + .reg = DA8XX_MSTPRI1_OFFSET, + .shift = 12, + .mask = 0x0000f000, + }, + [DA8XX_MSTPRI_EDMA31TC0] = { + .reg = DA8XX_MSTPRI1_OFFSET, + .shift = 16, + .mask = 0x000f0000, + }, + [DA8XX_MSTPRI_VPIF_DMA_0] = { + .reg = DA8XX_MSTPRI1_OFFSET, + .shift = 24, + .mask = 0x0f000000, + }, + [DA8XX_MSTPRI_VPIF_DMA_1] = { + .reg = DA8XX_MSTPRI1_OFFSET, + .shift = 28, + .mask = 0xf0000000, + }, + [DA8XX_MSTPRI_EMAC] = { + .reg = DA8XX_MSTPRI2_OFFSET, + .shift = 0, + .mask = 0x0000000f, + }, + [DA8XX_MSTPRI_USB0CFG] = { + .reg = DA8XX_MSTPRI2_OFFSET, + .shift = 8, + .mask = 0x00000f00, + }, + [DA8XX_MSTPRI_USB0CDMA] = { + .reg = DA8XX_MSTPRI2_OFFSET, + .shift = 12, + .mask = 0x0000f000, + }, + [DA8XX_MSTPRI_UHPI] = { + .reg = DA8XX_MSTPRI2_OFFSET, + .shift = 20, + .mask = 0x00f00000, + }, + [DA8XX_MSTPRI_USB1] = { + .reg = DA8XX_MSTPRI2_OFFSET, + .shift = 24, + .mask = 0x0f000000, + }, + [DA8XX_MSTPRI_LCDC] = { + .reg = DA8XX_MSTPRI2_OFFSET, + .shift = 28, + .mask = 0xf0000000, + }, +}; + +struct da8xx_mstpri_priority { + int which; + u32 val; +}; + +struct da8xx_mstpri_board_priorities { + const char *board; + const struct da8xx_mstpri_priority *priorities; + size_t numprio; +}; + +/* + * Default memory settings of da850 do not meet the throughput/latency + * requirements of tilcdc. This results in the image displayed being + * incorrect and the following warning being displayed by the LCDC + * drm driver: + * + * tilcdc da8xx_lcdc.0: tilcdc_crtc_irq(0x00000020): FIFO underfow + */ +static const struct da8xx_mstpri_priority da850_lcdk_priorities[] = { + { + .which = DA8XX_MSTPRI_LCDC, + .val = 0, + }, + { + .which = DA8XX_MSTPRI_EDMA30TC1, + .val = 0, + }, + { + .which = DA8XX_MSTPRI_EDMA30TC0, + .val = 1, + }, +}; + +static const struct da8xx_mstpri_board_priorities da8xx_mstpri_board_confs[] = { + { + .board = "ti,da850-lcdk", + .priorities = da850_lcdk_priorities, + .numprio = ARRAY_SIZE(da850_lcdk_priorities), + }, +}; + +static const struct da8xx_mstpri_board_priorities * +da8xx_mstpri_get_board_prio(void) +{ + const struct da8xx_mstpri_board_priorities *board_prio; + int i; + + for (i = 0; i < ARRAY_SIZE(da8xx_mstpri_board_confs); i++) { + board_prio = &da8xx_mstpri_board_confs[i]; + + if (of_machine_is_compatible(board_prio->board)) + return board_prio; + } + + return NULL; +} + +static int da8xx_mstpri_probe(struct platform_device *pdev) +{ + const struct da8xx_mstpri_board_priorities *prio_list; + const struct da8xx_mstpri_descr *prio_descr; + const struct da8xx_mstpri_priority *prio; + struct device *dev = &pdev->dev; + struct resource *res; + void __iomem *mstpri; + u32 reg; + int i; + + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + mstpri = devm_ioremap_resource(dev, res); + if (IS_ERR(mstpri)) { + dev_err(dev, "unable to map MSTPRI registers\n"); + return PTR_ERR(mstpri); + } + + prio_list = da8xx_mstpri_get_board_prio(); + if (!prio_list) { + dev_err(dev, "no master priotities defined for board '%s'\n", + of_flat_dt_get_machine_name()); + return -EINVAL; + } + + for (i = 0; i < prio_list->numprio; i++) { + prio = &prio_list->priorities[i]; + prio_descr = &da8xx_mstpri_priority_list[prio->which]; + + if (prio_descr->reg + sizeof(u32) > resource_size(res)) { + dev_warn(dev, "register offset out of range\n"); + continue; + } + + reg = readl(mstpri + prio_descr->reg); + reg &= ~prio_descr->mask; + reg |= prio->val << prio_descr->shift; + + writel(reg, mstpri + prio_descr->reg); + } + + return 0; +} + +static const struct of_device_id da8xx_mstpri_of_match[] = { + { .compatible = "ti,da850-mstpri", }, + { }, +}; + +static struct platform_driver da8xx_mstpri_driver = { + .probe = da8xx_mstpri_probe, + .driver = { + .name = "da8xx-mstpri", + .of_match_table = da8xx_mstpri_of_match, + }, +}; +module_platform_driver(da8xx_mstpri_driver); + +MODULE_AUTHOR("Bartosz Golaszewski "); +MODULE_DESCRIPTION("TI da8xx master peripheral priority driver"); +MODULE_LICENSE("GPL v2"); -- 2.9.3