1/* 2 * LIRC base driver 3 * 4 * by Artur Lipowski <alipowski@interia.pl> 5 * This code is licensed under GNU GPL 6 * 7 */ 8 9#ifndef _LINUX_LIRC_DEV_H 10#define _LINUX_LIRC_DEV_H 11 12#define MAX_IRCTL_DEVICES 4 13#define BUFLEN 16 14 15#define mod(n, div) ((n) % (div)) 16 17#include <linux/slab.h> 18#include <linux/fs.h> 19#include <linux/ioctl.h> 20#include <linux/poll.h> 21#include <linux/kfifo.h> 22#include <media/lirc.h> 23 24struct lirc_buffer { 25 wait_queue_head_t wait_poll; 26 spinlock_t fifo_lock; 27 unsigned int chunk_size; 28 unsigned int size; /* in chunks */ 29 /* Using chunks instead of bytes pretends to simplify boundary checking 30 * And should allow for some performance fine tunning later */ 31 struct kfifo fifo; 32 u8 fifo_initialized; 33}; 34 35static inline void lirc_buffer_clear(struct lirc_buffer *buf) 36{ 37 unsigned long flags; 38 39 if (buf->fifo_initialized) { 40 spin_lock_irqsave(&buf->fifo_lock, flags); 41 kfifo_reset(&buf->fifo); 42 spin_unlock_irqrestore(&buf->fifo_lock, flags); 43 } else 44 WARN(1, "calling %s on an uninitialized lirc_buffer\n", 45 __func__); 46} 47 48static inline int lirc_buffer_init(struct lirc_buffer *buf, 49 unsigned int chunk_size, 50 unsigned int size) 51{ 52 int ret; 53 54 init_waitqueue_head(&buf->wait_poll); 55 spin_lock_init(&buf->fifo_lock); 56 buf->chunk_size = chunk_size; 57 buf->size = size; 58 ret = kfifo_alloc(&buf->fifo, size * chunk_size, GFP_KERNEL); 59 if (ret == 0) 60 buf->fifo_initialized = 1; 61 62 return ret; 63} 64 65static inline void lirc_buffer_free(struct lirc_buffer *buf) 66{ 67 if (buf->fifo_initialized) { 68 kfifo_free(&buf->fifo); 69 buf->fifo_initialized = 0; 70 } else 71 WARN(1, "calling %s on an uninitialized lirc_buffer\n", 72 __func__); 73} 74 75static inline int lirc_buffer_len(struct lirc_buffer *buf) 76{ 77 int len; 78 unsigned long flags; 79 80 spin_lock_irqsave(&buf->fifo_lock, flags); 81 len = kfifo_len(&buf->fifo); 82 spin_unlock_irqrestore(&buf->fifo_lock, flags); 83 84 return len; 85} 86 87static inline int lirc_buffer_full(struct lirc_buffer *buf) 88{ 89 return lirc_buffer_len(buf) == buf->size * buf->chunk_size; 90} 91 92static inline int lirc_buffer_empty(struct lirc_buffer *buf) 93{ 94 return !lirc_buffer_len(buf); 95} 96 97static inline int lirc_buffer_available(struct lirc_buffer *buf) 98{ 99 return buf->size - (lirc_buffer_len(buf) / buf->chunk_size); 100} 101 102static inline unsigned int lirc_buffer_read(struct lirc_buffer *buf, 103 unsigned char *dest) 104{ 105 unsigned int ret = 0; 106 107 if (lirc_buffer_len(buf) >= buf->chunk_size) 108 ret = kfifo_out_locked(&buf->fifo, dest, buf->chunk_size, 109 &buf->fifo_lock); 110 return ret; 111 112} 113 114static inline unsigned int lirc_buffer_write(struct lirc_buffer *buf, 115 unsigned char *orig) 116{ 117 unsigned int ret; 118 119 ret = kfifo_in_locked(&buf->fifo, orig, buf->chunk_size, 120 &buf->fifo_lock); 121 122 return ret; 123} 124 125struct lirc_driver { 126 char name[40]; 127 int minor; 128 unsigned long code_length; 129 unsigned int buffer_size; /* in chunks holding one code each */ 130 int sample_rate; 131 unsigned long features; 132 133 unsigned int chunk_size; 134 135 void *data; 136 int min_timeout; 137 int max_timeout; 138 int (*add_to_buf) (void *data, struct lirc_buffer *buf); 139 struct lirc_buffer *rbuf; 140 int (*set_use_inc) (void *data); 141 void (*set_use_dec) (void *data); 142 struct file_operations *fops; 143 struct device *dev; 144 struct module *owner; 145}; 146 147/* name: 148 * this string will be used for logs 149 * 150 * minor: 151 * indicates minor device (/dev/lirc) number for registered driver 152 * if caller fills it with negative value, then the first free minor 153 * number will be used (if available) 154 * 155 * code_length: 156 * length of the remote control key code expressed in bits 157 * 158 * sample_rate: 159 * 160 * data: 161 * it may point to any driver data and this pointer will be passed to 162 * all callback functions 163 * 164 * add_to_buf: 165 * add_to_buf will be called after specified period of the time or 166 * triggered by the external event, this behavior depends on value of 167 * the sample_rate this function will be called in user context. This 168 * routine should return 0 if data was added to the buffer and 169 * -ENODATA if none was available. This should add some number of bits 170 * evenly divisible by code_length to the buffer 171 * 172 * rbuf: 173 * if not NULL, it will be used as a read buffer, you will have to 174 * write to the buffer by other means, like irq's (see also 175 * lirc_serial.c). 176 * 177 * set_use_inc: 178 * set_use_inc will be called after device is opened 179 * 180 * set_use_dec: 181 * set_use_dec will be called after device is closed 182 * 183 * fops: 184 * file_operations for drivers which don't fit the current driver model. 185 * 186 * Some ioctl's can be directly handled by lirc_dev if the driver's 187 * ioctl function is NULL or if it returns -ENOIOCTLCMD (see also 188 * lirc_serial.c). 189 * 190 * owner: 191 * the module owning this struct 192 * 193 */ 194 195 196/* following functions can be called ONLY from user context 197 * 198 * returns negative value on error or minor number 199 * of the registered device if success 200 * contents of the structure pointed by p is copied 201 */ 202extern int lirc_register_driver(struct lirc_driver *d); 203 204/* returns negative value on error or 0 if success 205*/ 206extern int lirc_unregister_driver(int minor); 207 208/* Returns the private data stored in the lirc_driver 209 * associated with the given device file pointer. 210 */ 211void *lirc_get_pdata(struct file *file); 212 213/* default file operations 214 * used by drivers if they override only some operations 215 */ 216int lirc_dev_fop_open(struct inode *inode, struct file *file); 217int lirc_dev_fop_close(struct inode *inode, struct file *file); 218unsigned int lirc_dev_fop_poll(struct file *file, poll_table *wait); 219long lirc_dev_fop_ioctl(struct file *file, unsigned int cmd, unsigned long arg); 220ssize_t lirc_dev_fop_read(struct file *file, char *buffer, size_t length, 221 loff_t *ppos); 222ssize_t lirc_dev_fop_write(struct file *file, const char *buffer, size_t length, 223 loff_t *ppos); 224 225#endif 226