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 }