drivers/cbus/retu-user.c

   1 /**
   2  * drivers/cbus/retu-user.c
   3  *
   4  * Retu 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 "retu.h"
  40
  41 #include "user_retu_tahvo.h"
  42
  43 /* Maximum size of IRQ node buffer/pool */
  44 #define RETU_MAX_IRQ_BUF_LEN    16
  45
  46 #define PFX                     "retu-user: "
  47
  48 /* Bitmap for marking the interrupt sources as having the handlers */
  49 static u32 retu_irq_bits;
  50
  51 /* For allowing only one user process to subscribe to the retu interrupts */
  52 static struct file *retu_irq_subscr = NULL;
  53
  54 /* For poll and IRQ passing */
  55 struct retu_irq {
  56         u32 id;
  57         struct list_head node;
  58 };
  59
  60 static spinlock_t retu_irqs_lock;
  61 static struct retu_irq *retu_irq_block;
  62 static LIST_HEAD(retu_irqs);
  63 static LIST_HEAD(retu_irqs_reserve);
  64
  65 /* Wait queue - used when user wants to read the device */
  66 DECLARE_WAIT_QUEUE_HEAD(retu_user_waitqueue);
  67
  68 /* Semaphore to protect irq subscription sequence */
  69 static struct mutex retu_mutex;
  70
  71 /* This array specifies RETU register types (read/write/toggle) */
  72 static const u8 retu_access_bits[] = {
  73         1,
  74         4,
  75         3,
  76         3,
  77         1,
  78         3,
  79         3,
  80         0,
  81         3,
  82         3,
  83         3,
  84         3,
  85         3,
  86         3,
  87         3,
  88         4,
  89         4,
  90         3,
  91         0,
  92         0,
  93         0,
  94         0,
  95         1,
  96         3,
  97         3,
  98         3,
  99         3,
 100         3,
 101         3,
 102         3,
 103         3,
 104         3
 105 };
 106
 107 /*
 108  * The handler for all RETU interrupts.
 109  *
 110  * arg is the interrupt source in RETU.
 111  */
 112 static void retu_user_irq_handler(unsigned long arg)
 113 {
 114         struct retu_irq *irq;
 115
 116         retu_ack_irq(arg);
 117
 118         spin_lock(&retu_irqs_lock);
 119         if (list_empty(&retu_irqs_reserve)) {
 120                 spin_unlock(&retu_irqs_lock);
 121                 return;
 122         }
 123         irq = list_entry((&retu_irqs_reserve)->next, struct retu_irq, node);
 124         irq->id = arg;
 125         list_move_tail(&irq->node, &retu_irqs);
 126         spin_unlock(&retu_irqs_lock);
 127
 128         /* wake up waiting thread */
 129         wake_up(&retu_user_waitqueue);
 130 }
 131
 132 /*
 133  * This routine sets up the interrupt handler and marks an interrupt source
 134  * in RETU as a candidate for signal delivery to the user process.
 135  */
 136 static int retu_user_subscribe_to_irq(int id, struct file *filp)
 137 {
 138         int ret;
 139
 140         mutex_lock(&retu_mutex);
 141         if ((retu_irq_subscr != NULL) && (retu_irq_subscr != filp)) {
 142                 mutex_unlock(&retu_mutex);
 143                 return -EBUSY;
 144         }
 145         /* Store the file pointer of the first user process registering IRQs */
 146         retu_irq_subscr = filp;
 147         mutex_unlock(&retu_mutex);
 148
 149         if (retu_irq_bits & (1 << id))
 150                 return 0;
 151
 152         ret = retu_request_irq(id, retu_user_irq_handler, id, "");
 153         if (ret < 0)
 154                 return ret;
 155
 156         /* Mark that this interrupt has a handler */
 157         retu_irq_bits |= 1 << id;
 158
 159         return 0;
 160 }
 161
 162 /*
 163  * Unregisters all RETU interrupt handlers.
 164  */
 165 static void retu_unreg_irq_handlers(void)
 166 {
 167         int id;
 168
 169         if (!retu_irq_bits)
 170                 return;
 171
 172         for (id = 0; id < MAX_RETU_IRQ_HANDLERS; id++)
 173                 if (retu_irq_bits & (1 << id))
 174                         retu_free_irq(id);
 175
 176         retu_irq_bits = 0;
 177 }
 178
 179 /*
 180  * Write to RETU register.
 181  * Returns 0 upon success, a negative error value otherwise.
 182  */
 183 static int retu_user_write_with_mask(u32 field, u16 value)
 184 {
 185         u32 mask;
 186         u32 reg;
 187         u_short tmp;
 188         unsigned long flags;
 189
 190         mask = MASK(field);
 191         reg = REG(field);
 192
 193         /* Detect bad mask and reg */
 194         if (mask == 0 || reg > RETU_REG_MAX ||
 195             retu_access_bits[reg] == READ_ONLY) {
 196                 printk(KERN_ERR PFX "invalid arguments (reg=%#x, mask=%#x)\n",
 197                        reg, mask);
 198                 return -EINVAL;
 199         }
 200
 201         /* Justify value according to mask */
 202         while (!(mask & 1)) {
 203                 value = value << 1;
 204                 mask = mask >> 1;
 205         }
 206
 207         spin_lock_irqsave(&retu_lock, flags);
 208         if (retu_access_bits[reg] == TOGGLE) {
 209                 /* No need to detect previous content of register */
 210                 tmp = 0;
 211         } else {
 212                 /* Read current value of register */
 213                 tmp = retu_read_reg(reg);
 214         }
 215
 216         /* Generate new value */
 217         tmp = (tmp & ~MASK(field)) | (value & MASK(field));
 218         /* Write data to RETU */
 219         retu_write_reg(reg, tmp);
 220         spin_unlock_irqrestore(&retu_lock, flags);
 221
 222         return 0;
 223 }
 224
 225 /*
 226  * Read RETU register.
 227  */
 228 static u32 retu_user_read_with_mask(u32 field)
 229 {
 230         u_short value;
 231         u32 mask, reg;
 232
 233         mask = MASK(field);
 234         reg = REG(field);
 235
 236         /* Detect bad mask and reg */
 237         if (mask == 0 || reg > RETU_REG_MAX) {
 238                 printk(KERN_ERR PFX "invalid arguments (reg=%#x, mask=%#x)\n",
 239                        reg, mask);
 240                 return -EINVAL;
 241         }
 242
 243         /* Read the register */
 244         value = retu_read_reg(reg) & mask;
 245
 246         /* Right justify value */
 247         while (!(mask & 1)) {
 248                 value = value >> 1;
 249                 mask = mask >> 1;
 250         }
 251
 252         return value;
 253 }
 254
 255 /*
 256  * Close device
 257  */
 258 static int retu_close(struct inode *inode, struct file *filp)
 259 {
 260         /* Unregister all interrupts that have been registered */
 261         if (retu_irq_subscr == filp) {
 262                 retu_unreg_irq_handlers();
 263                 retu_irq_subscr = NULL;
 264         }
 265
 266         return 0;
 267 }
 268
 269 /*
 270  * Device control (ioctl)
 271  */
 272 static int retu_ioctl(struct inode *inode, struct file *filp,
 273                       unsigned int cmd, unsigned long arg)
 274 {
 275         struct retu_tahvo_write_parms par;
 276         int ret;
 277
 278         switch (cmd) {
 279         case URT_IOCT_IRQ_SUBSCR:
 280                 return retu_user_subscribe_to_irq(arg, filp);
 281         case RETU_IOCH_READ:
 282                 return retu_user_read_with_mask(arg);
 283         case RETU_IOCX_WRITE:
 284                 ret = copy_from_user(&par, (void __user *) arg, sizeof(par));
 285                 if (ret)
 286                         printk(KERN_ERR "copy_from_user failed: %d\n", ret);
 287                 par.result = retu_user_write_with_mask(par.field, par.value);
 288                 ret = copy_to_user((void __user *) arg, &par, sizeof(par));
 289                 if (ret)
 290                         printk(KERN_ERR "copy_to_user failed: %d\n", ret);
 291                 break;
 292         case RETU_IOCH_ADC_READ:
 293                 return retu_read_adc(arg);
 294         default:
 295                 return -ENOIOCTLCMD;
 296         }
 297         return 0;
 298 }
 299
 300 /*
 301  * Read from device
 302  */
 303 static ssize_t retu_read(struct file *filp, char *buf, size_t count,
 304                          loff_t * offp)
 305 {
 306         struct retu_irq *irq;
 307
 308         u32 nr, i;
 309
 310         /* read not permitted if neither filp nor anyone has registered IRQs */
 311         if (retu_irq_subscr != filp)
 312                 return -EPERM;
 313
 314         if ((count < sizeof(u32)) || ((count % sizeof(u32)) != 0))
 315                 return -EINVAL;
 316
 317         nr = count / sizeof(u32);
 318
 319         for (i = 0; i < nr; i++) {
 320                 unsigned long flags;
 321                 u32 irq_id;
 322                 int ret;
 323
 324                 ret = wait_event_interruptible(retu_user_waitqueue,
 325                                                !list_empty(&retu_irqs));
 326                 if (ret < 0)
 327                         return ret;
 328
 329                 spin_lock_irqsave(&retu_irqs_lock, flags);
 330                 irq = list_entry((&retu_irqs)->next, struct retu_irq, node);
 331                 irq_id = irq->id;
 332                 list_move(&irq->node, &retu_irqs_reserve);
 333                 spin_unlock_irqrestore(&retu_irqs_lock, flags);
 334
 335                 ret = copy_to_user(buf + i * sizeof(irq_id), &irq_id,
 336                                    sizeof(irq_id));
 337                 if (ret)
 338                         printk(KERN_ERR "copy_to_user failed: %d\n", ret);
 339         }
 340
 341         return count;
 342 }
 343
 344 /*
 345  * Poll method
 346  */
 347 static unsigned retu_poll(struct file *filp, struct poll_table_struct *pt)
 348 {
 349         if (!list_empty(&retu_irqs))
 350                 return POLLIN;
 351
 352         poll_wait(filp, &retu_user_waitqueue, pt);
 353
 354         if (!list_empty(&retu_irqs))
 355                 return POLLIN;
 356         else
 357                 return 0;
 358 }
 359
 360 static struct file_operations retu_user_fileops = {
 361         .owner = THIS_MODULE,
 362         .ioctl = retu_ioctl,
 363         .read = retu_read,
 364         .release = retu_close,
 365         .poll = retu_poll
 366 };
 367
 368 static struct miscdevice retu_device = {
 369         .minor = MISC_DYNAMIC_MINOR,
 370         .name = "retu",
 371         .fops = &retu_user_fileops
 372 };
 373
 374 /*
 375  * Initialization
 376  *
 377  * @return 0 if successful, error value otherwise.
 378  */
 379 int retu_user_init(void)
 380 {
 381         struct retu_irq *irq;
 382         int res, i;
 383
 384         irq = kmalloc(sizeof(*irq) * RETU_MAX_IRQ_BUF_LEN, GFP_KERNEL);
 385         if (irq == NULL) {
 386                 printk(KERN_ERR PFX "kmalloc failed\n");
 387                 return -ENOMEM;
 388         }
 389         memset(irq, 0, sizeof(*irq) * RETU_MAX_IRQ_BUF_LEN);
 390         for (i = 0; i < RETU_MAX_IRQ_BUF_LEN; i++)
 391                 list_add(&irq[i].node, &retu_irqs_reserve);
 392
 393         retu_irq_block = irq;
 394
 395         spin_lock_init(&retu_irqs_lock);
 396         mutex_init(&retu_mutex);
 397
 398         /* Request a misc device */
 399         res = misc_register(&retu_device);
 400         if (res < 0) {
 401                 printk(KERN_ERR PFX "unable to register misc device for %s\n",
 402                        retu_device.name);
 403                 kfree(irq);
 404                 return res;
 405         }
 406
 407         return 0;
 408 }
 409
 410 /*
 411  * Cleanup.
 412  */
 413 void retu_user_cleanup(void)
 414 {
 415         /* Unregister our misc device */
 416         misc_deregister(&retu_device);
 417         /* Unregister and disable all RETU interrupts used by this module */
 418         retu_unreg_irq_handlers();
 419         kfree(retu_irq_block);
 420 }
 421
 422 MODULE_DESCRIPTION("Retu ASIC user space functions");
 423 MODULE_LICENSE("GPL");
 424 MODULE_AUTHOR("Mikko Ylinen");