From patchwork Mon Apr 27 23:55:46 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Dmitry Baryshkov X-Patchwork-Id: 6284481 Return-Path: X-Original-To: patchwork-linux-spi@patchwork.kernel.org Delivered-To: patchwork-parsemail@patchwork2.web.kernel.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.136]) by patchwork2.web.kernel.org (Postfix) with ESMTP id 693EFBEEE1 for ; Mon, 27 Apr 2015 23:57:30 +0000 (UTC) Received: from mail.kernel.org (localhost [127.0.0.1]) by mail.kernel.org (Postfix) with ESMTP id 24CA3202FE for ; Mon, 27 Apr 2015 23:57:29 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 3B25520379 for ; Mon, 27 Apr 2015 23:57:27 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S932180AbbD0X5Z (ORCPT ); Mon, 27 Apr 2015 19:57:25 -0400 Received: from mail-pa0-f46.google.com ([209.85.220.46]:36060 "EHLO mail-pa0-f46.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S932281AbbD0X5W (ORCPT ); Mon, 27 Apr 2015 19:57:22 -0400 Received: by pabsx10 with SMTP id sx10so145562785pab.3; Mon, 27 Apr 2015 16:57:21 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=wWG/ivyZvS4cxWzAY6bWiC7RRfpdlEeBXNlkBTrxCvU=; b=xI1DpFwpCyJEL92o5DdjfP/FO82xckb6RbIszrU+bsr6JS2c1k0rP+uQF2w9paXjWE caHvlADSJ8ZXhsMHwzdCZMbtvhrfbnqpK82+t9KgMK7h3IraCEs/0NNB0yQQgDZruXAF rUIMjHf+PMB36/ksJAL5WWp6Se9+1tzZIaYciBH+CyIoy0wLpurnDUvVaWW9onGnavxP CvGRczcK4C1MDImY2YdPpqaDGX9WJ5PLNRmL52oStxFAg/wsIj2jE+FlhI6lkb1qezyK BPKkJeZ//W/rQ0Xn44a9E9F6m+BFVxwEc8H9y8B25MDIATilsOqxy4fDsJnR4uOTelB6 jPWQ== X-Received: by 10.68.135.4 with SMTP id po4mr27033779pbb.12.1430179040939; Mon, 27 Apr 2015 16:57:20 -0700 (PDT) Received: from fangorn.rup.mentorg.com (nat-min.mentorg.com. [139.181.32.34]) by mx.google.com with ESMTPSA id pv2sm20428375pbb.12.2015.04.27.16.57.14 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Mon, 27 Apr 2015 16:57:20 -0700 (PDT) From: Dmitry Eremin-Solenikov To: Russell King , Daniel Mack , Robert Jarzmik , Linus Walleij , Alexandre Courbot , Wolfram Sang , Dmitry Torokhov , Bryan Wu , Richard Purdie , Samuel Ortiz , Lee Jones , Mark Brown , Jingoo Han , Jean-Christophe Plagniol-Villard , Tomi Valkeinen , Liam Girdwood , Andrea Adami Cc: linux-arm-kernel@lists.infradead.org, linux-gpio@vger.kernel.org, linux-i2c@vger.kernel.org, linux-input@vger.kernel.org, linux-leds@vger.kernel.org, linux-spi@vger.kernel.org, linux-fbdev@vger.kernel.org, alsa-devel@alsa-project.org Subject: [PATCH v2 09/17] spi: add locomo SPI driver Date: Tue, 28 Apr 2015 02:55:46 +0300 Message-Id: <1430178954-11138-10-git-send-email-dbaryshkov@gmail.com> X-Mailer: git-send-email 2.1.4 In-Reply-To: <1430178954-11138-1-git-send-email-dbaryshkov@gmail.com> References: <1430178954-11138-1-git-send-email-dbaryshkov@gmail.com> Sender: linux-spi-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-spi@vger.kernel.org X-Spam-Status: No, score=-6.8 required=5.0 tests=BAYES_00, DKIM_ADSP_CUSTOM_MED, DKIM_SIGNED, FREEMAIL_FROM, RCVD_IN_DNSWL_HI, T_DKIM_INVALID, T_RP_MATCHES_RCVD, UNPARSEABLE_RELAY autolearn=unavailable version=3.3.1 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on mail.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP LoCoMo chip has a built-in simple SPI controller. On Sharp SL-5500 PDDAs it is connected to external MMC slot. Signed-off-by: Dmitry Eremin-Solenikov --- drivers/spi/Kconfig | 10 ++ drivers/spi/Makefile | 1 + drivers/spi/spi-locomo.c | 363 +++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 374 insertions(+) create mode 100644 drivers/spi/spi-locomo.c diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig index 198f96b..c9e3176 100644 --- a/drivers/spi/Kconfig +++ b/drivers/spi/Kconfig @@ -258,6 +258,16 @@ config SPI_LM70_LLP which interfaces to an LM70 temperature sensor using a parallel port. +config SPI_LOCOMO + tristate "Locomo SPI master" + depends on MFD_LOCOMO + help + This enables using the SPI controller as present in the LoCoMo + chips. It is probably only useful on the Sharp SL-5x00 PDA family. + + On SL-5500 and SL-5000 devices this controller is used for + MMC/SD cards. + config SPI_MPC52xx tristate "Freescale MPC52xx SPI (non-PSC) controller support" depends on PPC_MPC52xx diff --git a/drivers/spi/Makefile b/drivers/spi/Makefile index d8cbf65..623c463 100644 --- a/drivers/spi/Makefile +++ b/drivers/spi/Makefile @@ -44,6 +44,7 @@ obj-$(CONFIG_SPI_GPIO) += spi-gpio.o obj-$(CONFIG_SPI_IMG_SPFI) += spi-img-spfi.o obj-$(CONFIG_SPI_IMX) += spi-imx.o obj-$(CONFIG_SPI_LM70_LLP) += spi-lm70llp.o +obj-$(CONFIG_SPI_LOCOMO) += spi-locomo.o obj-$(CONFIG_SPI_MESON_SPIFC) += spi-meson-spifc.o obj-$(CONFIG_SPI_MPC512x_PSC) += spi-mpc512x-psc.o obj-$(CONFIG_SPI_MPC52xx_PSC) += spi-mpc52xx-psc.o diff --git a/drivers/spi/spi-locomo.c b/drivers/spi/spi-locomo.c new file mode 100644 index 0000000..71b36fd --- /dev/null +++ b/drivers/spi/spi-locomo.c @@ -0,0 +1,363 @@ +/* + * 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; version 2 of the License. + * + * 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 +#include +#include + +struct locomospi_dev { + struct regmap *regmap; + + int clock_base; + int clock_div; + unsigned nsecs; + + unsigned int save_ct; + unsigned int save_md; +}; + +static int locomospi_reg_open(struct locomospi_dev *spidev) +{ + regmap_write(spidev->regmap, LOCOMO_SPIMD, + LOCOMO_SPIMD_MSB1ST | LOCOMO_SPIMD_DOSTAT | + LOCOMO_SPIMD_RCPOL | LOCOMO_SPIMD_TCPOL | + (spidev->clock_base << 3) | spidev->clock_div); + + regmap_update_bits(spidev->regmap, LOCOMO_SPIMD, + LOCOMO_SPIMD_XON, + LOCOMO_SPIMD_XON); + regmap_update_bits(spidev->regmap, LOCOMO_SPIMD, + LOCOMO_SPIMD_XEN, + LOCOMO_SPIMD_XEN); + + regmap_write(spidev->regmap, LOCOMO_SPICT, LOCOMO_SPICT_CS); + regmap_update_bits(spidev->regmap, LOCOMO_SPICT, + LOCOMO_SPICT_CEN | LOCOMO_SPICT_RXUEN | + LOCOMO_SPICT_ALIGNEN, + LOCOMO_SPICT_CEN | LOCOMO_SPICT_RXUEN | + LOCOMO_SPICT_ALIGNEN); + + usleep_range(200, 300); + + regmap_update_bits(spidev->regmap, LOCOMO_SPICT, LOCOMO_SPICT_CS, 0); + + return 0; +} + +static int locomospi_reg_release(struct locomospi_dev *spidev) +{ + regmap_update_bits(spidev->regmap, LOCOMO_SPICT, LOCOMO_SPICT_CEN, 0); + regmap_update_bits(spidev->regmap, LOCOMO_SPIMD, LOCOMO_SPIMD_XEN, 0); + regmap_update_bits(spidev->regmap, LOCOMO_SPIMD, LOCOMO_SPIMD_XON, 0); + regmap_update_bits(spidev->regmap, LOCOMO_SPICT, + LOCOMO_SPIMD_XEN, + LOCOMO_SPIMD_XEN); + + return 0; +} + + +static void locomospi_chipselect(struct spi_device *spi, bool enable) +{ + struct locomospi_dev *spidev; + + dev_dbg(&spi->dev, "SPI cs: %s\n", enable ? "enable" : "disable"); + + spidev = spi_master_get_devdata(spi->master); + + regmap_update_bits(spidev->regmap, LOCOMO_SPICT, LOCOMO_SPICT_CS, + enable ? LOCOMO_SPICT_CS : 0); +} + +static u32 locomospi_txrx_word(struct spi_device *spi, + unsigned nsecs, + u32 word) +{ + struct locomospi_dev *spidev; + int wait; + int j; + unsigned int rx; + unsigned int r; + + spidev = spi_master_get_devdata(spi->master); + + if (spidev->clock_div == DIV_64) + wait = 0x10000; + else + wait = 8; + + for (j = 0; j < wait; j++) { + regmap_read(spidev->regmap, LOCOMO_SPIST, &r); + if (r & LOCOMO_SPI_RFW) + break; + } + if (j == wait) + dev_err(&spi->dev, "rfw timeout\n"); + + regmap_write(spidev->regmap, LOCOMO_SPITD, word); + ndelay(nsecs); + + for (j = 0; j < wait; j++) { + regmap_read(spidev->regmap, LOCOMO_SPIST, &r); + if (r & LOCOMO_SPI_RFR) + break; + } + if (j == wait) + dev_err(&spi->dev, "rfr timeout\n"); + + regmap_read(spidev->regmap, LOCOMO_SPIRD, &rx); + ndelay(nsecs); + + dev_dbg(&spi->dev, "SPI txrx: %02x/%02x\n", word, rx); + + return rx; +} + +static void locomo_spi_set_speed(struct locomospi_dev *spidev, u32 hz) +{ + spidev->nsecs = (1000000000/2) / hz; + + if (hz >= 24576000) { + spidev->clock_base = CLOCK_25MHZ; + spidev->clock_div = DIV_1; + } else if (hz >= 22579200) { + spidev->clock_base = CLOCK_22MHZ; + spidev->clock_div = DIV_1; + } else if (hz >= 18432000) { + spidev->clock_base = CLOCK_18MHZ; + spidev->clock_div = DIV_1; + } else if (hz >= 12288000) { + spidev->clock_base = CLOCK_25MHZ; + spidev->clock_div = DIV_2; + } else if (hz >= 11289600) { + spidev->clock_base = CLOCK_22MHZ; + spidev->clock_div = DIV_2; + } else if (hz >= 9216000) { + spidev->clock_base = CLOCK_18MHZ; + spidev->clock_div = DIV_2; + } else if (hz >= 6144000) { + spidev->clock_base = CLOCK_25MHZ; + spidev->clock_div = DIV_4; + } else if (hz >= 5644800) { + spidev->clock_base = CLOCK_22MHZ; + spidev->clock_div = DIV_4; + } else if (hz >= 4608000) { + spidev->clock_base = CLOCK_18MHZ; + spidev->clock_div = DIV_4; + } else if (hz >= 3072000) { + spidev->clock_base = CLOCK_25MHZ; + spidev->clock_div = DIV_8; + } else if (hz >= 2822400) { + spidev->clock_base = CLOCK_22MHZ; + spidev->clock_div = DIV_8; + } else if (hz >= 2304000) { + spidev->clock_base = CLOCK_18MHZ; + spidev->clock_div = DIV_8; + } else if (hz >= 384000) { + spidev->clock_base = CLOCK_25MHZ; + spidev->clock_div = DIV_64; + } else if (hz >= 352800) { + spidev->clock_base = CLOCK_22MHZ; + spidev->clock_div = DIV_64; + } else { /* set to 288 Khz */ + spidev->clock_base = CLOCK_18MHZ; + spidev->clock_div = DIV_64; + } + + regmap_update_bits(spidev->regmap, LOCOMO_SPIMD, + LOCOMO_SPIMD_XSEL | LOCOMO_SPIMD_CLKSEL | + LOCOMO_SPIMD_XEN, + 0); + regmap_update_bits(spidev->regmap, LOCOMO_SPIMD, + LOCOMO_SPIMD_XSEL | LOCOMO_SPIMD_CLKSEL | + LOCOMO_SPIMD_XEN, + spidev->clock_div | (spidev->clock_base << 3) | + LOCOMO_SPIMD_XEN); + + usleep_range(300, 400); +} + +static int locomo_spi_setup_transfer(struct spi_device *spi, + struct spi_transfer *t) +{ + struct locomospi_dev *spidev; + u32 hz = 0; + + if (t) + hz = t->speed_hz; + if (!hz) + hz = spi->max_speed_hz; + + spidev = spi_master_get_devdata(spi->master); + + regmap_update_bits(spidev->regmap, LOCOMO_SPIMD, + LOCOMO_SPIMD_XON, + hz ? LOCOMO_SPIMD_XON : 0); + + if (hz != 0) + locomo_spi_set_speed(spidev, hz); + + return 0; +} + +static int locomospi_transfer_one(struct spi_master *master, + struct spi_device *spi, + struct spi_transfer *t) +{ + struct locomospi_dev *spidev = spi_master_get_devdata(spi->master); + int rc; + unsigned count; + const u8 *tx = t->tx_buf; + u8 *rx = t->rx_buf; + + if (!tx && !rx && t->len) + return -EINVAL; + + rc = locomo_spi_setup_transfer(spi, t); + if (rc < 0) + return rc; + + if (!t->len) + return 0; + + for (count = t->len; likely(count > 0); count--) { + u8 word = 0; + + if (tx) + word = *tx++; + word = locomospi_txrx_word(spi, spidev->nsecs, word); + + if (rx) + *rx++ = word; + } + + return 0; +} + +#ifdef CONFIG_PM_SLEEP +static int locomo_spi_suspend(struct device *dev) +{ + struct spi_master *master = dev_get_drvdata(dev); + struct locomospi_dev *spidev = spi_master_get_devdata(master); + int ret; + + /* Stop the queue running */ + ret = spi_master_suspend(master); + if (ret) { + dev_warn(dev, "cannot suspend master\n"); + return ret; + } + + regmap_read(spidev->regmap, LOCOMO_SPICT, &spidev->save_ct); + regmap_write(spidev->regmap, LOCOMO_SPICT, LOCOMO_SPICT_CS); + regmap_read(spidev->regmap, LOCOMO_SPIMD, &spidev->save_ct); + regmap_write(spidev->regmap, LOCOMO_SPIMD, 0x3c14); + + + return 0; +} + +static int locomo_spi_resume(struct device *dev) +{ + struct spi_master *master = dev_get_drvdata(dev); + struct locomospi_dev *spidev = spi_master_get_devdata(master); + int ret; + + regmap_write(spidev->regmap, LOCOMO_SPICT, spidev->save_ct); + regmap_write(spidev->regmap, LOCOMO_SPIMD, spidev->save_md); + + /* Start the queue running */ + ret = spi_master_resume(master); + if (ret) + dev_err(dev, "problem starting queue (%d)\n", ret); + + return ret; +} + +static SIMPLE_DEV_PM_OPS(locomo_spi_pm_ops, + locomo_spi_suspend, locomo_spi_resume); + +#define LOCOMO_SPI_PM_OPS (&locomo_spi_pm_ops) +#else +#define LOCOMO_SPI_PM_OPS NULL +#endif + +static int locomo_spi_probe(struct platform_device *pdev) +{ + struct spi_master *master; + struct locomospi_dev *spidev; + int ret = -ENODEV; + + master = spi_alloc_master(&pdev->dev, sizeof(struct locomospi_dev)); + if (!master) + return -ENOMEM; + + master->bus_num = 0; + master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH; + master->bits_per_word_mask = SPI_BPW_RANGE_MASK(8, 8); + master->max_speed_hz = 24576000; + master->num_chipselect = 1; + master->set_cs = locomospi_chipselect; + master->transfer_one = locomospi_transfer_one; + + spidev = spi_master_get_devdata(master); + + spidev->regmap = dev_get_regmap(pdev->dev.parent, NULL); + if (!spidev->regmap) + goto out_put; + + spidev->clock_div = DIV_64; + spidev->clock_base = CLOCK_18MHZ; + + platform_set_drvdata(pdev, master); + + ret = locomospi_reg_open(spidev); + if (ret < 0) + goto out_put; + + ret = devm_spi_register_master(&pdev->dev, master); + if (ret) { + dev_err(&pdev->dev, "bitbang start failed with %d\n", ret); + goto out_put; + } + + return 0; + +out_put: + spi_master_put(master); + return ret; +} + +static int locomo_spi_remove(struct platform_device *pdev) +{ + struct spi_master *master = platform_get_drvdata(pdev); + struct locomospi_dev *spidev = spi_master_get_devdata(master); + + return locomospi_reg_release(spidev); +} + +static struct platform_driver locomo_spi_driver = { + .probe = locomo_spi_probe, + .remove = locomo_spi_remove, + .driver = { + .name = "locomo-spi", + .pm = LOCOMO_SPI_PM_OPS, + }, +}; +module_platform_driver(locomo_spi_driver); + +MODULE_AUTHOR("Thomas Kunze thommy@tabao.de"); +MODULE_DESCRIPTION("LoCoMo SPI driver"); +MODULE_LICENSE("GPL"); +MODULE_ALIAS("platform:locomo-spi");