bkgpl/cyb4_linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
cyb4_linux/drivers/input/keyboard/cyio.c

941 lines
24 KiB
C
Raw Blame History

// ===========================================================================
// cyio.c
// Copyright (C) 2008-2009 Bookeen - All rights reserved
// ===========================================================================
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/poll.h>
#include <linux/sched.h>
#include <linux/wait.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/pm.h>
#include <cybook.h>
#include "cyio.h"
//#define CYIO_TIMER
#define CYIO_REPEAT
#define CYIO_ALTERNATE_KEY
#define DEBUG_MESSAGES
#define DBG_IRQ
#include <asm/hardware.h>
#include <asm/delay.h>
#include <asm/uaccess.h>
#include <asm-arm/irq.h>
#include <asm/arch/gpio.h>
#include <asm/arch/regs-gpio.h>
#include <asm/arch/regs-irq.h>
#include <asm-arm/arch-s3c2410/irqs.h>
#include <asm-arm/arch-s3c2410/gpio.h>
#include <linux/irq.h>
#include <linux/platform_device.h>
// ===========================================================================
spinlock_t io_lock = SPIN_LOCK_UNLOCKED;
static unsigned long io_status = 0;
struct task_struct *ptsk = 0;
unsigned int platform_type = CYBOOK_GEN4;
#ifdef CYIO_TIMER
#define IO_TIMER_DELAY_1 ((HZ * 1) / 2) /* 500 ms */
#define IO_TIMER_DELAY_2 ((HZ * 2) / 1) /* 2 s */
#define IO_TIMER_DELAY_3 ((HZ * 1) / 1) /* 1 s */
static struct timer_list io_timer;
static int timer_inited = 0;
static int timer_run = 0;
#endif
#define TRUE (1==1)
#define FALSE (0==1)
#define PFX "CyIO:"
typedef struct _cyIrq_
{
int nIrq;
u32 nGpio;
u8 bActive;
u8 bKeyIrq; // IRQ generated by a key?
u8 bIsAltKey;
u8 nCodeActive; // All interrupts generate a code when active
u8 nCodeInactive; // Some interrupts generate a code when inactive
u8 nCodeAlternate;
char* sName;
} cyIrq;
typedef struct _cyEvent_
{
u8 nCode;
u8 nKeyEvent;
void* pNext;
} cyEvent;
static cyEvent s_nEvents[10];
static int s_nEventMax = sizeof(s_nEvents)/sizeof(s_nEvents[0]);
static int s_nEventCnt = 0;
static int s_nKeyLogMax = 1;
static int s_nKeyLogCnt = 0;
static cyEvent* s_pEventR = 0;
static cyEvent* s_pEventW = 0;
#ifdef CYIO_REPEAT
static u8 s_nPrevKey = 0;
static u8 s_bRepMode = 0;
#endif
#ifdef CYIO_ALTERNATE_KEY
static u8 s_altKeyPress = 0;
static u32 s_altKeyGpio = 0;
static u8 s_altKeyPresent = FALSE; /* By default we don't have a Alt Key */
#endif
#define GPIO_F0 S3C2410_GPF0
#define GPIO_F1 S3C2410_GPF1
#define GPIO_F2 S3C2410_GPF2
#define GPIO_F3 S3C2410_GPF3
#define GPIO_F4 S3C2410_GPF4
#define GPIO_F5 S3C2410_GPF5
#define GPIO_F6 S3C2410_GPF6
#define GPIO_F7 S3C2410_GPF7
#define GPIO_F8 S3C2410_GPF8
#define GPIO_F9 S3C2410_GPF9
#define GPIO_F10 S3C2410_GPF10
#define GPIO_G0 S3C2410_GPG0
#define GPIO_G1 S3C2410_GPG1
#define GPIO_G2 S3C2410_GPG2
#define GPIO_G3 S3C2410_GPG3
#define GPIO_G4 S3C2410_GPG4
#define GPIO_G5 S3C2410_GPG5
#define GPIO_G6 S3C2410_GPG6
#define GPIO_G7 S3C2410_GPG7
#define GPIO_G8 S3C2410_GPG8
#define GPIO_G9 S3C2410_GPG9
static cyIrq *s_nIrq ;
static int nCnt;
static cyIrq s_nIrq_GEN4[] =
{ /* Event structure for the Cybook Gen3 (2440) */
/* IRQ GPIO A B C Depress Event Release Event Alt Event Name Number */
{ IRQ_EINT0, GPIO_F0, 0, 1, 0, CYEVENT_KEY_OFF, 0, 0, "PowerBtn" } //0
//, { IRQ_EINT1, GPIO_F1, 0, 0, 0, CYEVENT_SD_IN, CYEVENT_SD_OUT, 0, "SD Card" } //1
//, { IRQ_EINT2, GPIO_F2, 0, 0, 0, CYEVENT_TP_PRESS, CYEVENT_TP_REL, 0, "Touch Panel" } //2
//
/* EINT3 is not Wifi EINT */
/* EINT4 is Headphone plug status */
/* EINT5 is Touchpanel Enable */
/* EINT6 is charger status */
, { IRQ_EINT7, GPIO_F7, 0, 1, 0, CYEVENT_KEY_LEFT, 0, 0, "Left" } //3
/* INT8 is Power Keey???? */
//, { IRQ_EINT9, GPIO_G1, 0, 0, 0, CYEVENT_USB_IN, CYEVENT_USB_OUT, 0, "USB" } //4
/* EINT10 is SD power enable */
, { IRQ_EINT15, GPIO_G7, 0, 1, 0, CYEVENT_KEY_RIGHT, 0, 0, "Right" } //5
/* IRQ GPIO A B C Depress Event Release Event Alt Event Name Number */
/* A:Reserved (must be 0) - B: Is Keypress Event? (or Allow Repeat?) (1: Yes, 0: No) - C: Is Alt Key? (1: Yes 0: No) */
};
static u8* s_pbUsbPowered = NULL;
static u8* s_pbAcPowered = NULL;
static u8* s_pbPowerOff = NULL;
static u8* s_pbVolMinus = NULL;
static irqreturn_t io_interrupt(int irq, void *dev_id);
#ifdef CYIO_TIMER
static void io_timer_handler(unsigned long nData);
#endif
#undef MSG
#undef DBG
#ifdef DEBUG_MESSAGES
#define MSG(str) { printk(KERN_ALERT str "\n"); }
#define DBG(str, ...) { printk(KERN_ALERT str "\n", __VA_ARGS__); }
#else
#define MSG(str)
#define DBG(str, ...)
#endif
//#define DEBUG_SPINLOCK
#ifdef DEBUG_SPINLOCK
#define spinLock(spin) {\
printk(KERN_ALERT ")))))))))))) (%s:%d) Wait for %p\n", __func__, __LINE__, spin);\
spin_lock(spin); \
printk(KERN_ALERT ")))))))))))) (%s:%d) Gain %p\n", __func__, __LINE__, spin);\
}
#define spinUnlock(spin) {\
printk(KERN_ALERT ")))))))))))) (%s:%d) Free %p\n", __func__, __LINE__, spin);\
spin_unlock(spin);\
}
#else
#define spinLock(spin) spin_lock(spin)
#define spinUnlock(spin) spin_unlock(spin)
#endif
/* Allow other modules/driver to push cyio event */
void Cyio_PushEvent(char eventId, char unique)
{
cyEvent *pEventC;
spinLock(&io_lock);
if (unique != 0)
{
pEventC = s_pEventR;
do
{
if (pEventC->nCode == eventId)
goto exit;
pEventC = pEventC->pNext;
} while ((pEventC != s_pEventW) && (s_pEventR != s_pEventW));
}
DBG("New Pushed event '%c'\n", eventId);
if (s_pEventW)
{
++s_nEventCnt;
s_pEventW->nCode = eventId;
s_pEventW->nKeyEvent = 0;
s_pEventW = s_pEventW->pNext;
}
spinUnlock(&io_lock);
exit:
if (ptsk)
wake_up_process(ptsk);
}
EXPORT_SYMBOL(Cyio_PushEvent);
#ifdef CYIO_TIMER
/* Allow other module/driver to reset the timer event */
void Cyio_ResetTimer(void)
{
if (timer_inited == 0)
return;
if (timer_run == 0)
return;
#ifndef ALTERNATE_TIMER_CHANGE
del_timer(&io_timer);
if (io_timer.data == CYEVENT_SUSPEND_SCREEN)
{
io_timer.expires = IO_TIMER_DELAY_1;
}
else //if (io_timer.data == CYEVENT_SUSPEND_DEVICE)
{
io_timer.expires = IO_TIMER_DELAY_2 - IO_TIMER_DELAY_1;
}
io_timer.expires += jiffies;
add_timer(&io_timer);
timer_run = 1;
#else
//io_timer.expires += IO_TIMER_DELAY_3;
mod_timer(&io_timer, IO_TIMER_DELAY_3 + io_timer.expires);
#endif
}
EXPORT_SYMBOL(Cyio_ResetTimer);
#endif /* CYIO_TIMER */
// ===========================================================================
void io_initEventList(void)
{
int i;
s_pEventR = 0;
s_nEventCnt = 0;
s_nKeyLogCnt = 0;
for (i=0; i<s_nEventMax; ++i)
{
cyEvent* pEvent = &s_nEvents[i];
pEvent->nCode = 0;
pEvent->nKeyEvent = 0;
if (s_pEventR)
s_pEventR->pNext = pEvent;
s_pEventR = pEvent;
}
s_pEventR = &s_nEvents[0];
s_nEvents[s_nEventMax-1].pNext = s_pEventR;
s_pEventW = s_pEventR;
#ifdef CYIO_REPEAT
s_nPrevKey = 0;
s_bRepMode = 0;
#endif
}
// ---------------------------------------------------------------------------
u8 io_factoryPowerOff(void)
{
return (s_pbPowerOff &&
s_pbVolMinus &&
(*s_pbPowerOff) &&
(*s_pbVolMinus))
? 1
: 0;
}
// ---------------------------------------------------------------------------
void io_initIrq(void)
{
int i;
cyIrq *pIrq, *pIrq0;
int ret;
pIrq0 = &s_nIrq[0];
// Read state as fast as possible (important when resuming)
for (i=0, pIrq=pIrq0; i<nCnt; ++i, ++pIrq)
{
#if 1
pIrq->bActive = !gpio_get_value(pIrq->nGpio);
#else
int j, nUp = 0;
for (j=0; j<4; ++j)
if (gpio_get_value(pIrq->nGpio))
++nUp;
pIrq->bActive = (nUp < 2);
#endif
}
// Preparatory pass
for (i=0, pIrq=pIrq0; i<nCnt; ++i, ++pIrq)
{
switch (pIrq->nCodeActive)
{
case CYEVENT_USB_IN:
s_pbUsbPowered = &pIrq->bActive;
s_pbAcPowered = &pIrq->bActive;
break;
case CYEVENT_AC_IN:
break;
case CYEVENT_KEY_OFF:
s_pbPowerOff = &pIrq->bActive;
break;
case CYEVENT_KEY_VOLN:
s_pbVolMinus = &pIrq->bActive;
break;
}
#ifdef CYIO_ALTERNATE_KEY
if (pIrq->bIsAltKey)
{ /* If this event is configured as the Alt key, just fill the needed variables */
DBG("Found Alt key as '%s'\n", pIrq->sName);
s_altKeyPresent = TRUE;
s_altKeyGpio = pIrq->nGpio;
}
#endif
}
if (io_factoryPowerOff())
{ // Special case
spinLock(&io_lock);
if (s_pEventW)
{
++s_nEventCnt;
++s_nKeyLogCnt;
s_pEventW->nCode = CYEVENT_FACTORY_OFF;
s_pEventW->nKeyEvent = 1;
s_pEventW = s_pEventW->pNext;
}
spinUnlock(&io_lock);
}
else
{ // Register events as if they had just occurred (esp. when resuming)
spinLock(&io_lock);
for (i=0, pIrq=pIrq0; i<nCnt; ++i, ++pIrq)
{
if (!pIrq->bActive && pIrq->bKeyIrq)
continue;
if ((s_nEventMax <= s_nEventCnt) ||
(pIrq->bKeyIrq && s_nKeyLogMax <= s_nKeyLogCnt))
{
//break;
// !!! BUGBUG (we might miss system events once a key event is queued)
continue;
}
if (s_pEventW)
{
++s_nEventCnt;
if (pIrq->bKeyIrq)
++s_nKeyLogCnt;
s_pEventW->nCode = pIrq->bActive ? pIrq->nCodeActive : pIrq->nCodeInactive;
s_pEventW->nKeyEvent = pIrq->bKeyIrq;
s_pEventW = s_pEventW->pNext;
}
}
spinUnlock(&io_lock);
}
for (i=0, pIrq=pIrq0; i<nCnt; ++i, ++pIrq)
{
int nIrq = pIrq->nIrq;
set_irq_type(nIrq, IRQT_BOTHEDGE);
DBG(".. io_initIrq [%s][%c] bActive[%d]", pIrq->sName, pIrq->bActive || !pIrq->nCodeInactive ? (char)pIrq->nCodeActive : (char)pIrq->nCodeInactive, pIrq->bActive);
ret = request_irq(nIrq, io_interrupt, SA_INTERRUPT|SA_SHIRQ, "cyio", pIrq);
if (ret != 0)
{
printk(KERN_ERR PFX "Error registering IRQ %d [%s]!\n", nIrq, pIrq->sName);
}
}
#ifdef CYIO_TIMER
init_timer(&io_timer);
timer_inited = 1;
io_timer.function = io_timer_handler;
io_timer.data = CYEVENT_SUSPEND_SCREEN;
#endif
}
// ---------------------------------------------------------------------------
void io_deinitIrq(void)
{
int i;
cyIrq *pIrq, *pIrq0;
#ifdef CYIO_TIMER
del_timer(&io_timer);
timer_run = 0;
#endif
//nCnt = sizeof(s_nIrq)/sizeof(s_nIrq[0]);
pIrq0 = &s_nIrq[0];
for (i=0, pIrq=pIrq0; i<nCnt; ++i, ++pIrq)
free_irq(pIrq->nIrq, pIrq);
}
// ---------------------------------------------------------------------------
//#define DBG_IRQ
static irqreturn_t io_interrupt(int irq, void *dev_id)
{
cyIrq* pIrq = (cyIrq*)dev_id;
u8 bActive;
u8 blCodeActive;
unsigned long flags;
spinlock_t lock = SPIN_LOCK_UNLOCKED;
#ifdef CYIO_ALTERNATE_KEY
static int bAltKeyUsed = FALSE;
#endif
#ifdef DBG_IRQ
static int s_nIrq_dbg = 0;
++s_nIrq_dbg;
#endif
spin_lock_irqsave(&lock, flags);
{ // Avoid bounces
int i, nUp = 0;
for (i=0; i<10000; ++i)
if (gpio_get_value(pIrq->nGpio))
++nUp;
bActive = (nUp < 5000);
}
spin_unlock_irqrestore(&lock, flags);
if (pIrq->bActive == bActive)
return IRQ_HANDLED;
#ifdef DBG_IRQ
DBG(".. io_irq #%d [%s][%c] alt[%d:%d] bActive[%d]", s_nIrq_dbg, pIrq->sName, bActive || !pIrq->nCodeInactive ? (char)pIrq->nCodeActive : (char)pIrq->nCodeInactive, (s_altKeyPress && pIrq->bKeyIrq) ? pIrq->nCodeAlternate : (bActive ? pIrq->nCodeActive : pIrq->nCodeInactive), s_altKeyPress, bActive);
#endif
blCodeActive = (s_altKeyPress && pIrq->bKeyIrq) ? pIrq->nCodeAlternate : (bActive ? pIrq->nCodeActive : pIrq->nCodeInactive);
#ifdef CYIO_ALTERNATE_KEY
if (s_altKeyPresent)
{
s_altKeyPress = !gpio_get_value(s_altKeyGpio);
DBG("alt status: %d", s_altKeyPress);
}
#endif
spinLock(&io_lock);
pIrq->bActive = bActive;
if (pIrq->bKeyIrq)
{
#ifdef CYIO_REPEAT
DBG("bfr: s_nPrevKey = %d", s_nPrevKey);
if (s_nPrevKey)
{
DBG("s_nPrevKey is != 0 [%d]", s_nPrevKey);
if (!pIrq->bActive /*|| s_nPrevKey != blCodeActive*/)
s_nPrevKey = 0;
DBG("s_nPrevKey == %d (s_bRepMode:%d, pIrq->bActive:%d)", s_nPrevKey, s_bRepMode, pIrq->bActive);
if (s_bRepMode && !s_nPrevKey)
{
MSG("Exit repeat mode...");
s_bRepMode = 0;
if (s_pEventW)
{ // NB: This is considered as a system event
++s_nEventCnt;
s_pEventW->nCode = CYEVENT_KEY_REPEAT_END;
s_pEventW->nKeyEvent = 0;
s_pEventW = s_pEventW->pNext;
}
if (ptsk)
wake_up_process(ptsk);
}
}
#endif
#ifdef CYIO_ALTERNATE_KEY
if ((!pIrq->bActive) && (pIrq->nGpio != s_altKeyGpio))
#else
if (!pIrq->bActive)
#endif
{
spinUnlock(&io_lock);
MSG("Exiting IRQ Handler");
#ifdef CYIO_KERNEL_2_4
return;
#else
return IRQ_HANDLED;
#endif
}
}
spinUnlock(&io_lock);
//#ifdef DBG_IRQ
// DBG(".. io_irq #%d [%s][%c] bActive[%d]", s_nIrq_dbg, pIrq->sName, bActive || !pIrq->nCodeInactive ? (char)pIrq->nCodeActive : (char)pIrq->nCodeInactive, bActive);
//#endif
if (io_factoryPowerOff())
{ // Special case
spinLock(&io_lock);
MSG("Request Factory Setting...\n");
if (s_pEventW)
{
++s_nEventCnt;
++s_nKeyLogCnt;
s_pEventW->nCode = CYEVENT_FACTORY_OFF;
s_pEventW->nKeyEvent = 1;
s_pEventW = s_pEventW->pNext;
}
spinUnlock(&io_lock);
}
else
{
spinLock(&io_lock);
if ((s_nEventMax <= s_nEventCnt) ||
(pIrq->bKeyIrq && s_nKeyLogMax <= s_nKeyLogCnt))
{
spinUnlock(&io_lock);
DBG("s_nEventMax:%d, s_nEventCnt:%d, s_nKeyLogMax:%d, s_nKeyLogCnt:%d",s_nEventMax,s_nEventCnt,s_nKeyLogMax,s_nKeyLogCnt);
MSG("!!! Event list full !!!");
return IRQ_HANDLED;
}
#ifdef CYIO_ALTERNATE_KEY
if (s_altKeyPresent && bAltKeyUsed && !s_altKeyPress && (pIrq->nGpio == s_altKeyGpio))
{ /* If the released key is the Alt Key and it was used as the Alt Key, do not send an event */
MSG("Alt Key released... Do Nothing");
bAltKeyUsed = FALSE;
s_nPrevKey = 0;
spinUnlock(&io_lock);
return IRQ_HANDLED;
}
if (s_altKeyPresent && (pIrq->nGpio == s_altKeyGpio))
{ /* If the altKey is pressed, we have to do a little trick: Inverse it's active state */
MSG("Alt key event...");
/* To be sure */
s_nPrevKey = 0;
s_bRepMode = 0;
bActive = !bActive;
}
else if (s_altKeyPresent && s_altKeyPress && pIrq->bKeyIrq)
{/* The event is a keypress and the AltKey is pressed, set our internal value to prevent Alt to send an event */
MSG("Button press with Alt...");
if (pIrq->nCodeAlternate != 0)
bAltKeyUsed = TRUE;
}
MSG("Hum...");
#endif
if (s_pEventW)
{
MSG("Will push another event...");
++s_nEventCnt;
if (pIrq->bKeyIrq)
++s_nKeyLogCnt;
#ifdef CYIO_ALTERNATE_KEY
s_pEventW->nCode = (s_altKeyPress && pIrq->bKeyIrq) ? pIrq->nCodeAlternate : (bActive ? pIrq->nCodeActive : pIrq->nCodeInactive);
#else
s_pEventW->nCode = bActive ? pIrq->nCodeActive : pIrq->nCodeInactive;
#endif
s_pEventW->nKeyEvent = pIrq->bKeyIrq;
s_pEventW = s_pEventW->pNext;
}
spinUnlock(&io_lock);
}
if (ptsk)
wake_up_process(ptsk);
return IRQ_HANDLED;
}
// ---------------------------------------------------------------------------
#ifdef CYIO_TIMER
static void io_timer_handler(unsigned long nData)
{
/* YEP inside */
#if 0
//#ifdef G_SENSOR
if (hold_wakeup==1) {
del_timer(&io_timer);
goto end_timer;
}
#endif
/* end YEP inside */
DBG("Timer [%ld] tick...\n", nData);
spin_lock_irq(&io_lock);
del_timer(&io_timer);
timer_run = 0;
if (s_nEventCnt < s_nEventMax)
{
if (s_pEventW)
{
++s_nEventCnt;
s_pEventW->nCode = (u8)nData;
s_pEventW->nKeyEvent = 0;
s_pEventW = s_pEventW->pNext;
}
}
spin_unlock_irq(&io_lock);
if (ptsk)
wake_up_process(ptsk);
//end_timer:
return;
}
#endif
// ===========================================================================
static int io_open(struct inode *inode, struct file *file)
{
//MSG(">> io_open");
//spin_lock_irq(&io_lock);
spinLock(&io_lock);
if (io_status)
{
//spin_unlock_irq(&io_lock);
spinUnlock(&io_lock);
//MSG(".. io_open !!! Busy");
return -EBUSY;
}
io_status = 1;
//spin_unlock_irq(&io_lock);
spinUnlock(&io_lock);
io_initIrq();
return 0;
}
// ---------------------------------------------------------------------------
static int io_release(struct inode *inode, struct file *file)
{
MSG(">> io_release");
io_deinitIrq();
spin_lock_irq(&io_lock);
io_status = 0;
// The driver is likely to be closed & reopened within suspend sequences
// Only initialize the list when registering the driver and when closing it
// This allows for a quicker opening of the driver
io_initEventList();
spin_unlock_irq(&io_lock);
MSG("<< io_release");
return 0;
}
// ---------------------------------------------------------------------------
ssize_t io_read(struct file *file, char *buf, size_t count, loff_t *ppos)
{
int nBytes = sizeof(unsigned long);
unsigned long nData;
ssize_t nRes = 0;
if (count < sizeof(unsigned long))
return -EINVAL;
while (1)
{
//spin_lock_irq(&io_lock);
spinLock(&io_lock);
nData = 0;
if (s_nEventCnt)
{
nData = s_pEventR->nCode;
s_pEventR->nCode = 0;
--s_nEventCnt;
if (s_pEventR->nKeyEvent)
{
--s_nKeyLogCnt;
#ifdef CYIO_REPEAT
if (nData != CYEVENT_KEY_OFF)
{
DBG("(line %d)Set s_nPrevKey", __LINE__);
s_nPrevKey = nData;
s_bRepMode = 0;
}
#endif
}
s_pEventR = s_pEventR->pNext;
}
#ifdef CYIO_REPEAT
if (!nData && s_nPrevKey)
{ // Check new status
int i;
cyIrq *pIrq, *pIrq0;
pIrq0 = &s_nIrq[0];
MSG("Will test key...");
for (i=0, pIrq=pIrq0; i<nCnt; ++i, ++pIrq)
{
#ifdef CYIO_ALTERNATE_KEY
if ((pIrq->nCodeActive != s_nPrevKey) && (pIrq->nCodeAlternate != s_nPrevKey))
#else
if (pIrq->nCodeActive != s_nPrevKey)
#endif
{
MSG("!CodeActive and Alt+!AltCode");
continue;
}
MSG("May clear prevkey");
if (!pIrq->bActive || gpio_get_value(pIrq->nGpio))
{
DBG("(line %d)Set s_nPrevKey", __LINE__);
s_nPrevKey = 0;
}
break;
}
if (s_nPrevKey)
{
MSG("Will Set Repeat flag...");
nData = s_nPrevKey | CYEVENT_KEY_REPEAT_FLAG;
s_bRepMode = 1;
}
}
#endif
spinUnlock(&io_lock);
if (nData != 0)
{
#ifdef CYIO_TIMER
del_timer(&io_timer);
timer_run = 0;
io_timer.data = (nData == CYEVENT_SUSPEND_SCREEN) ? CYEVENT_SUSPEND_DEVICE : CYEVENT_SUSPEND_SCREEN;
#endif
break;
}
#ifdef CYIO_TIMER
if (s_pbUsbPowered && s_pbAcPowered && !(*s_pbUsbPowered) && !(*s_pbAcPowered))
{
del_timer(&io_timer);
timer_run = 0;
if (io_timer.data == CYEVENT_SUSPEND_SCREEN)
{
io_timer.expires = IO_TIMER_DELAY_1;
io_timer.expires += jiffies;
add_timer(&io_timer);
}
else //if (io_timer.data == CYEVENT_SUSPEND_DEVICE)
{
io_timer.expires = IO_TIMER_DELAY_2 - IO_TIMER_DELAY_1;
io_timer.expires += jiffies;
add_timer(&io_timer);
}
timer_run = 1;
}
#endif
ptsk = current;
set_current_state(TASK_INTERRUPTIBLE);
schedule();
set_current_state(TASK_RUNNING);
ptsk = 0;
if (signal_pending(current))
{
nRes = -ERESTARTSYS;
break;
}
}
if (nData)
{
nRes = copy_to_user(buf,&nData,nBytes);
if (!nRes)
nRes = nBytes;
}
return nRes;
}
// ---------------------------------------------------------------------------
static int io_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg)
{
return -EINVAL;
}
// ===========================================================================
static struct file_operations s_io_fops =
{
owner: THIS_MODULE,
read: io_read,
ioctl: io_ioctl,
open: io_open,
release: io_release,
};
static struct miscdevice s_io_dev =
{
.minor = 250,
.name = "cyio",
.fops = &s_io_fops,
};
// ===========================================================================
// ---------------------------------------------------------------------------
static int io_probe(struct platform_device *dev)
{
return 0;
}
// ---------------------------------------------------------------------------
static int io_remove(struct platform_device *dev)
{
misc_deregister(&s_io_dev);
return 0;
}
// ---------------------------------------------------------------------------
static int io_resume(struct platform_device *dev)
{
//cyIrq *pIrq;
//u8 bSdCd;
MSG(">>Resume() .......\n");
#if 0
if ((platform_type == CYBOOK_GEN3) || (platform_type == CYBOOK_GEN3GOLD))
{
pIrq = &s_nIrq[13];
}
else
{
pIrq = &s_nIrq[11];
}
bSdCd = !read_gpio_bit(pIrq->nGpio);
//MSG(">>Resume() .......bSdCd 0x%x\n",bSdCd);
if (pIrq->bActive == bSdCd)
return 0;
spinLock(&io_lock);
pIrq->bActive = bSdCd;
if (s_pEventW)
{
++s_nEventCnt;
s_pEventW->nCode = pIrq->bActive ? pIrq->nCodeActive : pIrq->nCodeInactive;
s_pEventW->nKeyEvent = pIrq->bKeyIrq;
s_pEventW = s_pEventW->pNext;
}
spinUnlock(&io_lock);
if (ptsk)
wake_up_process(ptsk);
#endif
MSG("<<Resume() .......\n");
return 0;
}
// ---------------------------------------------------------------------------
static struct platform_driver cyio_driver =
{
.driver =
{
.name = "cyio",
.owner = THIS_MODULE,
},
.probe = io_probe,
.remove = io_remove,
.suspend = NULL,
.resume = io_resume,
};
// ---------------------------------------------------------------------------
// ===========================================================================
static int __init cyIo_init(void)
{
#if 0
if(platform_type == CYBOOK_OPUS)
{
s_nIrq = s_nIrq_OPUS;
nCnt = sizeof(s_nIrq_OPUS)/sizeof(s_nIrq_OPUS[0]);
}
else if (/* GEN3 && GEN3GOLD */
{
s_nIrq = s_nIrq_GEN3;
nCnt = sizeof(s_nIrq_GEN3)/sizeof(s_nIrq_GEN3[0]);
}
#endif
s_nIrq = s_nIrq_GEN4;
nCnt = sizeof(s_nIrq_GEN4)/sizeof(s_nIrq_GEN4[0]);
DBG("s_nEventMax:%d, s_nEventCnt:%d, s_nKeyLogMax:%d, s_nKeyLogCnt:%d",s_nEventMax,s_nEventCnt,s_nKeyLogMax,s_nKeyLogCnt);
/* end YEP inside */
io_initEventList();
if (misc_register(&s_io_dev))
return -EBUSY;
platform_driver_register(&cyio_driver);
return 0;
}
// ---------------------------------------------------------------------------
static void __exit cyIo_exit(void)
{
platform_driver_unregister(&cyio_driver);
misc_deregister(&s_io_dev);
//MSG("<< cyIo_exit");
}
// ---------------------------------------------------------------------------
module_init(cyIo_init);
module_exit(cyIo_exit);
// ---------------------------------------------------------------------------
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Bookeen <developers@bookeen.com>");
MODULE_DESCRIPTION("Cybook Event Manager");
MODULE_VERSION("3.0");
// ===========================================================================
Reference in New Issue View Git Blame Copy Permalink