1 /* 2 * Allwinner SoCs Reset Controller driver 3 * 4 * Copyright 2013 Maxime Ripard 5 * 6 * Maxime Ripard <maxime.ripard@free-electrons.com> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 */ 13 14 #include <linux/err.h> 15 #include <linux/io.h> 16 #include <linux/module.h> 17 #include <linux/of.h> 18 #include <linux/of_address.h> 19 #include <linux/platform_device.h> 20 #include <linux/reset-controller.h> 21 #include <linux/slab.h> 22 #include <linux/spinlock.h> 23 #include <linux/types.h> 24 25 struct sunxi_reset_data { 26 spinlock_t lock; 27 void __iomem *membase; 28 struct reset_controller_dev rcdev; 29 }; 30 31 static int sunxi_reset_assert(struct reset_controller_dev *rcdev, 32 unsigned long id) 33 { 34 struct sunxi_reset_data *data = container_of(rcdev, 35 struct sunxi_reset_data, 36 rcdev); 37 int bank = id / BITS_PER_LONG; 38 int offset = id % BITS_PER_LONG; 39 unsigned long flags; 40 u32 reg; 41 42 spin_lock_irqsave(&data->lock, flags); 43 44 reg = readl(data->membase + (bank * 4)); 45 writel(reg & ~BIT(offset), data->membase + (bank * 4)); 46 47 spin_unlock_irqrestore(&data->lock, flags); 48 49 return 0; 50 } 51 52 static int sunxi_reset_deassert(struct reset_controller_dev *rcdev, 53 unsigned long id) 54 { 55 struct sunxi_reset_data *data = container_of(rcdev, 56 struct sunxi_reset_data, 57 rcdev); 58 int bank = id / BITS_PER_LONG; 59 int offset = id % BITS_PER_LONG; 60 unsigned long flags; 61 u32 reg; 62 63 spin_lock_irqsave(&data->lock, flags); 64 65 reg = readl(data->membase + (bank * 4)); 66 writel(reg | BIT(offset), data->membase + (bank * 4)); 67 68 spin_unlock_irqrestore(&data->lock, flags); 69 70 return 0; 71 } 72 73 static struct reset_control_ops sunxi_reset_ops = { 74 .assert = sunxi_reset_assert, 75 .deassert = sunxi_reset_deassert, 76 }; 77 78 static int sunxi_reset_init(struct device_node *np) 79 { 80 struct sunxi_reset_data *data; 81 struct resource res; 82 resource_size_t size; 83 int ret; 84 85 data = kzalloc(sizeof(*data), GFP_KERNEL); 86 if (!data) 87 return -ENOMEM; 88 89 ret = of_address_to_resource(np, 0, &res); 90 if (ret) 91 goto err_alloc; 92 93 size = resource_size(&res); 94 if (!request_mem_region(res.start, size, np->name)) { 95 ret = -EBUSY; 96 goto err_alloc; 97 } 98 99 data->membase = ioremap(res.start, size); 100 if (!data->membase) { 101 ret = -ENOMEM; 102 goto err_alloc; 103 } 104 105 data->rcdev.owner = THIS_MODULE; 106 data->rcdev.nr_resets = size * 32; 107 data->rcdev.ops = &sunxi_reset_ops; 108 data->rcdev.of_node = np; 109 reset_controller_register(&data->rcdev); 110 111 return 0; 112 113 err_alloc: 114 kfree(data); 115 return ret; 116 }; 117 118 /* 119 * These are the reset controller we need to initialize early on in 120 * our system, before we can even think of using a regular device 121 * driver for it. 122 */ 123 static const struct of_device_id sunxi_early_reset_dt_ids[] __initdata = { 124 { .compatible = "allwinner,sun6i-a31-ahb1-reset", }, 125 { /* sentinel */ }, 126 }; 127 128 void __init sun6i_reset_init(void) 129 { 130 struct device_node *np; 131 132 for_each_matching_node(np, sunxi_early_reset_dt_ids) 133 sunxi_reset_init(np); 134 } 135 136 /* 137 * And these are the controllers we can register through the regular 138 * device model. 139 */ 140 static const struct of_device_id sunxi_reset_dt_ids[] = { 141 { .compatible = "allwinner,sun6i-a31-clock-reset", }, 142 { /* sentinel */ }, 143 }; 144 MODULE_DEVICE_TABLE(of, sunxi_reset_dt_ids); 145 146 static int sunxi_reset_probe(struct platform_device *pdev) 147 { 148 struct sunxi_reset_data *data; 149 struct resource *res; 150 151 data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); 152 if (!data) 153 return -ENOMEM; 154 155 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 156 data->membase = devm_ioremap_resource(&pdev->dev, res); 157 if (IS_ERR(data->membase)) 158 return PTR_ERR(data->membase); 159 160 data->rcdev.owner = THIS_MODULE; 161 data->rcdev.nr_resets = resource_size(res) * 32; 162 data->rcdev.ops = &sunxi_reset_ops; 163 data->rcdev.of_node = pdev->dev.of_node; 164 165 return reset_controller_register(&data->rcdev); 166 } 167 168 static int sunxi_reset_remove(struct platform_device *pdev) 169 { 170 struct sunxi_reset_data *data = platform_get_drvdata(pdev); 171 172 reset_controller_unregister(&data->rcdev); 173 174 return 0; 175 } 176 177 static struct platform_driver sunxi_reset_driver = { 178 .probe = sunxi_reset_probe, 179 .remove = sunxi_reset_remove, 180 .driver = { 181 .name = "sunxi-reset", 182 .owner = THIS_MODULE, 183 .of_match_table = sunxi_reset_dt_ids, 184 }, 185 }; 186 module_platform_driver(sunxi_reset_driver); 187 188 MODULE_AUTHOR("Maxime Ripard <maxime.ripard@free-electrons.com"); 189 MODULE_DESCRIPTION("Allwinner SoCs Reset Controller Driver"); 190 MODULE_LICENSE("GPL"); 191