Balaji T K | e8deb28 | 2009-12-14 00:25:31 +0100 | [diff] [blame] | 1 | /* |
| 2 | * twl6030-irq.c - TWL6030 irq support |
| 3 | * |
| 4 | * Copyright (C) 2005-2009 Texas Instruments, Inc. |
| 5 | * |
| 6 | * Modifications to defer interrupt handling to a kernel thread: |
| 7 | * Copyright (C) 2006 MontaVista Software, Inc. |
| 8 | * |
| 9 | * Based on tlv320aic23.c: |
| 10 | * Copyright (c) by Kai Svahn <kai.svahn@nokia.com> |
| 11 | * |
| 12 | * Code cleanup and modifications to IRQ handler. |
| 13 | * by syed khasim <x0khasim@ti.com> |
| 14 | * |
| 15 | * TWL6030 specific code and IRQ handling changes by |
| 16 | * Jagadeesh Bhaskar Pakaravoor <j-pakaravoor@ti.com> |
| 17 | * Balaji T K <balajitk@ti.com> |
| 18 | * |
| 19 | * This program is free software; you can redistribute it and/or modify |
| 20 | * it under the terms of the GNU General Public License as published by |
| 21 | * the Free Software Foundation; either version 2 of the License, or |
| 22 | * (at your option) any later version. |
| 23 | * |
| 24 | * This program is distributed in the hope that it will be useful, |
| 25 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 26 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 27 | * GNU General Public License for more details. |
| 28 | * |
| 29 | * You should have received a copy of the GNU General Public License |
| 30 | * along with this program; if not, write to the Free Software |
| 31 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 32 | */ |
| 33 | |
| 34 | #include <linux/init.h> |
| 35 | #include <linux/interrupt.h> |
| 36 | #include <linux/irq.h> |
| 37 | #include <linux/kthread.h> |
| 38 | #include <linux/i2c/twl.h> |
kishore kadiyala | 72f2e2c | 2010-09-24 17:13:20 +0000 | [diff] [blame] | 39 | #include <linux/platform_device.h> |
Todd Poynor | ab2b926 | 2011-10-04 11:52:29 +0200 | [diff] [blame] | 40 | #include <linux/suspend.h> |
Balaji T K | e8deb28 | 2009-12-14 00:25:31 +0100 | [diff] [blame] | 41 | |
G, Manjunath Kondaiah | b0b4a7c | 2010-10-19 11:02:48 +0200 | [diff] [blame] | 42 | #include "twl-core.h" |
| 43 | |
Balaji T K | e8deb28 | 2009-12-14 00:25:31 +0100 | [diff] [blame] | 44 | /* |
| 45 | * TWL6030 (unlike its predecessors, which had two level interrupt handling) |
| 46 | * three interrupt registers INT_STS_A, INT_STS_B and INT_STS_C. |
| 47 | * It exposes status bits saying who has raised an interrupt. There are |
| 48 | * three mask registers that corresponds to these status registers, that |
| 49 | * enables/disables these interrupts. |
| 50 | * |
| 51 | * We set up IRQs starting at a platform-specified base. An interrupt map table, |
| 52 | * specifies mapping between interrupt number and the associated module. |
| 53 | * |
| 54 | */ |
| 55 | |
| 56 | static int twl6030_interrupt_mapping[24] = { |
| 57 | PWR_INTR_OFFSET, /* Bit 0 PWRON */ |
| 58 | PWR_INTR_OFFSET, /* Bit 1 RPWRON */ |
| 59 | PWR_INTR_OFFSET, /* Bit 2 BAT_VLOW */ |
| 60 | RTC_INTR_OFFSET, /* Bit 3 RTC_ALARM */ |
| 61 | RTC_INTR_OFFSET, /* Bit 4 RTC_PERIOD */ |
| 62 | HOTDIE_INTR_OFFSET, /* Bit 5 HOT_DIE */ |
| 63 | SMPSLDO_INTR_OFFSET, /* Bit 6 VXXX_SHORT */ |
| 64 | SMPSLDO_INTR_OFFSET, /* Bit 7 VMMC_SHORT */ |
| 65 | |
| 66 | SMPSLDO_INTR_OFFSET, /* Bit 8 VUSIM_SHORT */ |
| 67 | BATDETECT_INTR_OFFSET, /* Bit 9 BAT */ |
| 68 | SIMDETECT_INTR_OFFSET, /* Bit 10 SIM */ |
| 69 | MMCDETECT_INTR_OFFSET, /* Bit 11 MMC */ |
| 70 | RSV_INTR_OFFSET, /* Bit 12 Reserved */ |
| 71 | MADC_INTR_OFFSET, /* Bit 13 GPADC_RT_EOC */ |
| 72 | MADC_INTR_OFFSET, /* Bit 14 GPADC_SW_EOC */ |
| 73 | GASGAUGE_INTR_OFFSET, /* Bit 15 CC_AUTOCAL */ |
| 74 | |
| 75 | USBOTG_INTR_OFFSET, /* Bit 16 ID_WKUP */ |
| 76 | USBOTG_INTR_OFFSET, /* Bit 17 VBUS_WKUP */ |
| 77 | USBOTG_INTR_OFFSET, /* Bit 18 ID */ |
Hema HK | 77b1d3f | 2010-12-10 17:55:37 +0530 | [diff] [blame] | 78 | USB_PRES_INTR_OFFSET, /* Bit 19 VBUS */ |
Balaji T K | e8deb28 | 2009-12-14 00:25:31 +0100 | [diff] [blame] | 79 | CHARGER_INTR_OFFSET, /* Bit 20 CHRG_CTRL */ |
Graeme Gregory | 6523b14 | 2011-05-12 14:27:56 +0100 | [diff] [blame] | 80 | CHARGERFAULT_INTR_OFFSET, /* Bit 21 EXT_CHRG */ |
| 81 | CHARGERFAULT_INTR_OFFSET, /* Bit 22 INT_CHRG */ |
Balaji T K | e8deb28 | 2009-12-14 00:25:31 +0100 | [diff] [blame] | 82 | RSV_INTR_OFFSET, /* Bit 23 Reserved */ |
| 83 | }; |
| 84 | /*----------------------------------------------------------------------*/ |
| 85 | |
| 86 | static unsigned twl6030_irq_base; |
Todd Poynor | ab2b926 | 2011-10-04 11:52:29 +0200 | [diff] [blame] | 87 | static int twl_irq; |
| 88 | static bool twl_irq_wake_enabled; |
Balaji T K | e8deb28 | 2009-12-14 00:25:31 +0100 | [diff] [blame] | 89 | |
| 90 | static struct completion irq_event; |
Todd Poynor | ab2b926 | 2011-10-04 11:52:29 +0200 | [diff] [blame] | 91 | static atomic_t twl6030_wakeirqs = ATOMIC_INIT(0); |
| 92 | |
| 93 | static int twl6030_irq_pm_notifier(struct notifier_block *notifier, |
| 94 | unsigned long pm_event, void *unused) |
| 95 | { |
| 96 | int chained_wakeups; |
| 97 | |
| 98 | switch (pm_event) { |
| 99 | case PM_SUSPEND_PREPARE: |
| 100 | chained_wakeups = atomic_read(&twl6030_wakeirqs); |
| 101 | |
| 102 | if (chained_wakeups && !twl_irq_wake_enabled) { |
| 103 | if (enable_irq_wake(twl_irq)) |
| 104 | pr_err("twl6030 IRQ wake enable failed\n"); |
| 105 | else |
| 106 | twl_irq_wake_enabled = true; |
| 107 | } else if (!chained_wakeups && twl_irq_wake_enabled) { |
| 108 | disable_irq_wake(twl_irq); |
| 109 | twl_irq_wake_enabled = false; |
| 110 | } |
| 111 | |
Todd Poynor | 782baa2 | 2011-09-26 16:44:24 -0700 | [diff] [blame] | 112 | disable_irq(twl_irq); |
Todd Poynor | ab2b926 | 2011-10-04 11:52:29 +0200 | [diff] [blame] | 113 | break; |
Todd Poynor | 782baa2 | 2011-09-26 16:44:24 -0700 | [diff] [blame] | 114 | |
| 115 | case PM_POST_SUSPEND: |
| 116 | enable_irq(twl_irq); |
| 117 | break; |
| 118 | |
Todd Poynor | ab2b926 | 2011-10-04 11:52:29 +0200 | [diff] [blame] | 119 | default: |
| 120 | break; |
| 121 | } |
| 122 | |
| 123 | return NOTIFY_DONE; |
| 124 | } |
| 125 | |
| 126 | static struct notifier_block twl6030_irq_pm_notifier_block = { |
| 127 | .notifier_call = twl6030_irq_pm_notifier, |
| 128 | }; |
Balaji T K | e8deb28 | 2009-12-14 00:25:31 +0100 | [diff] [blame] | 129 | |
| 130 | /* |
| 131 | * This thread processes interrupts reported by the Primary Interrupt Handler. |
| 132 | */ |
| 133 | static int twl6030_irq_thread(void *data) |
| 134 | { |
| 135 | long irq = (long)data; |
| 136 | static unsigned i2c_errors; |
| 137 | static const unsigned max_i2c_errors = 100; |
| 138 | int ret; |
| 139 | |
| 140 | current->flags |= PF_NOFREEZE; |
| 141 | |
| 142 | while (!kthread_should_stop()) { |
| 143 | int i; |
| 144 | union { |
| 145 | u8 bytes[4]; |
| 146 | u32 int_sts; |
| 147 | } sts; |
| 148 | |
| 149 | /* Wait for IRQ, then read PIH irq status (also blocking) */ |
| 150 | wait_for_completion_interruptible(&irq_event); |
| 151 | |
| 152 | /* read INT_STS_A, B and C in one shot using a burst read */ |
| 153 | ret = twl_i2c_read(TWL_MODULE_PIH, sts.bytes, |
| 154 | REG_INT_STS_A, 3); |
| 155 | if (ret) { |
| 156 | pr_warning("twl6030: I2C error %d reading PIH ISR\n", |
| 157 | ret); |
| 158 | if (++i2c_errors >= max_i2c_errors) { |
| 159 | printk(KERN_ERR "Maximum I2C error count" |
| 160 | " exceeded. Terminating %s.\n", |
| 161 | __func__); |
| 162 | break; |
| 163 | } |
| 164 | complete(&irq_event); |
| 165 | continue; |
| 166 | } |
| 167 | |
| 168 | |
| 169 | |
| 170 | sts.bytes[3] = 0; /* Only 24 bits are valid*/ |
| 171 | |
Hema HK | 77b1d3f | 2010-12-10 17:55:37 +0530 | [diff] [blame] | 172 | /* |
| 173 | * Since VBUS status bit is not reliable for VBUS disconnect |
| 174 | * use CHARGER VBUS detection status bit instead. |
| 175 | */ |
| 176 | if (sts.bytes[2] & 0x10) |
| 177 | sts.bytes[2] |= 0x08; |
| 178 | |
Balaji T K | e8deb28 | 2009-12-14 00:25:31 +0100 | [diff] [blame] | 179 | for (i = 0; sts.int_sts; sts.int_sts >>= 1, i++) { |
| 180 | local_irq_disable(); |
| 181 | if (sts.int_sts & 0x1) { |
| 182 | int module_irq = twl6030_irq_base + |
| 183 | twl6030_interrupt_mapping[i]; |
Thomas Gleixner | c22435a | 2011-03-25 11:12:31 +0000 | [diff] [blame] | 184 | generic_handle_irq(module_irq); |
Balaji T K | e8deb28 | 2009-12-14 00:25:31 +0100 | [diff] [blame] | 185 | |
| 186 | } |
| 187 | local_irq_enable(); |
| 188 | } |
| 189 | ret = twl_i2c_write(TWL_MODULE_PIH, sts.bytes, |
| 190 | REG_INT_STS_A, 3); /* clear INT_STS_A */ |
| 191 | if (ret) |
| 192 | pr_warning("twl6030: I2C error in clearing PIH ISR\n"); |
| 193 | |
| 194 | enable_irq(irq); |
| 195 | } |
| 196 | |
| 197 | return 0; |
| 198 | } |
| 199 | |
| 200 | /* |
| 201 | * handle_twl6030_int() is the desc->handle method for the twl6030 interrupt. |
| 202 | * This is a chained interrupt, so there is no desc->action method for it. |
| 203 | * Now we need to query the interrupt controller in the twl6030 to determine |
| 204 | * which module is generating the interrupt request. However, we can't do i2c |
| 205 | * transactions in interrupt context, so we must defer that work to a kernel |
| 206 | * thread. All we do here is acknowledge and mask the interrupt and wakeup |
| 207 | * the kernel thread. |
| 208 | */ |
| 209 | static irqreturn_t handle_twl6030_pih(int irq, void *devid) |
| 210 | { |
| 211 | disable_irq_nosync(irq); |
| 212 | complete(devid); |
| 213 | return IRQ_HANDLED; |
| 214 | } |
| 215 | |
| 216 | /*----------------------------------------------------------------------*/ |
| 217 | |
| 218 | static inline void activate_irq(int irq) |
| 219 | { |
| 220 | #ifdef CONFIG_ARM |
| 221 | /* ARM requires an extra step to clear IRQ_NOREQUEST, which it |
| 222 | * sets on behalf of every irq_chip. Also sets IRQ_NOPROBE. |
| 223 | */ |
| 224 | set_irq_flags(irq, IRQF_VALID); |
| 225 | #else |
| 226 | /* same effect on other architectures */ |
Thomas Gleixner | d5bb122 | 2011-03-25 11:12:32 +0000 | [diff] [blame] | 227 | irq_set_noprobe(irq); |
Balaji T K | e8deb28 | 2009-12-14 00:25:31 +0100 | [diff] [blame] | 228 | #endif |
| 229 | } |
| 230 | |
Santosh Shilimkar | 49dcd07 | 2011-09-06 21:29:30 +0530 | [diff] [blame] | 231 | int twl6030_irq_set_wake(struct irq_data *d, unsigned int on) |
| 232 | { |
Todd Poynor | ab2b926 | 2011-10-04 11:52:29 +0200 | [diff] [blame] | 233 | if (on) |
| 234 | atomic_inc(&twl6030_wakeirqs); |
| 235 | else |
| 236 | atomic_dec(&twl6030_wakeirqs); |
Santosh Shilimkar | 49dcd07 | 2011-09-06 21:29:30 +0530 | [diff] [blame] | 237 | |
Todd Poynor | ab2b926 | 2011-10-04 11:52:29 +0200 | [diff] [blame] | 238 | return 0; |
Santosh Shilimkar | 49dcd07 | 2011-09-06 21:29:30 +0530 | [diff] [blame] | 239 | } |
| 240 | |
Balaji T K | e8deb28 | 2009-12-14 00:25:31 +0100 | [diff] [blame] | 241 | /*----------------------------------------------------------------------*/ |
| 242 | |
| 243 | static unsigned twl6030_irq_next; |
| 244 | |
| 245 | /*----------------------------------------------------------------------*/ |
| 246 | int twl6030_interrupt_unmask(u8 bit_mask, u8 offset) |
| 247 | { |
| 248 | int ret; |
| 249 | u8 unmask_value; |
| 250 | ret = twl_i2c_read_u8(TWL_MODULE_PIH, &unmask_value, |
| 251 | REG_INT_STS_A + offset); |
| 252 | unmask_value &= (~(bit_mask)); |
| 253 | ret |= twl_i2c_write_u8(TWL_MODULE_PIH, unmask_value, |
| 254 | REG_INT_STS_A + offset); /* unmask INT_MSK_A/B/C */ |
| 255 | return ret; |
| 256 | } |
| 257 | EXPORT_SYMBOL(twl6030_interrupt_unmask); |
| 258 | |
| 259 | int twl6030_interrupt_mask(u8 bit_mask, u8 offset) |
| 260 | { |
| 261 | int ret; |
| 262 | u8 mask_value; |
| 263 | ret = twl_i2c_read_u8(TWL_MODULE_PIH, &mask_value, |
| 264 | REG_INT_STS_A + offset); |
| 265 | mask_value |= (bit_mask); |
| 266 | ret |= twl_i2c_write_u8(TWL_MODULE_PIH, mask_value, |
| 267 | REG_INT_STS_A + offset); /* mask INT_MSK_A/B/C */ |
| 268 | return ret; |
| 269 | } |
| 270 | EXPORT_SYMBOL(twl6030_interrupt_mask); |
| 271 | |
kishore kadiyala | 72f2e2c | 2010-09-24 17:13:20 +0000 | [diff] [blame] | 272 | int twl6030_mmc_card_detect_config(void) |
| 273 | { |
| 274 | int ret; |
| 275 | u8 reg_val = 0; |
| 276 | |
| 277 | /* Unmasking the Card detect Interrupt line for MMC1 from Phoenix */ |
| 278 | twl6030_interrupt_unmask(TWL6030_MMCDETECT_INT_MASK, |
| 279 | REG_INT_MSK_LINE_B); |
| 280 | twl6030_interrupt_unmask(TWL6030_MMCDETECT_INT_MASK, |
| 281 | REG_INT_MSK_STS_B); |
| 282 | /* |
Lucas De Marchi | 25985ed | 2011-03-30 22:57:33 -0300 | [diff] [blame] | 283 | * Initially Configuring MMC_CTRL for receiving interrupts & |
kishore kadiyala | 72f2e2c | 2010-09-24 17:13:20 +0000 | [diff] [blame] | 284 | * Card status on TWL6030 for MMC1 |
| 285 | */ |
| 286 | ret = twl_i2c_read_u8(TWL6030_MODULE_ID0, ®_val, TWL6030_MMCCTRL); |
| 287 | if (ret < 0) { |
| 288 | pr_err("twl6030: Failed to read MMCCTRL, error %d\n", ret); |
| 289 | return ret; |
| 290 | } |
| 291 | reg_val &= ~VMMC_AUTO_OFF; |
| 292 | reg_val |= SW_FC; |
| 293 | ret = twl_i2c_write_u8(TWL6030_MODULE_ID0, reg_val, TWL6030_MMCCTRL); |
| 294 | if (ret < 0) { |
| 295 | pr_err("twl6030: Failed to write MMCCTRL, error %d\n", ret); |
| 296 | return ret; |
| 297 | } |
| 298 | |
| 299 | /* Configuring PullUp-PullDown register */ |
| 300 | ret = twl_i2c_read_u8(TWL6030_MODULE_ID0, ®_val, |
| 301 | TWL6030_CFG_INPUT_PUPD3); |
| 302 | if (ret < 0) { |
| 303 | pr_err("twl6030: Failed to read CFG_INPUT_PUPD3, error %d\n", |
| 304 | ret); |
| 305 | return ret; |
| 306 | } |
| 307 | reg_val &= ~(MMC_PU | MMC_PD); |
| 308 | ret = twl_i2c_write_u8(TWL6030_MODULE_ID0, reg_val, |
| 309 | TWL6030_CFG_INPUT_PUPD3); |
| 310 | if (ret < 0) { |
| 311 | pr_err("twl6030: Failed to write CFG_INPUT_PUPD3, error %d\n", |
| 312 | ret); |
| 313 | return ret; |
| 314 | } |
| 315 | return 0; |
| 316 | } |
| 317 | EXPORT_SYMBOL(twl6030_mmc_card_detect_config); |
| 318 | |
| 319 | int twl6030_mmc_card_detect(struct device *dev, int slot) |
| 320 | { |
| 321 | int ret = -EIO; |
| 322 | u8 read_reg = 0; |
| 323 | struct platform_device *pdev = to_platform_device(dev); |
| 324 | |
| 325 | if (pdev->id) { |
| 326 | /* TWL6030 provide's Card detect support for |
| 327 | * only MMC1 controller. |
| 328 | */ |
Lucas De Marchi | 25985ed | 2011-03-30 22:57:33 -0300 | [diff] [blame] | 329 | pr_err("Unknown MMC controller %d in %s\n", pdev->id, __func__); |
kishore kadiyala | 72f2e2c | 2010-09-24 17:13:20 +0000 | [diff] [blame] | 330 | return ret; |
| 331 | } |
| 332 | /* |
| 333 | * BIT0 of MMC_CTRL on TWL6030 provides card status for MMC1 |
| 334 | * 0 - Card not present ,1 - Card present |
| 335 | */ |
| 336 | ret = twl_i2c_read_u8(TWL6030_MODULE_ID0, &read_reg, |
| 337 | TWL6030_MMCCTRL); |
| 338 | if (ret >= 0) |
| 339 | ret = read_reg & STS_MMC; |
| 340 | return ret; |
| 341 | } |
| 342 | EXPORT_SYMBOL(twl6030_mmc_card_detect); |
| 343 | |
Balaji T K | e8deb28 | 2009-12-14 00:25:31 +0100 | [diff] [blame] | 344 | int twl6030_init_irq(int irq_num, unsigned irq_base, unsigned irq_end) |
| 345 | { |
| 346 | |
| 347 | int status = 0; |
| 348 | int i; |
| 349 | struct task_struct *task; |
| 350 | int ret; |
| 351 | u8 mask[4]; |
| 352 | |
| 353 | static struct irq_chip twl6030_irq_chip; |
| 354 | mask[1] = 0xFF; |
| 355 | mask[2] = 0xFF; |
| 356 | mask[3] = 0xFF; |
| 357 | ret = twl_i2c_write(TWL_MODULE_PIH, &mask[0], |
| 358 | REG_INT_MSK_LINE_A, 3); /* MASK ALL INT LINES */ |
| 359 | ret = twl_i2c_write(TWL_MODULE_PIH, &mask[0], |
| 360 | REG_INT_MSK_STS_A, 3); /* MASK ALL INT STS */ |
| 361 | ret = twl_i2c_write(TWL_MODULE_PIH, &mask[0], |
| 362 | REG_INT_STS_A, 3); /* clear INT_STS_A,B,C */ |
| 363 | |
| 364 | twl6030_irq_base = irq_base; |
| 365 | |
| 366 | /* install an irq handler for each of the modules; |
| 367 | * clone dummy irq_chip since PIH can't *do* anything |
| 368 | */ |
| 369 | twl6030_irq_chip = dummy_irq_chip; |
| 370 | twl6030_irq_chip.name = "twl6030"; |
Lennert Buytenhek | c45c685 | 2010-12-13 13:31:18 +0100 | [diff] [blame] | 371 | twl6030_irq_chip.irq_set_type = NULL; |
Santosh Shilimkar | 49dcd07 | 2011-09-06 21:29:30 +0530 | [diff] [blame] | 372 | twl6030_irq_chip.irq_set_wake = twl6030_irq_set_wake; |
Balaji T K | e8deb28 | 2009-12-14 00:25:31 +0100 | [diff] [blame] | 373 | |
| 374 | for (i = irq_base; i < irq_end; i++) { |
Thomas Gleixner | d5bb122 | 2011-03-25 11:12:32 +0000 | [diff] [blame] | 375 | irq_set_chip_and_handler(i, &twl6030_irq_chip, |
| 376 | handle_simple_irq); |
Santosh Shilimkar | 49dcd07 | 2011-09-06 21:29:30 +0530 | [diff] [blame] | 377 | irq_set_chip_data(i, (void *)irq_num); |
Balaji T K | e8deb28 | 2009-12-14 00:25:31 +0100 | [diff] [blame] | 378 | activate_irq(i); |
| 379 | } |
| 380 | |
| 381 | twl6030_irq_next = i; |
| 382 | pr_info("twl6030: %s (irq %d) chaining IRQs %d..%d\n", "PIH", |
| 383 | irq_num, irq_base, twl6030_irq_next - 1); |
| 384 | |
| 385 | /* install an irq handler to demultiplex the TWL6030 interrupt */ |
| 386 | init_completion(&irq_event); |
Balaji T K | e8deb28 | 2009-12-14 00:25:31 +0100 | [diff] [blame] | 387 | |
Yong Zhang | f742b96 | 2011-09-15 21:52:09 +0200 | [diff] [blame] | 388 | status = request_irq(irq_num, handle_twl6030_pih, 0, |
Balaji T K | e8deb28 | 2009-12-14 00:25:31 +0100 | [diff] [blame] | 389 | "TWL6030-PIH", &irq_event); |
| 390 | if (status < 0) { |
| 391 | pr_err("twl6030: could not claim irq%d: %d\n", irq_num, status); |
| 392 | goto fail_irq; |
| 393 | } |
Axel Lin | 862de70 | 2011-08-11 15:21:00 +0800 | [diff] [blame] | 394 | |
| 395 | task = kthread_run(twl6030_irq_thread, (void *)irq_num, "twl6030-irq"); |
| 396 | if (IS_ERR(task)) { |
| 397 | pr_err("twl6030: could not create irq %d thread!\n", irq_num); |
| 398 | status = PTR_ERR(task); |
| 399 | goto fail_kthread; |
| 400 | } |
Todd Poynor | ab2b926 | 2011-10-04 11:52:29 +0200 | [diff] [blame] | 401 | |
| 402 | twl_irq = irq_num; |
| 403 | register_pm_notifier(&twl6030_irq_pm_notifier_block); |
Balaji T K | e8deb28 | 2009-12-14 00:25:31 +0100 | [diff] [blame] | 404 | return status; |
Balaji T K | e8deb28 | 2009-12-14 00:25:31 +0100 | [diff] [blame] | 405 | |
| 406 | fail_kthread: |
Axel Lin | 862de70 | 2011-08-11 15:21:00 +0800 | [diff] [blame] | 407 | free_irq(irq_num, &irq_event); |
| 408 | |
| 409 | fail_irq: |
Balaji T K | e8deb28 | 2009-12-14 00:25:31 +0100 | [diff] [blame] | 410 | for (i = irq_base; i < irq_end; i++) |
Thomas Gleixner | d5bb122 | 2011-03-25 11:12:32 +0000 | [diff] [blame] | 411 | irq_set_chip_and_handler(i, NULL, NULL); |
Balaji T K | e8deb28 | 2009-12-14 00:25:31 +0100 | [diff] [blame] | 412 | return status; |
| 413 | } |
| 414 | |
| 415 | int twl6030_exit_irq(void) |
| 416 | { |
Todd Poynor | ab2b926 | 2011-10-04 11:52:29 +0200 | [diff] [blame] | 417 | unregister_pm_notifier(&twl6030_irq_pm_notifier_block); |
Balaji T K | e8deb28 | 2009-12-14 00:25:31 +0100 | [diff] [blame] | 418 | |
| 419 | if (twl6030_irq_base) { |
| 420 | pr_err("twl6030: can't yet clean up IRQs?\n"); |
| 421 | return -ENOSYS; |
| 422 | } |
| 423 | return 0; |
| 424 | } |
| 425 | |