linux/drivers/hwspinlock/omap_hwspinlock.c
<<
>>
Prefs
   1/*
   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
  44static int omap_hwspinlock_trylock(struct hwspinlock *lock)
  45{
  46        void __iomem *lock_addr = lock->priv;
  47
  48        /* attempt to acquire the lock by reading its value */
  49        return (SPINLOCK_NOTTAKEN == readl(lock_addr));
  50}
  51
  52static void omap_hwspinlock_unlock(struct hwspinlock *lock)
  53{
  54        void __iomem *lock_addr = lock->priv;
  55
  56        /* release the lock by writing 0 to it */
  57        writel(SPINLOCK_NOTTAKEN, lock_addr);
  58}
  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{
  83        struct hwspinlock_pdata *pdata = pdev->dev.platform_data;
  84        struct hwspinlock_device *bank;
  85        struct hwspinlock *hwlock;
  86        struct resource *res;
  87        void __iomem *io_base;
  88        int num_locks, i, ret;
  89
  90        if (!pdata)
  91                return -ENODEV;
  92
  93        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  94        if (!res)
  95                return -ENODEV;
  96
  97        io_base = ioremap(res->start, resource_size(res));
  98        if (!io_base)
  99                return -ENOMEM;
 100
 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
 111        num_locks = i * 32; /* actual number of locks in this device */
 112
 113        bank = kzalloc(sizeof(*bank) + num_locks * sizeof(*hwlock), GFP_KERNEL);
 114        if (!bank) {
 115                ret = -ENOMEM;
 116                goto iounmap_base;
 117        }
 118
 119        platform_set_drvdata(pdev, bank);
 120
 121        for (i = 0, hwlock = &bank->lock[0]; i < num_locks; i++, hwlock++)
 122                hwlock->priv = io_base + LOCK_BASE_OFFSET + sizeof(u32) * i;
 123
 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
 130        ret = hwspin_lock_register(bank, &pdev->dev, &omap_hwspinlock_ops,
 131                                                pdata->base_id, num_locks);
 132        if (ret)
 133                goto reg_fail;
 134
 135        return 0;
 136
 137reg_fail:
 138        pm_runtime_disable(&pdev->dev);
 139        kfree(bank);
 140iounmap_base:
 141        iounmap(io_base);
 142        return ret;
 143}
 144
 145static int __devexit omap_hwspinlock_remove(struct platform_device *pdev)
 146{
 147        struct hwspinlock_device *bank = platform_get_drvdata(pdev);
 148        void __iomem *io_base = bank->lock[0].priv - LOCK_BASE_OFFSET;
 149        int ret;
 150
 151        ret = hwspin_lock_unregister(bank);
 152        if (ret) {
 153                dev_err(&pdev->dev, "%s failed: %d\n", __func__, ret);
 154                return ret;
 155        }
 156
 157        pm_runtime_disable(&pdev->dev);
 158        iounmap(io_base);
 159        kfree(bank);
 160
 161        return 0;
 162}
 163
 164static struct platform_driver omap_hwspinlock_driver = {
 165        .probe          = omap_hwspinlock_probe,
 166        .remove         = __devexit_p(omap_hwspinlock_remove),
 167        .driver         = {
 168                .name   = "omap_hwspinlock",
 169                .owner  = THIS_MODULE,
 170        },
 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>");
 191
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.