drivers/reset/reset-rockchip.c

   1 /*
   2  * Copyright (c) 2014 ROCKCHIP, Inc.
   3  * Author: Dai Kelin <dkl@rock-chips.com>
   4  * Based on codes from Heiko Stuebner <heiko@sntech.de>.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  */
  16
  17 #include <linux/slab.h>
  18 #include <linux/io.h>
  19 #include <linux/of.h>
  20 #include <linux/reset-controller.h>
  21 #include <linux/spinlock.h>
  22 #include <linux/of_address.h>
  23 #include <linux/platform_device.h>
  24 #include <linux/module.h>
  25
  26 #include <dt-bindings/clock/rockchip.h>
  27
  28
  29 struct rockchip_reset {
  30         struct reset_controller_dev     rcdev;
  31         void __iomem                    *reg_base;
  32         int                             num_regs;
  33         int                             num_per_reg;
  34         u8                              flags;
  35         spinlock_t                      lock;
  36 };
  37
  38 static int rockchip_reset_assert(struct reset_controller_dev *rcdev,
  39                               unsigned long id)
  40 {
  41         struct rockchip_reset *reset = container_of(rcdev,
  42                                                      struct rockchip_reset,
  43                                                      rcdev);
  44         int bank = id / reset->num_per_reg;
  45         int offset = id % reset->num_per_reg;
  46
  47         if (reset->flags & ROCKCHIP_RESET_HIWORD_MASK) {
  48                 writel(BIT(offset) | (BIT(offset) << 16),
  49                        reset->reg_base + (bank * 4));
  50         } else {
  51                 unsigned long flags;
  52                 u32 reg;
  53
  54                 spin_lock_irqsave(&reset->lock, flags);
  55
  56                 reg = readl(reset->reg_base + (bank * 4));
  57                 writel(reg | BIT(offset), reset->reg_base + (bank * 4));
  58
  59                 spin_unlock_irqrestore(&reset->lock, flags);
  60         }
  61
  62         return 0;
  63 }
  64
  65 static int rockchip_reset_deassert(struct reset_controller_dev *rcdev,
  66                                 unsigned long id)
  67 {
  68         struct rockchip_reset *reset = container_of(rcdev,
  69                                                      struct rockchip_reset,
  70                                                      rcdev);
  71         int bank = id / reset->num_per_reg;
  72         int offset = id % reset->num_per_reg;
  73
  74         if (reset->flags & ROCKCHIP_RESET_HIWORD_MASK) {
  75                 writel((BIT(offset) << 16), reset->reg_base + (bank * 4));
  76         } else {
  77                 unsigned long flags;
  78                 u32 reg;
  79
  80                 spin_lock_irqsave(&reset->lock, flags);
  81
  82                 reg = readl(reset->reg_base + (bank * 4));
  83                 writel(reg & ~BIT(offset), reset->reg_base + (bank * 4));
  84
  85                 spin_unlock_irqrestore(&reset->lock, flags);
  86         }
  87
  88         return 0;
  89 }
  90
  91 static struct reset_control_ops rockchip_reset_ops = {
  92         .assert         = rockchip_reset_assert,
  93         .deassert       = rockchip_reset_deassert,
  94 };
  95
  96 static int rockchip_register_reset(struct device_node *np,
  97                                       unsigned int num_regs,
  98                                       void __iomem *base, u8 flags)
  99 {
 100         struct rockchip_reset *reset;
 101         int ret;
 102
 103         reset = kzalloc(sizeof(*reset), GFP_KERNEL);
 104         if (!reset)
 105                 return -ENOMEM;
 106
 107         reset->flags = flags;
 108         reset->reg_base = base;
 109         reset->num_regs = num_regs;
 110         reset->num_per_reg = (flags & ROCKCHIP_RESET_HIWORD_MASK) ? 16 : 32;
 111         spin_lock_init(&reset->lock);
 112
 113         reset->rcdev.owner = THIS_MODULE;
 114         reset->rcdev.nr_resets =  num_regs * reset->num_per_reg;
 115         reset->rcdev.ops = &rockchip_reset_ops;
 116         reset->rcdev.of_node = np;
 117         ret = reset_controller_register(&reset->rcdev);
 118         if (ret) {
 119                 pr_err("%s: could not register reset controller, %d\n",
 120                        __func__, ret);
 121                 kfree(reset);
 122                 return ret;
 123         }
 124
 125         return 0;
 126 };
 127
 128 static int __init rockchip_reset_probe(struct platform_device *pdev)
 129 {
 130         struct resource *res;
 131         void __iomem *base;
 132         resource_size_t size;
 133         u32 flag = 0;
 134
 135
 136         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 137         base = devm_ioremap_resource(&pdev->dev, res);
 138         if (IS_ERR(base)) {
 139                 pr_err("%s: ioremap err\n", __func__);
 140                 return PTR_ERR(base);
 141         }
 142
 143         size = resource_size(res);
 144         if (size%4) {
 145                 pr_err("%s: wrong size value\n", __func__);
 146                 return -EINVAL;
 147         }
 148
 149         of_property_read_u32(pdev->dev.of_node, "rockchip,reset-flag", &flag);
 150
 151         return rockchip_register_reset(pdev->dev.of_node, size/4, base, flag);
 152 }
 153
 154 static const struct of_device_id rockchip_reset_dt_ids[]  = {
 155         { .compatible = "rockchip,reset", },
 156         { /* sentinel */ },
 157 };
 158 MODULE_DEVICE_TABLE(of, rockchip_reset_dt_ids);
 159
 160 static struct platform_driver rockchip_reset_driver = {
 161         .driver = {
 162                 .name           = "rockchip-reset",
 163                 .owner          = THIS_MODULE,
 164                 .of_match_table = rockchip_reset_dt_ids,
 165         },
 166 };
 167
 168 static int __init rockchip_reset_module_init(void)
 169 {
 170         return platform_driver_probe(&rockchip_reset_driver,
 171                                      rockchip_reset_probe);
 172 }
 173
 174 subsys_initcall_sync(rockchip_reset_module_init);