LXR linux/drivers/rapidio/rio-access.c

   1/*
   2 * RapidIO configuration space access support
   3 *
   4 * Copyright 2005 MontaVista Software, Inc.
   5 * Matt Porter <mporter@kernel.crashing.org>
   6 *
   7 * This program is free software; you can redistribute  it and/or modify it
   8 * under  the terms of  the GNU General  Public License as published by the
   9 * Free Software Foundation;  either version 2 of the  License, or (at your
  10 * option) any later version.
  11 */
  12
  13#include <linux/rio.h>
  14#include <linux/module.h>
  15
  16/*
  17 * These interrupt-safe spinlocks protect all accesses to RIO
  18 * configuration space and doorbell access.
  19 */
  20static DEFINE_SPINLOCK(rio_config_lock);
  21static DEFINE_SPINLOCK(rio_doorbell_lock);
  22
  23/*
  24 *  Wrappers for all RIO configuration access functions.  They just check
  25 *  alignment, do locking and call the low-level functions pointed to
  26 *  by rio_mport->ops.
  27 */
  28
  29#define RIO_8_BAD 0
  30#define RIO_16_BAD (offset & 1)
  31#define RIO_32_BAD (offset & 3)
  32
  33/**
  34 * RIO_LOP_READ - Generate rio_local_read_config_* functions
  35 * @size: Size of configuration space read (8, 16, 32 bits)
  36 * @type: C type of value argument
  37 * @len: Length of configuration space read (1, 2, 4 bytes)
  38 *
  39 * Generates rio_local_read_config_* functions used to access
  40 * configuration space registers on the local device.
  41 */
  42#define RIO_LOP_READ(size,type,len) \
  43int __rio_local_read_config_##size \
  44        (struct rio_mport *mport, u32 offset, type *value)              \
  45{                                                                       \
  46        int res;                                                        \
  47        unsigned long flags;                                            \
  48        u32 data = 0;                                                   \
  49        if (RIO_##size##_BAD) return RIO_BAD_SIZE;                      \
  50        spin_lock_irqsave(&rio_config_lock, flags);                     \
  51        res = mport->ops->lcread(mport, mport->id, offset, len, &data); \
  52        *value = (type)data;                                            \
  53        spin_unlock_irqrestore(&rio_config_lock, flags);                \
  54        return res;                                                     \
  55}
  56
  57/**
  58 * RIO_LOP_WRITE - Generate rio_local_write_config_* functions
  59 * @size: Size of configuration space write (8, 16, 32 bits)
  60 * @type: C type of value argument
  61 * @len: Length of configuration space write (1, 2, 4 bytes)
  62 *
  63 * Generates rio_local_write_config_* functions used to access
  64 * configuration space registers on the local device.
  65 */
  66#define RIO_LOP_WRITE(size,type,len) \
  67int __rio_local_write_config_##size \
  68        (struct rio_mport *mport, u32 offset, type value)               \
  69{                                                                       \
  70        int res;                                                        \
  71        unsigned long flags;                                            \
  72        if (RIO_##size##_BAD) return RIO_BAD_SIZE;                      \
  73        spin_lock_irqsave(&rio_config_lock, flags);                     \
  74        res = mport->ops->lcwrite(mport, mport->id, offset, len, value);\
  75        spin_unlock_irqrestore(&rio_config_lock, flags);                \
  76        return res;                                                     \
  77}
  78
  79RIO_LOP_READ(8, u8, 1)
  80RIO_LOP_READ(16, u16, 2)
  81RIO_LOP_READ(32, u32, 4)
  82RIO_LOP_WRITE(8, u8, 1)
  83RIO_LOP_WRITE(16, u16, 2)
  84RIO_LOP_WRITE(32, u32, 4)
  85
  86EXPORT_SYMBOL_GPL(__rio_local_read_config_8);
  87EXPORT_SYMBOL_GPL(__rio_local_read_config_16);
  88EXPORT_SYMBOL_GPL(__rio_local_read_config_32);
  89EXPORT_SYMBOL_GPL(__rio_local_write_config_8);
  90EXPORT_SYMBOL_GPL(__rio_local_write_config_16);
  91EXPORT_SYMBOL_GPL(__rio_local_write_config_32);
  92
  93/**
  94 * RIO_OP_READ - Generate rio_mport_read_config_* functions
  95 * @size: Size of configuration space read (8, 16, 32 bits)
  96 * @type: C type of value argument
  97 * @len: Length of configuration space read (1, 2, 4 bytes)
  98 *
  99 * Generates rio_mport_read_config_* functions used to access
 100 * configuration space registers on the local device.
 101 */
 102#define RIO_OP_READ(size,type,len) \
 103int rio_mport_read_config_##size \
 104        (struct rio_mport *mport, u16 destid, u8 hopcount, u32 offset, type *value)     \
 105{                                                                       \
 106        int res;                                                        \
 107        unsigned long flags;                                            \
 108        u32 data = 0;                                                   \
 109        if (RIO_##size##_BAD) return RIO_BAD_SIZE;                      \
 110        spin_lock_irqsave(&rio_config_lock, flags);                     \
 111        res = mport->ops->cread(mport, mport->id, destid, hopcount, offset, len, &data); \
 112        *value = (type)data;                                            \
 113        spin_unlock_irqrestore(&rio_config_lock, flags);                \
 114        return res;                                                     \
 115}
 116
 117/**
 118 * RIO_OP_WRITE - Generate rio_mport_write_config_* functions
 119 * @size: Size of configuration space write (8, 16, 32 bits)
 120 * @type: C type of value argument
 121 * @len: Length of configuration space write (1, 2, 4 bytes)
 122 *
 123 * Generates rio_mport_write_config_* functions used to access
 124 * configuration space registers on the local device.
 125 */
 126#define RIO_OP_WRITE(size,type,len) \
 127int rio_mport_write_config_##size \
 128        (struct rio_mport *mport, u16 destid, u8 hopcount, u32 offset, type value)      \
 129{                                                                       \
 130        int res;                                                        \
 131        unsigned long flags;                                            \
 132        if (RIO_##size##_BAD) return RIO_BAD_SIZE;                      \
 133        spin_lock_irqsave(&rio_config_lock, flags);                     \
 134        res = mport->ops->cwrite(mport, mport->id, destid, hopcount, offset, len, value); \
 135        spin_unlock_irqrestore(&rio_config_lock, flags);                \
 136        return res;                                                     \
 137}
 138
 139RIO_OP_READ(8, u8, 1)
 140RIO_OP_READ(16, u16, 2)
 141RIO_OP_READ(32, u32, 4)
 142RIO_OP_WRITE(8, u8, 1)
 143RIO_OP_WRITE(16, u16, 2)
 144RIO_OP_WRITE(32, u32, 4)
 145
 146EXPORT_SYMBOL_GPL(rio_mport_read_config_8);
 147EXPORT_SYMBOL_GPL(rio_mport_read_config_16);
 148EXPORT_SYMBOL_GPL(rio_mport_read_config_32);
 149EXPORT_SYMBOL_GPL(rio_mport_write_config_8);
 150EXPORT_SYMBOL_GPL(rio_mport_write_config_16);
 151EXPORT_SYMBOL_GPL(rio_mport_write_config_32);
 152
 153/**
 154 * rio_mport_send_doorbell - Send a doorbell message
 155 *
 156 * @mport: RIO master port
 157 * @destid: RIO device destination ID
 158 * @data: Doorbell message data
 159 *
 160 * Send a doorbell message to a RIO device. The doorbell message
 161 * has a 16-bit info field provided by the data argument.
 162 */
 163int rio_mport_send_doorbell(struct rio_mport *mport, u16 destid, u16 data)
 164{
 165        int res;
 166        unsigned long flags;
 167
 168        spin_lock_irqsave(&rio_doorbell_lock, flags);
 169        res = mport->ops->dsend(mport, mport->id, destid, data);
 170        spin_unlock_irqrestore(&rio_doorbell_lock, flags);
 171
 172        return res;
 173}
 174
 175EXPORT_SYMBOL_GPL(rio_mport_send_doorbell);
 176