blob: 47a275c6ece1d24487ca0f832f2913a597b8a87b [file] [log] [blame]
Simon Que70ba4cc2011-02-17 09:52:03 -08001/*
2 * OMAP hardware spinlock driver
3 *
4 * Copyright (C) 2010 Texas Instruments Incorporated - http://www.ti.com
5 *
6 * Contact: Simon Que <sque@ti.com>
7 * Hari Kanigeri <h-kanigeri2@ti.com>
8 * Ohad Ben-Cohen <ohad@wizery.com>
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * version 2 as published by the Free Software Foundation.
13 *
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
18 */
19
20#include <linux/kernel.h>
21#include <linux/module.h>
22#include <linux/device.h>
23#include <linux/delay.h>
24#include <linux/io.h>
25#include <linux/bitops.h>
26#include <linux/pm_runtime.h>
27#include <linux/slab.h>
28#include <linux/spinlock.h>
29#include <linux/hwspinlock.h>
30#include <linux/platform_device.h>
31
32#include "hwspinlock_internal.h"
33
34/* Spinlock register offsets */
35#define SYSSTATUS_OFFSET 0x0014
36#define LOCK_BASE_OFFSET 0x0800
37
38#define SPINLOCK_NUMLOCKS_BIT_OFFSET (24)
39
40/* Possible values of SPINLOCK_LOCK_REG */
41#define SPINLOCK_NOTTAKEN (0) /* free */
42#define SPINLOCK_TAKEN (1) /* locked */
43
Simon Que70ba4cc2011-02-17 09:52:03 -080044static int omap_hwspinlock_trylock(struct hwspinlock *lock)
45{
Ohad Ben-Cohen300bab92011-09-06 15:39:21 +030046 void __iomem *lock_addr = lock->priv;
Simon Que70ba4cc2011-02-17 09:52:03 -080047
48 /* attempt to acquire the lock by reading its value */
Ohad Ben-Cohen300bab92011-09-06 15:39:21 +030049 return (SPINLOCK_NOTTAKEN == readl(lock_addr));
Simon Que70ba4cc2011-02-17 09:52:03 -080050}
51
52static void omap_hwspinlock_unlock(struct hwspinlock *lock)
53{
Ohad Ben-Cohen300bab92011-09-06 15:39:21 +030054 void __iomem *lock_addr = lock->priv;
Simon Que70ba4cc2011-02-17 09:52:03 -080055
56 /* release the lock by writing 0 to it */
Ohad Ben-Cohen300bab92011-09-06 15:39:21 +030057 writel(SPINLOCK_NOTTAKEN, lock_addr);
Simon Que70ba4cc2011-02-17 09:52:03 -080058}
59
60/*
61 * relax the OMAP interconnect while spinning on it.
62 *
63 * The specs recommended that the retry delay time will be
64 * just over half of the time that a requester would be
65 * expected to hold the lock.
66 *
67 * The number below is taken from an hardware specs example,
68 * obviously it is somewhat arbitrary.
69 */
70static void omap_hwspinlock_relax(struct hwspinlock *lock)
71{
72 ndelay(50);
73}
74
75static const struct hwspinlock_ops omap_hwspinlock_ops = {
76 .trylock = omap_hwspinlock_trylock,
77 .unlock = omap_hwspinlock_unlock,
78 .relax = omap_hwspinlock_relax,
79};
80
Bill Pemberton57129102012-11-19 13:23:22 -050081static int omap_hwspinlock_probe(struct platform_device *pdev)
Simon Que70ba4cc2011-02-17 09:52:03 -080082{
Ohad Ben-Cohenc3c12502011-09-05 23:15:06 +030083 struct hwspinlock_pdata *pdata = pdev->dev.platform_data;
Ohad Ben-Cohen300bab92011-09-06 15:39:21 +030084 struct hwspinlock_device *bank;
85 struct hwspinlock *hwlock;
Simon Que70ba4cc2011-02-17 09:52:03 -080086 struct resource *res;
87 void __iomem *io_base;
Ohad Ben-Cohen300bab92011-09-06 15:39:21 +030088 int num_locks, i, ret;
Simon Que70ba4cc2011-02-17 09:52:03 -080089
Ohad Ben-Cohenc3c12502011-09-05 23:15:06 +030090 if (!pdata)
91 return -ENODEV;
92
Simon Que70ba4cc2011-02-17 09:52:03 -080093 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
94 if (!res)
95 return -ENODEV;
96
Simon Que70ba4cc2011-02-17 09:52:03 -080097 io_base = ioremap(res->start, resource_size(res));
Ohad Ben-Cohenc97f6dd2011-09-05 17:30:34 +030098 if (!io_base)
99 return -ENOMEM;
Simon Que70ba4cc2011-02-17 09:52:03 -0800100
Suman Annae1e45282014-07-02 18:00:59 -0500101 /*
102 * make sure the module is enabled and clocked before reading
103 * the module SYSSTATUS register
104 */
105 pm_runtime_enable(&pdev->dev);
106 ret = pm_runtime_get_sync(&pdev->dev);
107 if (ret < 0) {
108 pm_runtime_put_noidle(&pdev->dev);
109 goto iounmap_base;
110 }
111
Simon Que70ba4cc2011-02-17 09:52:03 -0800112 /* Determine number of locks */
113 i = readl(io_base + SYSSTATUS_OFFSET);
114 i >>= SPINLOCK_NUMLOCKS_BIT_OFFSET;
115
Suman Annae1e45282014-07-02 18:00:59 -0500116 /*
117 * runtime PM will make sure the clock of this module is
118 * enabled again iff at least one lock is requested
119 */
120 ret = pm_runtime_put(&pdev->dev);
121 if (ret < 0)
122 goto iounmap_base;
123
Simon Que70ba4cc2011-02-17 09:52:03 -0800124 /* one of the four lsb's must be set, and nothing else */
125 if (hweight_long(i & 0xf) != 1 || i > 8) {
126 ret = -EINVAL;
127 goto iounmap_base;
128 }
129
Ohad Ben-Cohen300bab92011-09-06 15:39:21 +0300130 num_locks = i * 32; /* actual number of locks in this device */
Ohad Ben-Cohenc97f6dd2011-09-05 17:30:34 +0300131
Ohad Ben-Cohen300bab92011-09-06 15:39:21 +0300132 bank = kzalloc(sizeof(*bank) + num_locks * sizeof(*hwlock), GFP_KERNEL);
133 if (!bank) {
Ohad Ben-Cohenc97f6dd2011-09-05 17:30:34 +0300134 ret = -ENOMEM;
135 goto iounmap_base;
136 }
137
Ohad Ben-Cohen300bab92011-09-06 15:39:21 +0300138 platform_set_drvdata(pdev, bank);
Simon Que70ba4cc2011-02-17 09:52:03 -0800139
Ohad Ben-Cohen300bab92011-09-06 15:39:21 +0300140 for (i = 0, hwlock = &bank->lock[0]; i < num_locks; i++, hwlock++)
141 hwlock->priv = io_base + LOCK_BASE_OFFSET + sizeof(u32) * i;
Simon Que70ba4cc2011-02-17 09:52:03 -0800142
Ohad Ben-Cohen300bab92011-09-06 15:39:21 +0300143 ret = hwspin_lock_register(bank, &pdev->dev, &omap_hwspinlock_ops,
144 pdata->base_id, num_locks);
145 if (ret)
146 goto reg_fail;
Simon Que70ba4cc2011-02-17 09:52:03 -0800147
148 return 0;
149
Ohad Ben-Cohen300bab92011-09-06 15:39:21 +0300150reg_fail:
Ohad Ben-Cohen300bab92011-09-06 15:39:21 +0300151 kfree(bank);
Simon Que70ba4cc2011-02-17 09:52:03 -0800152iounmap_base:
Suman Annae1e45282014-07-02 18:00:59 -0500153 pm_runtime_disable(&pdev->dev);
Simon Que70ba4cc2011-02-17 09:52:03 -0800154 iounmap(io_base);
Simon Que70ba4cc2011-02-17 09:52:03 -0800155 return ret;
156}
157
Bill Pembertone533a342012-11-19 13:25:52 -0500158static int omap_hwspinlock_remove(struct platform_device *pdev)
Simon Que70ba4cc2011-02-17 09:52:03 -0800159{
Ohad Ben-Cohen300bab92011-09-06 15:39:21 +0300160 struct hwspinlock_device *bank = platform_get_drvdata(pdev);
161 void __iomem *io_base = bank->lock[0].priv - LOCK_BASE_OFFSET;
162 int ret;
Simon Que70ba4cc2011-02-17 09:52:03 -0800163
Ohad Ben-Cohen300bab92011-09-06 15:39:21 +0300164 ret = hwspin_lock_unregister(bank);
165 if (ret) {
166 dev_err(&pdev->dev, "%s failed: %d\n", __func__, ret);
167 return ret;
Simon Que70ba4cc2011-02-17 09:52:03 -0800168 }
169
170 pm_runtime_disable(&pdev->dev);
Ohad Ben-Cohen300bab92011-09-06 15:39:21 +0300171 iounmap(io_base);
172 kfree(bank);
Simon Que70ba4cc2011-02-17 09:52:03 -0800173
174 return 0;
175}
176
177static struct platform_driver omap_hwspinlock_driver = {
178 .probe = omap_hwspinlock_probe,
Bill Pemberton9eb26bd2012-11-19 13:20:13 -0500179 .remove = omap_hwspinlock_remove,
Simon Que70ba4cc2011-02-17 09:52:03 -0800180 .driver = {
181 .name = "omap_hwspinlock",
Simon Que70ba4cc2011-02-17 09:52:03 -0800182 },
183};
184
185static int __init omap_hwspinlock_init(void)
186{
187 return platform_driver_register(&omap_hwspinlock_driver);
188}
189/* board init code might need to reserve hwspinlocks for predefined purposes */
190postcore_initcall(omap_hwspinlock_init);
191
192static void __exit omap_hwspinlock_exit(void)
193{
194 platform_driver_unregister(&omap_hwspinlock_driver);
195}
196module_exit(omap_hwspinlock_exit);
197
198MODULE_LICENSE("GPL v2");
199MODULE_DESCRIPTION("Hardware spinlock driver for OMAP");
200MODULE_AUTHOR("Simon Que <sque@ti.com>");
201MODULE_AUTHOR("Hari Kanigeri <h-kanigeri2@ti.com>");
202MODULE_AUTHOR("Ohad Ben-Cohen <ohad@wizery.com>");