APR_DECLARE(void) apr_atomic_set32(volatile apr_uint32_t *mem, apr_uint32_t val)
{
DECLARE_MUTEX_LOCKED(mutex, mem);
*mem = val;
MUTEX_UNLOCK(mutex);
}
void harness_block(void)
{
#ifdef __KERNEL__
DECLARE_MUTEX_LOCKED(sem);
down_interruptible(&sem);
#else
sem_t sem;
sem_init(&sem, 0, 0);
sem_wait(&sem);
#endif
}
int lirc_unregister_plugin(int minor)
{
struct irctl *ir;
DECLARE_MUTEX_LOCKED(tn);
if (minor < 0 || minor >= MAX_IRCTL_DEVICES) {
printk("lirc_dev: lirc_unregister_plugin:"
"\" minor\" must be beetween 0 and %d!\n",
MAX_IRCTL_DEVICES-1);
return -EBADRQC;
}
ir = &irctls[minor];
down_interruptible(&plugin_lock);
if (ir->p.minor != minor) {
printk("lirc_dev: lirc_unregister_plugin:"
"minor (%d) device not registered!", minor);
up(&plugin_lock);
return -ENOENT;
}
if (ir->open) {
printk("lirc_dev: lirc_unregister_plugin:"
"plugin %s[%d] in use!", ir->p.name, ir->p.minor);
up(&plugin_lock);
return -EBUSY;
}
/* end up polling thread */
if (ir->tpid >= 0) {
ir->t_notify = &tn;
ir->shutdown = 1;
down(&tn);
ir->t_notify = NULL;
}
dprintk("lirc_dev: plugin %s unregistered from minor number = %d\n",
ir->p.name, ir->p.minor);
#ifdef LIRC_HAVE_DEVFS
devfs_unregister(ir->devfs_handle);
#endif
init_irctl(ir);
up(&plugin_lock);
MOD_DEC_USE_COUNT;
return SUCCESS;
}
APR_DECLARE(apr_uint32_t) apr_atomic_add32(volatile apr_uint32_t *mem, apr_uint32_t val)
{
apr_uint32_t old_value;
DECLARE_MUTEX_LOCKED(mutex, mem);
old_value = *mem;
*mem += val;
MUTEX_UNLOCK(mutex);
return old_value;
}
static int proc_viopath_show(struct seq_file *m, void *v)
{
char *buf;
u16 vlanMap;
dma_addr_t handle;
HvLpEvent_Rc hvrc;
DECLARE_MUTEX_LOCKED(Semaphore);
buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
if (!buf)
return 0;
memset(buf, 0, PAGE_SIZE);
handle = dma_map_single(iSeries_vio_dev, buf, PAGE_SIZE,
DMA_FROM_DEVICE);
hvrc = HvCallEvent_signalLpEventFast(viopath_hostLp,
HvLpEvent_Type_VirtualIo,
viomajorsubtype_config | vioconfigget,
HvLpEvent_AckInd_DoAck, HvLpEvent_AckType_ImmediateAck,
viopath_sourceinst(viopath_hostLp),
viopath_targetinst(viopath_hostLp),
(u64)(unsigned long)&Semaphore, VIOVERSION << 16,
((u64)handle) << 32, PAGE_SIZE, 0, 0);
if (hvrc != HvLpEvent_Rc_Good)
printk(VIOPATH_KERN_WARN "hv error on op %d\n", (int)hvrc);
down(&Semaphore);
vlanMap = HvLpConfig_getVirtualLanIndexMap();
buf[PAGE_SIZE-1] = '\0';
seq_printf(m, "%s", buf);
seq_printf(m, "AVAILABLE_VETH=%x\n", vlanMap);
seq_printf(m, "SRLNBR=%c%c%c%c%c%c%c\n",
e2a(xItExtVpdPanel.mfgID[2]),
e2a(xItExtVpdPanel.mfgID[3]),
e2a(xItExtVpdPanel.systemSerial[1]),
e2a(xItExtVpdPanel.systemSerial[2]),
e2a(xItExtVpdPanel.systemSerial[3]),
e2a(xItExtVpdPanel.systemSerial[4]),
e2a(xItExtVpdPanel.systemSerial[5]));
dma_unmap_single(iSeries_vio_dev, handle, PAGE_SIZE, DMA_FROM_DEVICE);
kfree(buf);
return 0;
}
int lirc_register_plugin(struct lirc_plugin *p)
{
struct irctl *ir;
int minor;
#ifdef LIRC_HAVE_DEVFS
char name[16];
#endif
DECLARE_MUTEX_LOCKED(tn);
if (!p) {
printk("lirc_dev: lirc_register_plugin:"
"plugin pointer must be not NULL!\n");
return -EBADRQC;
}
if (MAX_IRCTL_DEVICES <= p->minor) {
printk("lirc_dev: lirc_register_plugin:"
"\" minor\" must be beetween 0 and %d (%d)!\n",
MAX_IRCTL_DEVICES-1, p->minor);
return -EBADRQC;
}
if (1 > p->code_length || (BUFLEN*8) < p->code_length) {
printk("lirc_dev: lirc_register_plugin:"
"code length in bits for minor (%d) "
"must be less than %d!\n",
p->minor, BUFLEN*8);
return -EBADRQC;
}
if (p->sample_rate) {
if (2 > p->sample_rate || 50 < p->sample_rate) {
printk("lirc_dev: lirc_register_plugin:"
"sample_rate must be beetween 2 and 50!\n");
return -EBADRQC;
}
} else {
if (!p->get_queue) {
printk("lirc_dev: lirc_register_plugin:"
"get_queue cannot be NULL!\n");
return -EBADRQC;
}
}
down_interruptible(&plugin_lock);
minor = p->minor;
if (0 > minor) {
/* find first free slot for plugin */
for (minor=0; minor<MAX_IRCTL_DEVICES; minor++)
if (irctls[minor].p.minor == NOPLUG)
break;
if (MAX_IRCTL_DEVICES == minor) {
printk("lirc_dev: lirc_register_plugin: "
"no free slots for plugins!\n");
up(&plugin_lock);
return -ENOMEM;
}
} else if (irctls[minor].p.minor != NOPLUG) {
printk("lirc_dev: lirc_register_plugin:"
"minor (%d) just registerd!\n", minor);
up(&plugin_lock);
return -EBUSY;
}
ir = &irctls[minor];
if (p->sample_rate) {
ir->jiffies_to_wait = HZ / p->sample_rate;
} else {
/* it means - wait for externeal event in task queue */
ir->jiffies_to_wait = 0;
}
/* some safety check 8-) */
p->name[sizeof(p->name)-1] = '\0';
ir->bytes_in_key = p->code_length/8 + (p->code_length%8 ? 1 : 0);
/* this simplifies boundary checking during buffer access */
ir->buf_len = BUFLEN - (BUFLEN%ir->bytes_in_key);
ir->features = (p->code_length > 8) ?
LIRC_CAN_REC_LIRCCODE : LIRC_CAN_REC_CODE;
ir->p = *p;
ir->p.minor = minor;
#ifdef LIRC_HAVE_DEVFS
sprintf (name, DEV_LIRC "/%d", ir->p.minor);
ir->devfs_handle = devfs_register(NULL, name, DEVFS_FL_DEFAULT,
IRCTL_DEV_MAJOR, ir->p.minor,
S_IFCHR | S_IRUSR | S_IWUSR,
&fops, NULL);
#endif
/* try to fire up polling thread */
ir->t_notify = &tn;
ir->tpid = kernel_thread(lirc_thread, (void*)ir, 0);
if (ir->tpid < 0) {
IRUNLOCK;
up(&plugin_lock);
printk("lirc_dev: lirc_register_plugin:"
"cannot run poll thread for minor = %d\n", p->minor);
return -ECHILD;
}
down(&tn);
ir->t_notify = NULL;
up(&plugin_lock);
MOD_INC_USE_COUNT;
dprintk("lirc_dev: plugin %s registered at minor number = %d\n",
ir->p.name, ir->p.minor);
return minor;
}
