drivers/cbus/tahvo-user.c

   1 /**
   2  * drivers/cbus/tahvo-user.c
   3  *
   4  * Tahvo user space interface functions
   5  *
   6  * Copyright (C) 2004, 2005 Nokia Corporation
   7  *
   8  * Written by Mikko Ylinen <mikko.k.ylinen@nokia.com>
   9  *
  10  * This file is subject to the terms and conditions of the GNU General
  11  * Public License. See the file "COPYING" in the main directory of this
  12  * archive for more details.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  */
  23
  24 #include <linux/types.h>
  25 #include <linux/kernel.h>
  26 #include <linux/interrupt.h>
  27 #include <linux/module.h>
  28 #include <linux/init.h>
  29 #include <linux/fs.h>
  30 #include <linux/miscdevice.h>
  31 #include <linux/poll.h>
  32 #include <linux/list.h>
  33 #include <linux/spinlock.h>
  34 #include <linux/sched.h>
  35 #include <linux/mutex.h>
  36
  37 #include <asm/uaccess.h>
  38
  39 #include "tahvo.h"
  40
  41 #include "user_retu_tahvo.h"
  42
  43 /* Maximum size of IRQ node buffer/pool */
  44 #define TAHVO_MAX_IRQ_BUF_LEN   16
  45
  46 #define PFX                     "tahvo-user: "
  47
  48 /* Bitmap for marking the interrupt sources as having the handlers */
  49 static u32 tahvo_irq_bits;
  50
  51 /* For allowing only one user process to subscribe to the tahvo interrupts */
  52 static struct file *tahvo_irq_subscr = NULL;
  53
  54 /* For poll and IRQ passing */
  55 struct tahvo_irq {
  56         u32 id;
  57         struct list_head node;
  58 };
  59
  60 static spinlock_t tahvo_irqs_lock;
  61 static struct tahvo_irq *tahvo_irq_block;
  62 static LIST_HEAD(tahvo_irqs);
  63 static LIST_HEAD(tahvo_irqs_reserve);
  64
  65 /* Wait queue - used when user wants to read the device */
  66 DECLARE_WAIT_QUEUE_HEAD(tahvo_user_waitqueue);
  67
  68 /* Semaphore to protect irq subscription sequence */
  69 static struct mutex tahvo_mutex;
  70
  71 /* This array specifies TAHVO register types (read/write/toggle) */
  72 static const u8 tahvo_access_bits[] = {
  73         1,
  74         4,
  75         1,
  76         3,
  77         3,
  78         3,
  79         3,
  80         3,
  81         3,
  82         3,
  83         3,
  84         3,
  85         3,
  86         1
  87 };
  88
  89 /*
  90  * The handler for all TAHVO interrupts.
  91  *
  92  * arg is the interrupt source in TAHVO.
  93  */
  94 static void tahvo_user_irq_handler(unsigned long arg)
  95 {
  96         struct tahvo_irq *irq;
  97
  98         /* user has to re-enable the interrupt once ready
  99          * for receiving them again */
 100         tahvo_disable_irq(arg);
 101         tahvo_ack_irq(arg);
 102
 103         spin_lock(&tahvo_irqs_lock);
 104         if (list_empty(&tahvo_irqs_reserve)) {
 105                 spin_unlock(&tahvo_irqs_lock);
 106                 return;
 107         }
 108         irq = list_entry((&tahvo_irqs_reserve)->next, struct tahvo_irq, node);
 109         irq->id = arg;
 110         list_move_tail(&irq->node, &tahvo_irqs);
 111         spin_unlock(&tahvo_irqs_lock);
 112
 113         /* wake up waiting thread */
 114         wake_up(&tahvo_user_waitqueue);
 115 }
 116
 117 /*
 118  * This routine sets up the interrupt handler and marks an interrupt source
 119  * in TAHVO as a candidate for signal delivery to the user process.
 120  */
 121 static int tahvo_user_subscribe_to_irq(int id, struct file *filp)
 122 {
 123         int ret;
 124
 125         mutex_lock(&tahvo_mutex);
 126         if ((tahvo_irq_subscr != NULL) && (tahvo_irq_subscr != filp)) {
 127                 mutex_unlock(&tahvo_mutex);
 128                 return -EBUSY;
 129         }
 130         /* Store the file pointer of the first user process registering IRQs */
 131         tahvo_irq_subscr = filp;
 132         mutex_unlock(&tahvo_mutex);
 133
 134         if (tahvo_irq_bits & (1 << id))
 135                 return 0;
 136
 137         ret = tahvo_request_irq(id, tahvo_user_irq_handler, id, "");
 138         if (ret < 0)
 139                 return ret;
 140
 141         /* Mark that this interrupt has a handler */
 142         tahvo_irq_bits |= 1 << id;
 143
 144         return 0;
 145 }
 146
 147 /*
 148  * Unregister all TAHVO interrupt handlers
 149  */
 150 static void tahvo_unreg_irq_handlers(void)
 151 {
 152         int id;
 153
 154         if (!tahvo_irq_bits)
 155                 return;
 156
 157         for (id = 0; id < MAX_TAHVO_IRQ_HANDLERS; id++)
 158                 if (tahvo_irq_bits & (1 << id))
 159                         tahvo_free_irq(id);
 160
 161         tahvo_irq_bits = 0;
 162 }
 163
 164 /*
 165  * Write to TAHVO register.
 166  * Returns 0 upon success, a negative error value otherwise.
 167  */
 168 static int tahvo_user_write_with_mask(u32 field, u16 value)
 169 {
 170         u32 mask;
 171         u32 reg;
 172         u_short tmp;
 173         unsigned long flags;
 174
 175         mask = MASK(field);
 176         reg = REG(field);
 177
 178         /* Detect bad mask and reg */
 179         if (mask == 0 || reg > TAHVO_REG_MAX ||
 180             tahvo_access_bits[reg] == READ_ONLY) {
 181                 printk(KERN_ERR PFX "invalid arguments (reg=%#x, mask=%#x)\n",
 182                        reg, mask);
 183                 return -EINVAL;
 184         }
 185
 186         /* Justify value according to mask */
 187         while (!(mask & 1)) {
 188                 value = value << 1;
 189                 mask = mask >> 1;
 190         }
 191
 192         spin_lock_irqsave(&tahvo_lock, flags);
 193         if (tahvo_access_bits[reg] == TOGGLE) {
 194                 /* No need to detect previous content of register */
 195                 tmp = 0;
 196         } else {
 197                 /* Read current value of register */
 198                 tmp = tahvo_read_reg(reg);
 199         }
 200         /* Generate a new value */
 201         tmp = (tmp & ~MASK(field)) | (value & MASK(field));
 202         /* Write data to TAHVO */
 203         tahvo_write_reg(reg, tmp);
 204         spin_unlock_irqrestore(&tahvo_lock, flags);
 205
 206         return 0;
 207 }
 208
 209 /*
 210  * Read TAHVO register.
 211  */
 212 static u32 tahvo_user_read_with_mask(u32 field)
 213 {
 214         u_short value;
 215         u32 mask, reg;
 216
 217         mask = MASK(field);
 218         reg = REG(field);
 219
 220         /* Detect bad mask and reg */
 221         if (mask == 0 || reg > TAHVO_REG_MAX) {
 222                 printk(KERN_ERR PFX "invalid arguments (reg=%#x, mask=%#x)\n",
 223                        reg, mask);
 224                 return -EINVAL;
 225         }
 226
 227         /* Read the register */
 228         value = tahvo_read_reg(reg) & mask;
 229
 230         /* Right justify value */
 231         while (!(mask & 1)) {
 232                 value = value >> 1;
 233                 mask = mask >> 1;
 234         }
 235
 236         return value;
 237 }
 238
 239 /*
 240  * Close device
 241  */
 242 static int tahvo_close(struct inode *inode, struct file *filp)
 243 {
 244         /* Unregister all interrupts that have been registered */
 245         if (tahvo_irq_subscr == filp) {
 246                 tahvo_unreg_irq_handlers();
 247                 tahvo_irq_subscr = NULL;
 248         }
 249
 250         return 0;
 251 }
 252
 253 /*
 254  * Device control (ioctl)
 255  */
 256 static int tahvo_ioctl(struct inode *inode, struct file *filp,
 257                        unsigned int cmd, unsigned long arg)
 258 {
 259         struct retu_tahvo_write_parms par;
 260         int ret;
 261
 262         switch (cmd) {
 263         case URT_IOCT_IRQ_SUBSCR:
 264                 return tahvo_user_subscribe_to_irq(arg, filp);
 265         case TAHVO_IOCH_READ:
 266                 return tahvo_user_read_with_mask(arg);
 267         case TAHVO_IOCX_WRITE:
 268                 ret = copy_from_user(&par, (void __user *) arg, sizeof(par));
 269                 if (ret)
 270                         printk(KERN_ERR "copy_from_user failed: %d\n", ret);
 271                 par.result = tahvo_user_write_with_mask(par.field, par.value);
 272                 ret = copy_to_user((void __user *) arg, &par, sizeof(par));
 273                 if (ret)
 274                         printk(KERN_ERR "copy_to_user failed: %d\n", ret);
 275                 break;
 276         default:
 277                 return -ENOIOCTLCMD;
 278         }
 279         return 0;
 280 }
 281
 282 /*
 283  * Read from device
 284  */
 285 static ssize_t tahvo_read(struct file *filp, char *buf, size_t count,
 286                           loff_t * offp)
 287 {
 288         struct tahvo_irq *irq;
 289
 290         u32 nr, i;
 291
 292         /* read not permitted if neither filp nor anyone has registered IRQs */
 293         if (tahvo_irq_subscr != filp)
 294                 return -EPERM;
 295
 296         if ((count < sizeof(u32)) || ((count % sizeof(u32)) != 0))
 297                 return -EINVAL;
 298
 299         nr = count / sizeof(u32);
 300
 301         for (i = 0; i < nr; i++) {
 302                 unsigned long flags;
 303                 u32 irq_id;
 304                 int ret;
 305
 306                 ret = wait_event_interruptible(tahvo_user_waitqueue,
 307                                                !list_empty(&tahvo_irqs));
 308                 if (ret < 0)
 309                         return ret;
 310
 311                 spin_lock_irqsave(&tahvo_irqs_lock, flags);
 312                 irq = list_entry((&tahvo_irqs)->next, struct tahvo_irq, node);
 313                 irq_id = irq->id;
 314                 list_move(&irq->node, &tahvo_irqs_reserve);
 315                 spin_unlock_irqrestore(&tahvo_irqs_lock, flags);
 316
 317                 ret = copy_to_user(buf + i * sizeof(irq_id), &irq_id,
 318                                   sizeof(irq_id));
 319                 if (ret)
 320                         printk(KERN_ERR "copy_to_user failed: %d\n", ret);
 321         }
 322
 323         return count;
 324 }
 325
 326 /*
 327  * Poll method
 328  */
 329 static unsigned tahvo_poll(struct file *filp, struct poll_table_struct *pt)
 330 {
 331         if (!list_empty(&tahvo_irqs))
 332                 return POLLIN;
 333
 334         poll_wait(filp, &tahvo_user_waitqueue, pt);
 335
 336         if (!list_empty(&tahvo_irqs))
 337                 return POLLIN;
 338         else
 339                 return 0;
 340 }
 341
 342 static struct file_operations tahvo_user_fileops = {
 343         .owner = THIS_MODULE,
 344         .ioctl = tahvo_ioctl,
 345         .read = tahvo_read,
 346         .release = tahvo_close,
 347         .poll = tahvo_poll
 348 };
 349
 350 static struct miscdevice tahvo_device = {
 351         .minor = MISC_DYNAMIC_MINOR,
 352         .name = "tahvo",
 353         .fops = &tahvo_user_fileops
 354 };
 355
 356 /*
 357  * Initialization
 358  *
 359  * @return 0 if successful, error value otherwise.
 360  */
 361 int tahvo_user_init(void)
 362 {
 363         struct tahvo_irq *irq;
 364         int res, i;
 365
 366         irq = kmalloc(sizeof(*irq) * TAHVO_MAX_IRQ_BUF_LEN, GFP_KERNEL);
 367         if (irq == NULL) {
 368                 printk(KERN_ERR PFX "kmalloc failed\n");
 369                 return -ENOMEM;
 370         }
 371         memset(irq, 0, sizeof(*irq) * TAHVO_MAX_IRQ_BUF_LEN);
 372         for (i = 0; i < TAHVO_MAX_IRQ_BUF_LEN; i++)
 373                 list_add(&irq[i].node, &tahvo_irqs_reserve);
 374
 375         tahvo_irq_block = irq;
 376
 377         spin_lock_init(&tahvo_irqs_lock);
 378         mutex_init(&tahvo_mutex);
 379
 380         /* Request a misc device */
 381         res = misc_register(&tahvo_device);
 382         if (res < 0) {
 383                 printk(KERN_ERR PFX "unable to register misc device for %s\n",
 384                        tahvo_device.name);
 385                 kfree(irq);
 386                 return res;
 387         }
 388
 389         return 0;
 390 }
 391
 392 /*
 393  * Cleanup.
 394  */
 395 void tahvo_user_cleanup(void)
 396 {
 397         /* Unregister our misc device */
 398         misc_deregister(&tahvo_device);
 399         /* Unregister and disable all TAHVO interrupts */
 400         tahvo_unreg_irq_handlers();
 401         kfree(tahvo_irq_block);
 402 }
 403
 404 MODULE_DESCRIPTION("Tahvo ASIC user space functions");
 405 MODULE_LICENSE("GPL");
 406 MODULE_AUTHOR("Mikko Ylinen");