int wait_for_ack_irq(int which) {
int pid = fiona_sys_getpid();
g_ack_clients++;
if (g_ack_clients > 1) {
/* Someone is already waiting for an EINK controller acknowledgement.
* We should never have two processes waiting here for acks, as that
* indicates two separate processes presumably writing two separate
* things to hardware, each thinking it owns it....
* For now, this is a hack fix to avoid the effect when we hit this bug.
* Real solution is to fix semaphore issue with driver and setmode. -njv
*/
printk("BUG !!! Eink semaphore issue in wait_for_ack_irq !!\n");
printk("BUG !!! Waiting pid: %d, this pid: %d\n",g_ack_waiting_pid,pid);
g_ack_clients--;
return 1;
}
g_ack_waiting_pid = pid;
enable_irq(IRQ_GPIO(83));
wait_event_interruptible_timeout(apollo_ack_wq, (apollo_get_ack() == which), MAX_TIMEOUT);
disable_irq(IRQ_GPIO(83));
g_ack_clients--;
g_ack_waiting_pid = 0;
return 1;
}
static int sharpsl_pm_remove(struct platform_device *pdev)
{
suspend_set_ops(NULL);
device_remove_file(&pdev->dev, &dev_attr_battery_percentage);
device_remove_file(&pdev->dev, &dev_attr_battery_voltage);
led_trigger_unregister_simple(sharpsl_charge_led_trigger);
free_irq(IRQ_GPIO(sharpsl_pm.machinfo->gpio_acin), sharpsl_ac_isr);
free_irq(IRQ_GPIO(sharpsl_pm.machinfo->gpio_batlock), sharpsl_fatal_isr);
if (sharpsl_pm.machinfo->gpio_fatal)
free_irq(IRQ_GPIO(sharpsl_pm.machinfo->gpio_fatal), sharpsl_fatal_isr);
if (sharpsl_pm.machinfo->batfull_irq)
free_irq(IRQ_GPIO(sharpsl_pm.machinfo->gpio_batfull), sharpsl_chrg_full_isr);
gpio_free(sharpsl_pm.machinfo->gpio_batlock);
gpio_free(sharpsl_pm.machinfo->gpio_batfull);
gpio_free(sharpsl_pm.machinfo->gpio_acin);
if (sharpsl_pm.machinfo->exit)
sharpsl_pm.machinfo->exit();
del_timer_sync(&sharpsl_pm.chrg_full_timer);
del_timer_sync(&sharpsl_pm.ac_timer);
return 0;
}
static irqreturn_t k3v2_gpio_key_irq_handler(int irq, void *dev_id)
{
struct k3v2_gpio_key *gpio_key = (struct k3v2_gpio_key *)dev_id;
switch (irq) {
case IRQ_GPIO(GPIO_17_1):
schedule_delayed_work(&(gpio_key->gpio_keyup_work), 0);
break;
case IRQ_GPIO(GPIO_17_2):
schedule_delayed_work(&(gpio_key->gpio_keydown_work), 0);
break;
case IRQ_GPIO(GPIO_17_6):
schedule_delayed_work(&(gpio_key->gpio_camerafocus_work), 0);
break;
case IRQ_GPIO(GPIO_17_7):
schedule_delayed_work(&(gpio_key->gpio_camera_work), 0);
break;
default:
printk(KERN_ERR "[gpiokey][%s]invalid irq %d!\n", __FUNCTION__, irq);
break;
}
return IRQ_HANDLED;
}
static int e740_pcmcia_hw_init(struct soc_pcmcia_socket *skt)
{
skt->irq = skt->nr == 0 ? IRQ_GPIO(GPIO_E740_PCMCIA_RDY0) :
IRQ_GPIO(GPIO_E740_PCMCIA_RDY1);
return soc_pcmcia_request_irqs(skt, &cd_irqs[skt->nr], 1);
}
static int aspenite_u2o_vbus_detect(void *func, int enable)
{
int ret;
if (enable) {
/* FIXME needed for future SRP support
* request_irq(IRQ_GPIO(gpio_usb_otg_stat1),
aspenite_u2o_vbus_event, IRQF_DISABLED |
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
"otg_stat1", func);
*/
ret = request_irq(IRQ_GPIO(gpio_usb_otg_stat2),
(irq_handler_t)aspenite_u2o_vbus_event, IRQF_DISABLED |
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
"otg_stat2", func);
if (ret)
printk(KERN_INFO "request irq otgstat2 %d failed: %d\n",
IRQ_GPIO(gpio_usb_otg_stat2), ret);
} else {
/* free_irq(IRQ_GPIO(gpio_usb_otg_stat1), NULL); */
free_irq(IRQ_GPIO(gpio_usb_otg_stat2), func);
}
return 0;
}
static void __init yf255_init_irq(void)
{
int irq;
pxa25x_init_irq();
#if 1
/* setup extra yf255 irqs */
for (irq = YF255_IRQ(0); irq <= YF255_LAST_IRQ; irq++) {
set_irq_chip(irq, &yf255_irq_chip);
set_irq_handler(irq, handle_level_irq);
set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
}
#endif
/*For Ethernet_INT*/
set_irq_type(IRQ_GPIO(0), IRQ_TYPE_EDGE_RISING);
/*For RTC_INT*/
set_irq_type(IRQ_GPIO(1), IRQ_TYPE_EDGE_RISING);
/*For AC97_IRQ*/
// set_irq_type(IRQ_GPIO(3), IRQ_TYPE_EDGE_RISING);
/*For PCMCIA_DECT*/
set_irq_type(IRQ_GPIO(4), IRQ_TYPE_EDGE_RISING);
/*For PCMCIA_RDY*/
set_irq_type(IRQ_GPIO(5), IRQ_TYPE_EDGE_RISING);
/*For MMC*/
set_irq_type(IRQ_GPIO(12), IRQ_TYPE_LEVEL_LOW);// IRQ_TYPE_EDGE_FALLING);//zkj
}
static irqreturn_t a716_stylus(int irq, void *dev_id)
{
ts_pos_t ts_pos;
if (irq == IRQ_GPIO(GPIO_NR_A716_STYLUS_IRQ_N) && irq_disable == 0) {
//printk("IRQ\n");
irq_disable = 1;
disable_irq(IRQ_GPIO(GPIO_NR_A716_STYLUS_IRQ_N));
}
read_xydata(&ts_pos);
if (ts_pos.xd == 0 || ts_pos.yd == 0) {
report_touchpanel(0, 0, 0);
//printk("touch released\n");
if (irq_disable == 1) {
request_irq(IRQ_GPIO(GPIO_NR_A716_STYLUS_IRQ_N), a716_stylus, SA_SAMPLE_RANDOM, "ad7873 stylus", NULL);
set_irq_type(IRQ_GPIO(GPIO_NR_A716_STYLUS_IRQ_N), IRQT_FALLING);
enable_irq(IRQ_GPIO(GPIO_NR_A716_STYLUS_IRQ_N));
irq_disable = 0;
}
return IRQ_HANDLED;
}
//printk("%04d %04d\n", (int)ts_pos.xd, (int)ts_pos.yd);
//printk("touch pressed\n");
report_touchpanel(ts_pos.xd, ts_pos.yd, 1);
mod_timer(&timer_pen, jiffies + (SAMPLE_TIMEOUT * HZ) / 1000);
//printk("callback\n");
return IRQ_HANDLED;
};
void __cmx270_pci_init_irq(void)
{
it8152_init_irq();
pxa_gpio_mode(IRQ_TO_GPIO(GPIO_IT8152_IRQ));
set_irq_type(IRQ_GPIO(GPIO_IT8152_IRQ), IRQT_RISING);
set_irq_chained_handler(IRQ_GPIO(GPIO_IT8152_IRQ),
cmx270_it8152_irq_demux);
}
static int tekom_ts_probe(struct i2c_client *client, const struct i2c_device_id * id)
{
int ret = -EIO;
struct tekom_touch_data *p_tekom_touch;
struct input_dev *tekom_ts_input_dev;
/* register input device */
tekom_ts_input_dev = input_allocate_device();
tekom_ts_input_dev->name = "Tekom capcitive touchscreen";
tekom_ts_input_dev->open = tekom_ts_input_open;
tekom_ts_input_dev->close = tekom_ts_input_close;
__set_bit(EV_ABS, tekom_ts_input_dev->evbit);
__set_bit(ABS_X, tekom_ts_input_dev->absbit);
__set_bit(ABS_Y, tekom_ts_input_dev->absbit);
__set_bit(ABS_PRESSURE, tekom_ts_input_dev->absbit);
set_bit(EV_KEY, tekom_ts_input_dev->evbit);
set_bit(BTN_TOUCH, tekom_ts_input_dev->keybit);
/* Malloc p_touch context */
p_tekom_touch = kzalloc(sizeof(struct tekom_touch_data), GFP_KERNEL);
if (!p_tekom_touch) {
ret = -ENOMEM;
goto err;
}
p_tekom_touch->tekom_ts_input_dev = tekom_ts_input_dev;
platform_set_drvdata(client, p_tekom_touch);
input_set_drvdata(tekom_ts_input_dev, p_tekom_touch);
ret = input_register_device(tekom_ts_input_dev);
p_tekom_touch->client = client;
p_tekom_touch->pen_down = 0;
p_tekom_touch->use_count = 0;
p_tekom_touch->poll_jiffies = 5;
tekom_touch_gpio_init();
ret = request_irq(IRQ_GPIO(MFP2GPIO(TOUCH_INT)), tekom_touch_interrupt,
IRQF_TRIGGER_FALLING, "Tekom_capcitive", p_tekom_touch);
ret = request_irq(IRQ_GPIO(MFP2GPIO(SLIDE_INT)), slide_interrupt,
IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, "SLIDE_INT", p_tekom_touch);
init_timer(&p_tekom_touch->poll_timer);
p_tekom_touch->poll_timer.data = (unsigned long)p_tekom_touch;
p_tekom_touch->poll_timer.function = tekom_poll_timer_handler;
ret = sysfs_create_group(&client->dev.kobj, &tekom_touch_attr_group);
printk("Android tekom capcitive touchscreen driver register succ\n");
return 0;
err:
return ret;
}
void sharpsl_pm_pxa_remove(void)
{
free_irq(IRQ_GPIO(sharpsl_pm.machinfo->gpio_acin), sharpsl_ac_isr);
free_irq(IRQ_GPIO(sharpsl_pm.machinfo->gpio_batlock), sharpsl_fatal_isr);
if (sharpsl_pm.machinfo->gpio_fatal)
free_irq(IRQ_GPIO(sharpsl_pm.machinfo->gpio_fatal), sharpsl_fatal_isr);
if (sharpsl_pm.machinfo->batfull_irq)
free_irq(IRQ_GPIO(sharpsl_pm.machinfo->gpio_batfull), sharpsl_chrg_full_isr);
}
static int gpio_watch(int x)
{
int ret;
ret = request_irq (IRQ_GPIO(x), gpio_irq, SA_SAMPLE_RANDOM, "test_handler", (void*)x);
set_irq_type (IRQ_GPIO(x), IRQT_BOTHEDGE);
if(ret!=0) {
printk(KERN_ERR "GPIOed: failed to register for GPIO %d\n", x);
return 1;
} else {
printk(KERN_ERR "GPIOed: Registered GPIO %d\n", x);
return 0;
}
}
static int eseries_battery_init(void) {
int ret;
if(!(machine_is_e740() || machine_is_e750() || machine_is_e800()))
return -ENODEV;
ret = request_irq(IRQ_GPIO(10), eseries_battery_irq, 0, "battery", NULL);
if(ret)
return ret;
set_irq_type(IRQ_GPIO(10), IRQT_BOTHEDGE);
eseries_battery_probe(NULL);
return 0;
}
static int palmtx_pcmcia_hw_init (struct soc_pcmcia_socket *skt)
{
GPSR(GPIO48_nPOE_MD) = GPIO_bit(GPIO48_nPOE_MD) |
GPIO_bit(GPIO49_nPWE_MD) |
GPIO_bit(GPIO50_nPIOR_MD) |
GPIO_bit(GPIO51_nPIOW_MD) |
GPIO_bit(GPIO85_nPCE_1_MD) |
GPIO_bit(GPIO53_nPCE_2_MD) |
GPIO_bit(GPIO54_pSKTSEL_MD) |
GPIO_bit(GPIO55_nPREG_MD) |
GPIO_bit(GPIO56_nPWAIT_MD) |
GPIO_bit(GPIO57_nIOIS16_MD);
pxa_gpio_mode(GPIO48_nPOE_MD);
pxa_gpio_mode(GPIO49_nPWE_MD);
pxa_gpio_mode(GPIO50_nPIOR_MD);
pxa_gpio_mode(GPIO51_nPIOW_MD);
pxa_gpio_mode(GPIO85_nPCE_1_MD);
pxa_gpio_mode(GPIO53_nPCE_2_MD);
pxa_gpio_mode(GPIO54_pSKTSEL_MD);
pxa_gpio_mode(GPIO55_nPREG_MD);
pxa_gpio_mode(GPIO56_nPWAIT_MD);
pxa_gpio_mode(GPIO57_nIOIS16_MD);
skt->irq = IRQ_GPIO(GPIO_NR_PALMTX_PCMCIA_READY);
palmtx_pcmcia_dbg("%s:%i, Socket:%d\n", __FUNCTION__, __LINE__, skt->nr);
return soc_pcmcia_request_irqs(skt, palmtx_socket_state_irqs,
ARRAY_SIZE(palmtx_socket_state_irqs));
}
static void __init lubbock_init_irq(void)
{
int irq;
pxa_init_irq();
/* setup extra lubbock irqs */
for (irq = LUBBOCK_IRQ(0); irq <= LUBBOCK_LAST_IRQ; irq++) {
set_irq_chip(irq, &lubbock_irq_chip);
set_irq_handler(irq, do_level_IRQ);
set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
}
set_irq_chained_handler(IRQ_GPIO(0), lubbock_irq_handler);
set_irq_type(IRQ_GPIO(0), IRQT_FALLING);
}
// the module last called function
void cleanup_module(void) {
remove_proc_entry(PROCFS_PID_NAME, &proc_root);
remove_proc_entry(PROCFS_CMD_NAME, &proc_root);
PDEBUG("Freeing registered irq %d for GPIO %d\n", IRQ_GPIO(gpio_in_streamctl), gpio_in_streamctl);
free_irq(IRQ_GPIO(gpio_in_streamctl), &data);
turn_off_gpio(gpio_out_modem);
// turn off led green: reverse logic
turn_on_gpio(gpio_out_green);
del_timer(&jiq_pulse_timer);
printk(KERN_INFO MODULE_NAME ": Stopping gpio module...\n");
}
static void __init lubbock_init_irq(void)
{
int irq;
pxa25x_init_irq();
/* setup extra lubbock irqs */
for (irq = LUBBOCK_IRQ(0); irq <= LUBBOCK_LAST_IRQ; irq++) {
irq_set_chip_and_handler(irq, &lubbock_irq_chip,
handle_level_irq);
set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
}
irq_set_chained_handler(IRQ_GPIO(0), lubbock_irq_handler);
irq_set_irq_type(IRQ_GPIO(0), IRQ_TYPE_EDGE_FALLING);
}
static void pxa_mask_muxed_gpio(unsigned int irq)
{
int gpio = irq - IRQ_GPIO(2) + 2;
__clear_bit(gpio, GPIO_IRQ_mask);
GRER(gpio) &= ~GPIO_bit(gpio);
GFER(gpio) &= ~GPIO_bit(gpio);
}
static void pxa_unmask_muxed_gpio(unsigned int irq)
{
int gpio = irq - IRQ_GPIO(2) + 2;
int idx = gpio >> 5;
__set_bit(gpio, GPIO_IRQ_mask);
GRER(gpio) = GPIO_IRQ_rising_edge[idx] & GPIO_IRQ_mask[idx];
GFER(gpio) = GPIO_IRQ_falling_edge[idx] & GPIO_IRQ_mask[idx];
}
static void yf255_mmc_poll(unsigned long data)
{
unsigned long flags;
/* clear any previous irq state, then ... */
local_irq_save(flags);
YF255_IRQ_SET_CLR &= ~(1 << 0);
local_irq_restore(flags);
/* poll until mmc/sd card is removed */
if (YF255_IRQ_SET_CLR & (1 << 0))
mod_timer(&mmc_timer, jiffies + MMC_POLL_RATE);
else {
(void) mmc_detect_int(IRQ_GPIO(12), (void *)data);
enable_irq(IRQ_GPIO(12));
}
}
void apollo_init_irq(void) {
int rqstatus;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 0)
set_irq_type(IRQ_GPIO(83), IRQT_FALLING);
#else
set_GPIO_IRQ_edge(83, GPIO_FALLING_EDGE);
printk("SET FALLING EDGE 2.4 style done\n");
#endif
rqstatus = request_irq(IRQ_GPIO(83), eink_irq_hdl, SA_INTERRUPT, "einkfb", NULL);
do_debug("rqstatus %d irq %d\n", rqstatus, IRQ_GPIO(83));
disable_irq(IRQ_GPIO(83)); /* initially disable irq. we will use it
only for longer waits to avoid prolonged
spinning */
do_debug("DISABLE_IRQ done\n");
}
static void am200_cleanup(struct metronomefb_par *par)
{
int i;
free_irq(IRQ_GPIO(RDY_GPIO_PIN), par);
for (i = 0; i < ARRAY_SIZE(gpios); i++)
gpio_free(gpios[i]);
}
static void __init lpd270_init_irq(void)
{
int irq;
pxa27x_init_irq();
__raw_writew(0, LPD270_INT_MASK);
__raw_writew(0, LPD270_INT_STATUS);
/* setup extra LogicPD PXA270 irqs */
for (irq = LPD270_IRQ(2); irq <= LPD270_IRQ(4); irq++) {
irq_set_chip_and_handler(irq, &lpd270_irq_chip,
handle_level_irq);
set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
}
irq_set_chained_handler(IRQ_GPIO(0), lpd270_irq_handler);
irq_set_irq_type(IRQ_GPIO(0), IRQ_TYPE_EDGE_FALLING);
}
STATIC int hiusb_request_irq(struct lm_device *dev)
{
int ret = 0;
struct lm_device *lm_dev;
struct hiusb_info *hiusb_info;
lm_dev = dev;
hiusb_info = dev->hiusb_info;
if (hiusb_info->insert_irq == 0 || hiusb_info->draw_irq == 0) {
if ((hiusb_info->quirks & HIUSB_QUIRKS_PMUIRQ) == 0) {
hiusb_info->insert_irq = 1;
hiusb_info->draw_irq = 2;
}
dev_info(&lm_dev->dev, "No insert/draw irq.\n");
return 0;
}
/* request insert irq */
ret = request_irq(hiusb_info->insert_irq, hiusb_vbus_intr,
IRQF_NO_SUSPEND, "hiusb_insert_intr", lm_dev);
if (ret) {
dev_err(&dev->dev, "request insert irq failed.\n");
goto request_insert_irq_fail;
}
/* request draw irq */
ret = request_irq(hiusb_info->draw_irq, hiusb_vbus_intr,
IRQF_NO_SUSPEND, "hiusb_draw_intr", lm_dev);
if (ret) {
dev_err(&dev->dev, "request draw irq failed.\n");
goto request_draw_irq_fail;
}
/* request otg gpio int irq */
if(-1 != hiusb_info->otg_int_gpio) {
gpio_direction_input(hiusb_info->otg_int_gpio);
ret = request_irq(IRQ_GPIO(hiusb_info->otg_int_gpio), hiusb_otggpio_intr,
IRQF_NO_SUSPEND|IRQF_TRIGGER_FALLING, "hiusb_otggpio_intr", lm_dev);
if (ret) {
dev_err(&dev->dev, "request gpio irq failed.\n");
goto request_gpio_irq_fail;
}
}
dev_info(&dev->dev, "request insert irq: %d\n", hiusb_info->insert_irq);
dev_info(&dev->dev, "request draw irq: %d\n", hiusb_info->draw_irq);
dev_info(&dev->dev, "request gpio: %d irq\n", hiusb_info->otg_int_gpio);
return 0;
request_gpio_irq_fail:
free_irq(hiusb_info->draw_irq, dev);
request_draw_irq_fail:
free_irq(hiusb_info->insert_irq, dev);
request_insert_irq_fail:
return ret;
}
static int palmld_pcmcia_hw_init(struct soc_pcmcia_socket *skt)
{
int ret;
ret = gpio_request_array(palmld_pcmcia_gpios,
ARRAY_SIZE(palmld_pcmcia_gpios));
skt->socket.pci_irq = IRQ_GPIO(GPIO_NR_PALMLD_PCMCIA_READY);
return ret;
}
static int yf255_mci_init(struct device *dev,
irq_handler_t detect_int,
void *data)
{
/* detect card insert/eject */
mmc_detect_int = detect_int;
init_timer(&mmc_timer);
mmc_timer.data = (unsigned long) data;
return request_irq(IRQ_GPIO(12), yf255_detect_int,
IRQF_SAMPLE_RANDOM, "yf255-sd-detect", data);
}
static int a716_ssp_suspend(struct platform_device *pdev, pm_message_t state)
{
del_timer_sync(&timer_pen);
disable_irq(IRQ_GPIO(GPIO_NR_A716_STYLUS_IRQ_N));
ssp_flush(&a716_ssp_dev);
ssp_save_state(&a716_ssp_dev, &a716_ssp_state);
return 0;
}
static int sharpsl_pm_remove(struct platform_device *pdev)
{
pm_set_ops(NULL);
device_remove_file(&pdev->dev, &dev_attr_battery_percentage);
device_remove_file(&pdev->dev, &dev_attr_battery_voltage);
free_irq(IRQ_GPIO(sharpsl_pm.machinfo->gpio_acin), sharpsl_ac_isr);
free_irq(IRQ_GPIO(sharpsl_pm.machinfo->gpio_batlock), sharpsl_fatal_isr);
if (sharpsl_pm.machinfo->gpio_fatal)
free_irq(IRQ_GPIO(sharpsl_pm.machinfo->gpio_fatal), sharpsl_fatal_isr);
if (!machine_is_corgi())
free_irq(IRQ_GPIO(sharpsl_pm.machinfo->gpio_batfull), sharpsl_chrg_full_isr);
del_timer_sync(&sharpsl_pm.chrg_full_timer);
del_timer_sync(&sharpsl_pm.ac_timer);
return 0;
}
static void __init mainstone_init_irq(void)
{
int irq;
pxa_init_irq();
/* setup extra Mainstone irqs */
for(irq = MAINSTONE_IRQ(0); irq <= MAINSTONE_IRQ(15); irq++) {
set_irq_chip(irq, &mainstone_irq_chip);
set_irq_handler(irq, do_level_IRQ);
set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
}
set_irq_flags(MAINSTONE_IRQ(8), 0);
set_irq_flags(MAINSTONE_IRQ(12), 0);
MST_INTMSKENA = 0;
MST_INTSETCLR = 0;
set_irq_chained_handler(IRQ_GPIO(0), mainstone_irq_handler);
set_irq_type(IRQ_GPIO(0), IRQT_FALLING);
}
/* The init function called when module is installed */
static int arduino_comms_init(void){
int result; //temp status var
int cmd_req_irq; //the irq number associated with the gpio number
/* Attempt to register the device */
result = register_chrdev(arduino_comms_major, "arduino_comms", &arduino_comms_fops);
//check to see if registration was successful
if(result < 0){
printk(KERN_ALERT "arduino_comms: cannot obtain major number %d\n", arduino_comms_major);
return result;
}
proc_entry = create_proc_entry("arduino_comms", 0644, NULL);
if(proc_entry == NULL){
printk(KERN_ALERT "Couldn't create proc entry\n");
result = -ENOMEM;
}else{
//proc_entry->write_proc = write_2_proc;
proc_entry->read_proc = arduino_comms_proc_read;
proc_entry->owner = THIS_MODULE;
}
//IO pin setup
gpio_direction_output(THROTTLE_INCDEC,0);//set pin "THROTTLE_INCDEC" as output w/ init val of 0
gpio_direction_output(THROTTLE_RATE,0); //set pin "THROTTLE_RATE" as output w/ init val of 0
gpio_direction_output(YAW_INCDEC, 0);
gpio_direction_output(YAW_RATE, 0);
gpio_direction_output(PITCH_INCDEC, 0);
gpio_direction_output(PITCH_RATE, 0);
//gpio_direction_input(ARDUINO_CMD_REQ); //set pin used by arduino to request new command as input
pxa_gpio_mode(ARDUINO_CMD_REQ | GPIO_IN);
cmd_req_irq = IRQ_GPIO(ARDUINO_CMD_REQ);//get the irq number corresponding to the gpio_number
set_irq_type(cmd_req_irq, IRQT_RISING); //interupt triggered on rising edge (0 to 1 signal transition)
//register the gpio interrupt
//SA_INTERRUPT | SA_TRIGGER_RISING
if(request_irq(cmd_req_irq, &request_cmd_cb, 0, "ARDUINO_CMD_REQ", NULL) != 0){
printk(KERN_ALERT "Interupt for Arduino command requests not aquired\n");
goto fail;
}
printk("arduino_comms loaded.\n");
return 0;
fail:
arduino_comms_exit();
return result;
}
static void __init csb226_init(void)
{
(void) platform_add_devices(devices, ARRAY_SIZE(devices));
#if defined(CONFIG_MMC_PXA)
pxa_set_mci_info(&csb226_mci_platform_data);
#endif
#if defined(CONFIG_CIRRUS)
set_irq_type(IRQ_GPIO(GPIO_CSB226_ETH), IRQT_RISING);
#endif
if (!request_irq(IRQ_GPIO(0), csb226_gpio0_irq, 0, "gpio0", 0))
set_irq_type(IRQ_GPIO(0), IRQT_FALLING);
else
printk(KERN_ERR "%s: request for GPIO0 IRQ failed\n", __FUNCTION__);
#if defined(CONFIG_FB_PXA)
set_pxa_fb_info(&sharp_todo);
#endif
}
