drivers/pwm/pwm-litex.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2019 Antmicro <www.antmicro.com>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2
   7  * as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #include <linux/clk.h>
  20 #include <linux/err.h>
  21 #include <linux/io.h>
  22 #include <linux/kernel.h>
  23 #include <linux/module.h>
  24 #include <linux/of.h>
  25 #include <linux/of_address.h>
  26 #include <linux/platform_device.h>
  27 #include <linux/pwm.h>
  28 #include <linux/slab.h>
  29 #include <linux/stmp_device.h>
  30 #include <linux/litex.h>
  31
  32 #define REG_EN_ENABLE           0x1
  33 #define REG_EN_DISABLE          0x0
  34
  35 #define ENABLE_REG_OFFSET       0x0
  36 #define WIDTH_REG_OFFSET        0x4
  37 #define PERIOD_REG_OFFSET       0x14
  38
  39 struct litex_pwm_chip {
  40         struct pwm_chip chip;
  41         unsigned int clock;
  42         void __iomem *base;
  43         void __iomem *width;
  44         void __iomem *period;
  45         void __iomem *enable;
  46 };
  47
  48 #define to_litex_pwm_chip(_chip) container_of(_chip, struct litex_pwm_chip, chip)
  49
  50 static int litex_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
  51                           int duty_ns, int period_ns)
  52 {
  53         struct litex_pwm_chip *litex = to_litex_pwm_chip(chip);
  54         unsigned long period_cycles, duty_cycles;
  55         unsigned long long c;
  56
  57         /* Calculate period cycles */
  58         c = (unsigned long long)litex->clock * (unsigned long long)period_ns;
  59         do_div(c, NSEC_PER_SEC);
  60         period_cycles = c;
  61
  62         /* Calculate duty cycles */
  63         c *= duty_ns;
  64         do_div(c, period_ns);
  65         duty_cycles = c;
  66
  67     /* Apply values to registers */
  68         litex_write32(litex->width, duty_cycles);
  69         litex_write32(litex->period, period_cycles);
  70
  71         return 0;
  72 }
  73
  74 static int litex_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)
  75 {
  76         struct litex_pwm_chip *litex = to_litex_pwm_chip(chip);
  77
  78         litex_write8(litex->enable, REG_EN_ENABLE);
  79         return 0;
  80 }
  81
  82 static void litex_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)
  83 {
  84         struct litex_pwm_chip *litex = to_litex_pwm_chip(chip);
  85
  86         litex_write8(litex->enable, REG_EN_DISABLE);
  87 }
  88
  89 static const struct pwm_ops litex_pwm_ops = {
  90         .config = litex_pwm_config,
  91         .enable = litex_pwm_enable,
  92         .disable = litex_pwm_disable,
  93         .owner = THIS_MODULE,
  94 };
  95
  96 static int litex_pwm_probe(struct platform_device *pdev)
  97 {
  98         struct device_node *node = pdev->dev.of_node;
  99         struct litex_pwm_chip *litex;
 100         struct resource *res;
 101         int ret;
 102
 103         if (!node) {
 104                 dev_err(&pdev->dev, "Fail on obtaining device node\n");
 105                 return -ENOMEM;
 106         }
 107
 108         litex = devm_kzalloc(&pdev->dev, sizeof(*litex), GFP_KERNEL);
 109
 110         if (!litex) {
 111                 dev_err(&pdev->dev, "Fail on memory allocation\n");
 112                 return -ENOMEM;
 113         }
 114
 115         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 116         if (!res) {
 117                 dev_err(&pdev->dev, "Device is busy\n");
 118                 return -EBUSY;
 119         }
 120
 121         litex->base = devm_ioremap_resource(&pdev->dev, res);
 122         if (IS_ERR(litex->base)) {
 123                 dev_err(&pdev->dev, "Fail to get base address\n");
 124                 return -EIO;
 125         }
 126
 127         ret = of_property_read_u32(node, "clock", &(litex->clock));
 128         if (ret < 0) {
 129                 dev_err(&pdev->dev, "No clock record in the dts file\n");
 130                 return -ENODEV;
 131         }
 132
 133         litex->width = litex->base + WIDTH_REG_OFFSET;
 134         litex->period = litex->base + PERIOD_REG_OFFSET;
 135         litex->enable = litex->base + ENABLE_REG_OFFSET;
 136
 137         litex->chip.dev = &pdev->dev;
 138         litex->chip.ops = &litex_pwm_ops;
 139         litex->chip.base = -1;
 140         litex->chip.npwm = 1;
 141
 142         ret = pwmchip_add(&litex->chip);
 143         if (ret < 0) {
 144                 dev_err(&pdev->dev, "Failed to add pwm chip %d\n", ret);
 145                 return ret;
 146         }
 147
 148         platform_set_drvdata(pdev, litex);
 149
 150         return 0;
 151 }
 152
 153 static int litex_pwm_remove(struct platform_device *pdev)
 154 {
 155         struct litex_pwm_chip *litex = platform_get_drvdata(pdev);
 156
 157         return pwmchip_remove(&litex->chip);
 158 }
 159
 160 static const struct of_device_id litex_of_match[] = {
 161         { .compatible = "litex,pwm" },
 162         {}
 163 };
 164 MODULE_DEVICE_TABLE(of, litex_of_match);
 165
 166 static struct platform_driver litex_pwm_driver = {
 167         .driver = {
 168                 .name = "litex-pwm",
 169                 .of_match_table   = of_match_ptr(litex_of_match)
 170         },
 171         .probe = litex_pwm_probe,
 172         .remove = litex_pwm_remove,
 173 };
 174 module_platform_driver(litex_pwm_driver);
 175
 176 MODULE_DESCRIPTION("LiteX PWM driver");
 177 MODULE_AUTHOR("Antmicro <www.antmicro.com>");
 178 MODULE_LICENSE("GPL v2");