blob: 887d34effb3a3a40d4636a03e1783dc1e9f56584 [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
81static int __devinit omap_hwspinlock_probe(struct platform_device *pdev)
82{
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
101 /* Determine number of locks */
102 i = readl(io_base + SYSSTATUS_OFFSET);
103 i >>= SPINLOCK_NUMLOCKS_BIT_OFFSET;
104
105 /* one of the four lsb's must be set, and nothing else */
106 if (hweight_long(i & 0xf) != 1 || i > 8) {
107 ret = -EINVAL;
108 goto iounmap_base;
109 }
110
Ohad Ben-Cohen300bab92011-09-06 15:39:21 +0300111 num_locks = i * 32; /* actual number of locks in this device */
Ohad Ben-Cohenc97f6dd2011-09-05 17:30:34 +0300112
Ohad Ben-Cohen300bab92011-09-06 15:39:21 +0300113 bank = kzalloc(sizeof(*bank) + num_locks * sizeof(*hwlock), GFP_KERNEL);
114 if (!bank) {
Ohad Ben-Cohenc97f6dd2011-09-05 17:30:34 +0300115 ret = -ENOMEM;
116 goto iounmap_base;
117 }
118
Ohad Ben-Cohen300bab92011-09-06 15:39:21 +0300119 platform_set_drvdata(pdev, bank);
Simon Que70ba4cc2011-02-17 09:52:03 -0800120
Ohad Ben-Cohen300bab92011-09-06 15:39:21 +0300121 for (i = 0, hwlock = &bank->lock[0]; i < num_locks; i++, hwlock++)
122 hwlock->priv = io_base + LOCK_BASE_OFFSET + sizeof(u32) * i;
Simon Que70ba4cc2011-02-17 09:52:03 -0800123
124 /*
125 * runtime PM will make sure the clock of this module is
126 * enabled iff at least one lock is requested
127 */
128 pm_runtime_enable(&pdev->dev);
129
Ohad Ben-Cohen300bab92011-09-06 15:39:21 +0300130 ret = hwspin_lock_register(bank, &pdev->dev, &omap_hwspinlock_ops,
131 pdata->base_id, num_locks);
132 if (ret)
133 goto reg_fail;
Simon Que70ba4cc2011-02-17 09:52:03 -0800134
135 return 0;
136
Ohad Ben-Cohen300bab92011-09-06 15:39:21 +0300137reg_fail:
Simon Que70ba4cc2011-02-17 09:52:03 -0800138 pm_runtime_disable(&pdev->dev);
Ohad Ben-Cohen300bab92011-09-06 15:39:21 +0300139 kfree(bank);
Simon Que70ba4cc2011-02-17 09:52:03 -0800140iounmap_base:
141 iounmap(io_base);
Simon Que70ba4cc2011-02-17 09:52:03 -0800142 return ret;
143}
144
Ohad Ben-Cohen9efb4a12011-09-11 18:54:50 +0300145static int __devexit omap_hwspinlock_remove(struct platform_device *pdev)
Simon Que70ba4cc2011-02-17 09:52:03 -0800146{
Ohad Ben-Cohen300bab92011-09-06 15:39:21 +0300147 struct hwspinlock_device *bank = platform_get_drvdata(pdev);
148 void __iomem *io_base = bank->lock[0].priv - LOCK_BASE_OFFSET;
149 int ret;
Simon Que70ba4cc2011-02-17 09:52:03 -0800150
Ohad Ben-Cohen300bab92011-09-06 15:39:21 +0300151 ret = hwspin_lock_unregister(bank);
152 if (ret) {
153 dev_err(&pdev->dev, "%s failed: %d\n", __func__, ret);
154 return ret;
Simon Que70ba4cc2011-02-17 09:52:03 -0800155 }
156
157 pm_runtime_disable(&pdev->dev);
Ohad Ben-Cohen300bab92011-09-06 15:39:21 +0300158 iounmap(io_base);
159 kfree(bank);
Simon Que70ba4cc2011-02-17 09:52:03 -0800160
161 return 0;
162}
163
164static struct platform_driver omap_hwspinlock_driver = {
165 .probe = omap_hwspinlock_probe,
Ohad Ben-Cohen9efb4a12011-09-11 18:54:50 +0300166 .remove = __devexit_p(omap_hwspinlock_remove),
Simon Que70ba4cc2011-02-17 09:52:03 -0800167 .driver = {
168 .name = "omap_hwspinlock",
Ohad Ben-Cohene467b642011-09-05 16:42:36 +0300169 .owner = THIS_MODULE,
Simon Que70ba4cc2011-02-17 09:52:03 -0800170 },
171};
172
173static int __init omap_hwspinlock_init(void)
174{
175 return platform_driver_register(&omap_hwspinlock_driver);
176}
177/* board init code might need to reserve hwspinlocks for predefined purposes */
178postcore_initcall(omap_hwspinlock_init);
179
180static void __exit omap_hwspinlock_exit(void)
181{
182 platform_driver_unregister(&omap_hwspinlock_driver);
183}
184module_exit(omap_hwspinlock_exit);
185
186MODULE_LICENSE("GPL v2");
187MODULE_DESCRIPTION("Hardware spinlock driver for OMAP");
188MODULE_AUTHOR("Simon Que <sque@ti.com>");
189MODULE_AUTHOR("Hari Kanigeri <h-kanigeri2@ti.com>");
190MODULE_AUTHOR("Ohad Ben-Cohen <ohad@wizery.com>");