| 1 | --- a/arch/arm/mach-omap1/board-palmz71.c |
| 2 | +++ b/arch/arm/mach-omap1/board-palmz71.c |
| 3 | @@ -291,8 +291,7 @@ palmz71_gpio_setup(int early) |
| 4 | } |
| 5 | gpio_direction_input(PALMZ71_USBDETECT_GPIO); |
| 6 | if (request_irq(gpio_to_irq(PALMZ71_USBDETECT_GPIO), |
| 7 | - palmz71_powercable, IRQF_SAMPLE_RANDOM, |
| 8 | - "palmz71-cable", 0)) |
| 9 | + palmz71_powercable, 0, "palmz71-cable", 0)) |
| 10 | printk(KERN_ERR |
| 11 | "IRQ request for power cable failed!\n"); |
| 12 | palmz71_powercable(gpio_to_irq(PALMZ71_USBDETECT_GPIO), 0); |
| 13 | --- a/arch/arm/mach-pxa/lubbock.c |
| 14 | +++ b/arch/arm/mach-pxa/lubbock.c |
| 15 | @@ -455,7 +455,7 @@ static int lubbock_mci_init(struct devic |
| 16 | init_timer(&mmc_timer); |
| 17 | mmc_timer.data = (unsigned long) data; |
| 18 | return request_irq(LUBBOCK_SD_IRQ, lubbock_detect_int, |
| 19 | - IRQF_SAMPLE_RANDOM, "lubbock-sd-detect", data); |
| 20 | + 0, "lubbock-sd-detect", data); |
| 21 | } |
| 22 | |
| 23 | static int lubbock_mci_get_ro(struct device *dev) |
| 24 | --- a/arch/arm/mach-pxa/magician.c |
| 25 | +++ b/arch/arm/mach-pxa/magician.c |
| 26 | @@ -617,9 +617,8 @@ static struct platform_device bq24022 = |
| 27 | static int magician_mci_init(struct device *dev, |
| 28 | irq_handler_t detect_irq, void *data) |
| 29 | { |
| 30 | - return request_irq(IRQ_MAGICIAN_SD, detect_irq, |
| 31 | - IRQF_DISABLED | IRQF_SAMPLE_RANDOM, |
| 32 | - "mmc card detect", data); |
| 33 | + return request_irq(IRQ_MAGICIAN_SD, detect_irq, IRQF_DISABLED, |
| 34 | + "mmc card detect", data); |
| 35 | } |
| 36 | |
| 37 | static void magician_mci_exit(struct device *dev, void *data) |
| 38 | --- a/arch/arm/mach-pxa/trizeps4.c |
| 39 | +++ b/arch/arm/mach-pxa/trizeps4.c |
| 40 | @@ -332,8 +332,8 @@ static int trizeps4_mci_init(struct devi |
| 41 | int err; |
| 42 | |
| 43 | err = request_irq(TRIZEPS4_MMC_IRQ, mci_detect_int, |
| 44 | - IRQF_DISABLED | IRQF_TRIGGER_RISING | IRQF_SAMPLE_RANDOM, |
| 45 | - "MMC card detect", data); |
| 46 | + IRQF_DISABLED | IRQF_TRIGGER_RISING, |
| 47 | + "MMC card detect", data); |
| 48 | if (err) { |
| 49 | printk(KERN_ERR "trizeps4_mci_init: MMC/SD: can't request" |
| 50 | "MMC card detect IRQ\n"); |
| 51 | --- a/arch/ia64/kernel/irq_ia64.c |
| 52 | +++ b/arch/ia64/kernel/irq_ia64.c |
| 53 | @@ -23,7 +23,6 @@ |
| 54 | #include <linux/ioport.h> |
| 55 | #include <linux/kernel_stat.h> |
| 56 | #include <linux/ptrace.h> |
| 57 | -#include <linux/random.h> /* for rand_initialize_irq() */ |
| 58 | #include <linux/signal.h> |
| 59 | #include <linux/smp.h> |
| 60 | #include <linux/threads.h> |
| 61 | --- a/arch/sparc/kernel/ldc.c |
| 62 | +++ b/arch/sparc/kernel/ldc.c |
| 63 | @@ -1250,14 +1250,12 @@ int ldc_bind(struct ldc_channel *lp, con |
| 64 | snprintf(lp->rx_irq_name, LDC_IRQ_NAME_MAX, "%s RX", name); |
| 65 | snprintf(lp->tx_irq_name, LDC_IRQ_NAME_MAX, "%s TX", name); |
| 66 | |
| 67 | - err = request_irq(lp->cfg.rx_irq, ldc_rx, |
| 68 | - IRQF_SAMPLE_RANDOM | IRQF_DISABLED, |
| 69 | + err = request_irq(lp->cfg.rx_irq, ldc_rx, IRQF_DISABLED, |
| 70 | lp->rx_irq_name, lp); |
| 71 | if (err) |
| 72 | return err; |
| 73 | |
| 74 | - err = request_irq(lp->cfg.tx_irq, ldc_tx, |
| 75 | - IRQF_SAMPLE_RANDOM | IRQF_DISABLED, |
| 76 | + err = request_irq(lp->cfg.tx_irq, ldc_tx, IRQF_DISABLED, |
| 77 | lp->tx_irq_name, lp); |
| 78 | if (err) { |
| 79 | free_irq(lp->cfg.rx_irq, lp); |
| 80 | --- a/arch/um/drivers/line.c |
| 81 | +++ b/arch/um/drivers/line.c |
| 82 | @@ -371,7 +371,7 @@ static irqreturn_t line_write_interrupt( |
| 83 | int line_setup_irq(int fd, int input, int output, struct line *line, void *data) |
| 84 | { |
| 85 | const struct line_driver *driver = line->driver; |
| 86 | - int err = 0, flags = IRQF_DISABLED | IRQF_SHARED | IRQF_SAMPLE_RANDOM; |
| 87 | + int err = 0, flags = IRQF_DISABLED | IRQF_SHARED; |
| 88 | |
| 89 | if (input) |
| 90 | err = um_request_irq(driver->read_irq, fd, IRQ_READ, |
| 91 | @@ -807,7 +807,7 @@ void register_winch_irq(int fd, int tty_ |
| 92 | .stack = stack }); |
| 93 | |
| 94 | if (um_request_irq(WINCH_IRQ, fd, IRQ_READ, winch_interrupt, |
| 95 | - IRQF_DISABLED | IRQF_SHARED | IRQF_SAMPLE_RANDOM, |
| 96 | + IRQF_DISABLED | IRQF_SHARED, |
| 97 | "winch", winch) < 0) { |
| 98 | printk(KERN_ERR "register_winch_irq - failed to register " |
| 99 | "IRQ\n"); |
| 100 | --- a/arch/um/drivers/mconsole_kern.c |
| 101 | +++ b/arch/um/drivers/mconsole_kern.c |
| 102 | @@ -773,7 +773,7 @@ static int __init mconsole_init(void) |
| 103 | register_reboot_notifier(&reboot_notifier); |
| 104 | |
| 105 | err = um_request_irq(MCONSOLE_IRQ, sock, IRQ_READ, mconsole_interrupt, |
| 106 | - IRQF_DISABLED | IRQF_SHARED | IRQF_SAMPLE_RANDOM, |
| 107 | + IRQF_DISABLED | IRQF_SHARED, |
| 108 | "mconsole", (void *)sock); |
| 109 | if (err) { |
| 110 | printk(KERN_ERR "Failed to get IRQ for management console\n"); |
| 111 | --- a/arch/um/drivers/port_kern.c |
| 112 | +++ b/arch/um/drivers/port_kern.c |
| 113 | @@ -100,7 +100,7 @@ static int port_accept(struct port_list |
| 114 | .port = port }); |
| 115 | |
| 116 | if (um_request_irq(TELNETD_IRQ, socket[0], IRQ_READ, pipe_interrupt, |
| 117 | - IRQF_DISABLED | IRQF_SHARED | IRQF_SAMPLE_RANDOM, |
| 118 | + IRQF_DISABLED | IRQF_SHARED, |
| 119 | "telnetd", conn)) { |
| 120 | printk(KERN_ERR "port_accept : failed to get IRQ for " |
| 121 | "telnetd\n"); |
| 122 | @@ -184,7 +184,7 @@ void *port_data(int port_num) |
| 123 | } |
| 124 | |
| 125 | if (um_request_irq(ACCEPT_IRQ, fd, IRQ_READ, port_interrupt, |
| 126 | - IRQF_DISABLED | IRQF_SHARED | IRQF_SAMPLE_RANDOM, |
| 127 | + IRQF_DISABLED | IRQF_SHARED, |
| 128 | "port", port)) { |
| 129 | printk(KERN_ERR "Failed to get IRQ for port %d\n", port_num); |
| 130 | goto out_close; |
| 131 | --- a/arch/um/drivers/random.c |
| 132 | +++ b/arch/um/drivers/random.c |
| 133 | @@ -131,8 +131,7 @@ static int __init rng_init (void) |
| 134 | random_fd = err; |
| 135 | |
| 136 | err = um_request_irq(RANDOM_IRQ, random_fd, IRQ_READ, random_interrupt, |
| 137 | - IRQF_DISABLED | IRQF_SAMPLE_RANDOM, "random", |
| 138 | - NULL); |
| 139 | + IRQF_DISABLED, "random", NULL); |
| 140 | if (err) |
| 141 | goto err_out_cleanup_hw; |
| 142 | |
| 143 | --- a/arch/um/drivers/xterm_kern.c |
| 144 | +++ b/arch/um/drivers/xterm_kern.c |
| 145 | @@ -50,8 +50,7 @@ int xterm_fd(int socket, int *pid_out) |
| 146 | init_completion(&data->ready); |
| 147 | |
| 148 | err = um_request_irq(XTERM_IRQ, socket, IRQ_READ, xterm_interrupt, |
| 149 | - IRQF_DISABLED | IRQF_SHARED | IRQF_SAMPLE_RANDOM, |
| 150 | - "xterm", data); |
| 151 | + IRQF_DISABLED | IRQF_SHARED, "xterm", data); |
| 152 | if (err) { |
| 153 | printk(KERN_ERR "xterm_fd : failed to get IRQ for xterm, " |
| 154 | "err = %d\n", err); |
| 155 | --- a/arch/um/kernel/sigio.c |
| 156 | +++ b/arch/um/kernel/sigio.c |
| 157 | @@ -25,8 +25,7 @@ int write_sigio_irq(int fd) |
| 158 | int err; |
| 159 | |
| 160 | err = um_request_irq(SIGIO_WRITE_IRQ, fd, IRQ_READ, sigio_interrupt, |
| 161 | - IRQF_DISABLED|IRQF_SAMPLE_RANDOM, "write sigio", |
| 162 | - NULL); |
| 163 | + IRQF_DISABLED, "write sigio", NULL); |
| 164 | if (err) { |
| 165 | printk(KERN_ERR "write_sigio_irq : um_request_irq failed, " |
| 166 | "err = %d\n", err); |
| 167 | --- a/Documentation/feature-removal-schedule.txt |
| 168 | +++ b/Documentation/feature-removal-schedule.txt |
| 169 | @@ -71,20 +71,6 @@ Who: Luis R. Rodriguez <lrodriguez@ather |
| 170 | |
| 171 | --------------------------- |
| 172 | |
| 173 | -What: IRQF_SAMPLE_RANDOM |
| 174 | -Check: IRQF_SAMPLE_RANDOM |
| 175 | -When: July 2009 |
| 176 | - |
| 177 | -Why: Many of IRQF_SAMPLE_RANDOM users are technically bogus as entropy |
| 178 | - sources in the kernel's current entropy model. To resolve this, every |
| 179 | - input point to the kernel's entropy pool needs to better document the |
| 180 | - type of entropy source it actually is. This will be replaced with |
| 181 | - additional add_*_randomness functions in drivers/char/random.c |
| 182 | - |
| 183 | -Who: Robin Getz <rgetz@blackfin.uclinux.org> & Matt Mackall <mpm@selenic.com> |
| 184 | - |
| 185 | ---------------------------- |
| 186 | - |
| 187 | What: The ieee80211_regdom module parameter |
| 188 | When: March 2010 / desktop catchup |
| 189 | |
| 190 | --- a/drivers/block/xen-blkfront.c |
| 191 | +++ b/drivers/block/xen-blkfront.c |
| 192 | @@ -852,9 +852,8 @@ static int setup_blkring(struct xenbus_d |
| 193 | if (err) |
| 194 | goto fail; |
| 195 | |
| 196 | - err = bind_evtchn_to_irqhandler(info->evtchn, |
| 197 | - blkif_interrupt, |
| 198 | - IRQF_SAMPLE_RANDOM, "blkif", info); |
| 199 | + err = bind_evtchn_to_irqhandler(info->evtchn, blkif_interrupt, 0, |
| 200 | + "blkif", info); |
| 201 | if (err <= 0) { |
| 202 | xenbus_dev_fatal(dev, err, |
| 203 | "bind_evtchn_to_irqhandler failed"); |
| 204 | --- a/drivers/char/random.c |
| 205 | +++ b/drivers/char/random.c |
| 206 | @@ -633,43 +633,6 @@ struct timer_rand_state { |
| 207 | unsigned dont_count_entropy:1; |
| 208 | }; |
| 209 | |
| 210 | -#ifndef CONFIG_GENERIC_HARDIRQS |
| 211 | - |
| 212 | -static struct timer_rand_state *irq_timer_state[NR_IRQS]; |
| 213 | - |
| 214 | -static struct timer_rand_state *get_timer_rand_state(unsigned int irq) |
| 215 | -{ |
| 216 | - return irq_timer_state[irq]; |
| 217 | -} |
| 218 | - |
| 219 | -static void set_timer_rand_state(unsigned int irq, |
| 220 | - struct timer_rand_state *state) |
| 221 | -{ |
| 222 | - irq_timer_state[irq] = state; |
| 223 | -} |
| 224 | - |
| 225 | -#else |
| 226 | - |
| 227 | -static struct timer_rand_state *get_timer_rand_state(unsigned int irq) |
| 228 | -{ |
| 229 | - struct irq_desc *desc; |
| 230 | - |
| 231 | - desc = irq_to_desc(irq); |
| 232 | - |
| 233 | - return desc->timer_rand_state; |
| 234 | -} |
| 235 | - |
| 236 | -static void set_timer_rand_state(unsigned int irq, |
| 237 | - struct timer_rand_state *state) |
| 238 | -{ |
| 239 | - struct irq_desc *desc; |
| 240 | - |
| 241 | - desc = irq_to_desc(irq); |
| 242 | - |
| 243 | - desc->timer_rand_state = state; |
| 244 | -} |
| 245 | -#endif |
| 246 | - |
| 247 | /* |
| 248 | * Add device- or boot-specific data to the input and nonblocking |
| 249 | * pools to help initialize them to unique values. |
| 250 | @@ -1131,24 +1094,6 @@ static int rand_initialize(void) |
| 251 | } |
| 252 | module_init(rand_initialize); |
| 253 | |
| 254 | -void rand_initialize_irq(int irq) |
| 255 | -{ |
| 256 | - struct timer_rand_state *state; |
| 257 | - |
| 258 | - state = get_timer_rand_state(irq); |
| 259 | - |
| 260 | - if (state) |
| 261 | - return; |
| 262 | - |
| 263 | - /* |
| 264 | - * If kzalloc returns null, we just won't use that entropy |
| 265 | - * source. |
| 266 | - */ |
| 267 | - state = kzalloc(sizeof(struct timer_rand_state), GFP_KERNEL); |
| 268 | - if (state) |
| 269 | - set_timer_rand_state(irq, state); |
| 270 | -} |
| 271 | - |
| 272 | #ifdef CONFIG_BLOCK |
| 273 | void rand_initialize_disk(struct gendisk *disk) |
| 274 | { |
| 275 | --- a/drivers/crypto/n2_core.c |
| 276 | +++ b/drivers/crypto/n2_core.c |
| 277 | @@ -1607,8 +1607,7 @@ static int spu_map_ino(struct platform_d |
| 278 | |
| 279 | sprintf(p->irq_name, "%s-%d", irq_name, index); |
| 280 | |
| 281 | - return request_irq(p->irq, handler, IRQF_SAMPLE_RANDOM, |
| 282 | - p->irq_name, p); |
| 283 | + return request_irq(p->irq, handler, 0, p->irq_name, p); |
| 284 | } |
| 285 | |
| 286 | static struct kmem_cache *queue_cache[2]; |
| 287 | --- a/drivers/hv/vmbus_drv.c |
| 288 | +++ b/drivers/hv/vmbus_drv.c |
| 289 | @@ -545,8 +545,7 @@ static int vmbus_bus_init(int irq) |
| 290 | if (ret) |
| 291 | goto err_cleanup; |
| 292 | |
| 293 | - ret = request_irq(irq, vmbus_isr, IRQF_SAMPLE_RANDOM, |
| 294 | - driver_name, hv_acpi_dev); |
| 295 | + ret = request_irq(irq, vmbus_isr, 0, driver_name, hv_acpi_dev); |
| 296 | |
| 297 | if (ret != 0) { |
| 298 | pr_err("Unable to request IRQ %d\n", |
| 299 | --- a/drivers/i2c/busses/i2c-pmcmsp.c |
| 300 | +++ b/drivers/i2c/busses/i2c-pmcmsp.c |
| 301 | @@ -306,8 +306,7 @@ static int __devinit pmcmsptwi_probe(str |
| 302 | pmcmsptwi_data.irq = platform_get_irq(pldev, 0); |
| 303 | if (pmcmsptwi_data.irq) { |
| 304 | rc = request_irq(pmcmsptwi_data.irq, &pmcmsptwi_interrupt, |
| 305 | - IRQF_SHARED | IRQF_SAMPLE_RANDOM, |
| 306 | - pldev->name, &pmcmsptwi_data); |
| 307 | + IRQF_SHARED, pldev->name, &pmcmsptwi_data); |
| 308 | if (rc == 0) { |
| 309 | /* |
| 310 | * Enable 'DONE' interrupt only. |
| 311 | --- a/drivers/input/serio/hp_sdc.c |
| 312 | +++ b/drivers/input/serio/hp_sdc.c |
| 313 | @@ -879,7 +879,7 @@ static int __init hp_sdc_init(void) |
| 314 | #endif |
| 315 | |
| 316 | errstr = "IRQ not available for"; |
| 317 | - if (request_irq(hp_sdc.irq, &hp_sdc_isr, IRQF_SHARED|IRQF_SAMPLE_RANDOM, |
| 318 | + if (request_irq(hp_sdc.irq, &hp_sdc_isr, IRQF_SHARED, |
| 319 | "HP SDC", &hp_sdc)) |
| 320 | goto err1; |
| 321 | |
| 322 | --- a/drivers/mfd/ab3100-core.c |
| 323 | +++ b/drivers/mfd/ab3100-core.c |
| 324 | @@ -937,9 +937,6 @@ static int __devinit ab3100_probe(struct |
| 325 | |
| 326 | err = request_threaded_irq(client->irq, NULL, ab3100_irq_handler, |
| 327 | IRQF_ONESHOT, "ab3100-core", ab3100); |
| 328 | - /* This real unpredictable IRQ is of course sampled for entropy */ |
| 329 | - rand_initialize_irq(client->irq); |
| 330 | - |
| 331 | if (err) |
| 332 | goto exit_no_irq; |
| 333 | |
| 334 | --- a/drivers/mfd/tps65010.c |
| 335 | +++ b/drivers/mfd/tps65010.c |
| 336 | @@ -563,8 +563,7 @@ static int tps65010_probe(struct i2c_cli |
| 337 | */ |
| 338 | if (client->irq > 0) { |
| 339 | status = request_irq(client->irq, tps65010_irq, |
| 340 | - IRQF_SAMPLE_RANDOM | IRQF_TRIGGER_FALLING, |
| 341 | - DRIVER_NAME, tps); |
| 342 | + IRQF_TRIGGER_FALLING, DRIVER_NAME, tps); |
| 343 | if (status < 0) { |
| 344 | dev_dbg(&client->dev, "can't get IRQ %d, err %d\n", |
| 345 | client->irq, status); |
| 346 | --- a/drivers/net/ethernet/broadcom/tg3.c |
| 347 | +++ b/drivers/net/ethernet/broadcom/tg3.c |
| 348 | @@ -9415,7 +9415,7 @@ static int tg3_test_interrupt(struct tg3 |
| 349 | } |
| 350 | |
| 351 | err = request_irq(tnapi->irq_vec, tg3_test_isr, |
| 352 | - IRQF_SHARED | IRQF_SAMPLE_RANDOM, dev->name, tnapi); |
| 353 | + IRQF_SHARED, dev->name, tnapi); |
| 354 | if (err) |
| 355 | return err; |
| 356 | |
| 357 | --- a/drivers/power/pda_power.c |
| 358 | +++ b/drivers/power/pda_power.c |
| 359 | @@ -24,11 +24,7 @@ |
| 360 | |
| 361 | static inline unsigned int get_irq_flags(struct resource *res) |
| 362 | { |
| 363 | - unsigned int flags = IRQF_SAMPLE_RANDOM | IRQF_SHARED; |
| 364 | - |
| 365 | - flags |= res->flags & IRQF_TRIGGER_MASK; |
| 366 | - |
| 367 | - return flags; |
| 368 | + return IRQF_SHARED | (res->flags & IRQF_TRIGGER_MASK); |
| 369 | } |
| 370 | |
| 371 | static struct device *dev; |
| 372 | --- a/drivers/tty/serial/uartlite.c |
| 373 | +++ b/drivers/tty/serial/uartlite.c |
| 374 | @@ -216,8 +216,7 @@ static int ulite_startup(struct uart_por |
| 375 | { |
| 376 | int ret; |
| 377 | |
| 378 | - ret = request_irq(port->irq, ulite_isr, |
| 379 | - IRQF_SHARED | IRQF_SAMPLE_RANDOM, "uartlite", port); |
| 380 | + ret = request_irq(port->irq, ulite_isr, IRQF_SHARED, "uartlite", port); |
| 381 | if (ret) |
| 382 | return ret; |
| 383 | |
| 384 | --- a/drivers/usb/gadget/goku_udc.c |
| 385 | +++ b/drivers/usb/gadget/goku_udc.c |
| 386 | @@ -1839,7 +1839,7 @@ static int goku_probe(struct pci_dev *pd |
| 387 | /* init to known state, then setup irqs */ |
| 388 | udc_reset(dev); |
| 389 | udc_reinit (dev); |
| 390 | - if (request_irq(pdev->irq, goku_irq, IRQF_SHARED/*|IRQF_SAMPLE_RANDOM*/, |
| 391 | + if (request_irq(pdev->irq, goku_irq, IRQF_SHARED, |
| 392 | driver_name, dev) != 0) { |
| 393 | DBG(dev, "request interrupt %d failed\n", pdev->irq); |
| 394 | retval = -EBUSY; |
| 395 | --- a/drivers/usb/gadget/omap_udc.c |
| 396 | +++ b/drivers/usb/gadget/omap_udc.c |
| 397 | @@ -2943,7 +2943,7 @@ known: |
| 398 | |
| 399 | /* USB general purpose IRQ: ep0, state changes, dma, etc */ |
| 400 | status = request_irq(pdev->resource[1].start, omap_udc_irq, |
| 401 | - IRQF_SAMPLE_RANDOM, driver_name, udc); |
| 402 | + 0, driver_name, udc); |
| 403 | if (status != 0) { |
| 404 | ERR("can't get irq %d, err %d\n", |
| 405 | (int) pdev->resource[1].start, status); |
| 406 | @@ -2952,7 +2952,7 @@ known: |
| 407 | |
| 408 | /* USB "non-iso" IRQ (PIO for all but ep0) */ |
| 409 | status = request_irq(pdev->resource[2].start, omap_udc_pio_irq, |
| 410 | - IRQF_SAMPLE_RANDOM, "omap_udc pio", udc); |
| 411 | + 0, "omap_udc pio", udc); |
| 412 | if (status != 0) { |
| 413 | ERR("can't get irq %d, err %d\n", |
| 414 | (int) pdev->resource[2].start, status); |
| 415 | --- a/drivers/usb/gadget/pxa25x_udc.c |
| 416 | +++ b/drivers/usb/gadget/pxa25x_udc.c |
| 417 | @@ -2202,19 +2202,15 @@ static int __init pxa25x_udc_probe(struc |
| 418 | |
| 419 | #ifdef CONFIG_ARCH_LUBBOCK |
| 420 | if (machine_is_lubbock()) { |
| 421 | - retval = request_irq(LUBBOCK_USB_DISC_IRQ, |
| 422 | - lubbock_vbus_irq, |
| 423 | - IRQF_SAMPLE_RANDOM, |
| 424 | - driver_name, dev); |
| 425 | + retval = request_irq(LUBBOCK_USB_DISC_IRQ, lubbock_vbus_irq, |
| 426 | + 0, driver_name, dev); |
| 427 | if (retval != 0) { |
| 428 | pr_err("%s: can't get irq %i, err %d\n", |
| 429 | driver_name, LUBBOCK_USB_DISC_IRQ, retval); |
| 430 | goto err_irq_lub; |
| 431 | } |
| 432 | - retval = request_irq(LUBBOCK_USB_IRQ, |
| 433 | - lubbock_vbus_irq, |
| 434 | - IRQF_SAMPLE_RANDOM, |
| 435 | - driver_name, dev); |
| 436 | + retval = request_irq(LUBBOCK_USB_IRQ, lubbock_vbus_irq, |
| 437 | + 0, driver_name, dev); |
| 438 | if (retval != 0) { |
| 439 | pr_err("%s: can't get irq %i, err %d\n", |
| 440 | driver_name, LUBBOCK_USB_IRQ, retval); |
| 441 | --- a/drivers/usb/otg/gpio_vbus.c |
| 442 | +++ b/drivers/usb/otg/gpio_vbus.c |
| 443 | @@ -51,8 +51,7 @@ struct gpio_vbus_data { |
| 444 | * edges might be workable. |
| 445 | */ |
| 446 | #define VBUS_IRQ_FLAGS \ |
| 447 | - ( IRQF_SAMPLE_RANDOM | IRQF_SHARED \ |
| 448 | - | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING ) |
| 449 | + ( IRQF_SHARED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING ) |
| 450 | |
| 451 | |
| 452 | /* interface to regulator framework */ |
| 453 | @@ -253,7 +252,7 @@ static int __init gpio_vbus_probe(struct |
| 454 | if (res) { |
| 455 | irq = res->start; |
| 456 | res->flags &= IRQF_TRIGGER_MASK; |
| 457 | - res->flags |= IRQF_SAMPLE_RANDOM | IRQF_SHARED; |
| 458 | + res->flags |= IRQF_SHARED; |
| 459 | } else |
| 460 | irq = gpio_to_irq(gpio); |
| 461 | |
| 462 | --- a/drivers/usb/otg/isp1301_omap.c |
| 463 | +++ b/drivers/usb/otg/isp1301_omap.c |
| 464 | @@ -1567,7 +1567,6 @@ isp1301_probe(struct i2c_client *i2c, co |
| 465 | isp->irq_type = IRQF_TRIGGER_FALLING; |
| 466 | } |
| 467 | |
| 468 | - isp->irq_type |= IRQF_SAMPLE_RANDOM; |
| 469 | status = request_irq(i2c->irq, isp1301_irq, |
| 470 | isp->irq_type, DRIVER_NAME, isp); |
| 471 | if (status < 0) { |
| 472 | --- a/include/linux/interrupt.h |
| 473 | +++ b/include/linux/interrupt.h |
| 474 | @@ -44,7 +44,6 @@ |
| 475 | * |
| 476 | * IRQF_DISABLED - keep irqs disabled when calling the action handler. |
| 477 | * DEPRECATED. This flag is a NOOP and scheduled to be removed |
| 478 | - * IRQF_SAMPLE_RANDOM - irq is used to feed the random generator |
| 479 | * IRQF_SHARED - allow sharing the irq among several devices |
| 480 | * IRQF_PROBE_SHARED - set by callers when they expect sharing mismatches to occur |
| 481 | * IRQF_TIMER - Flag to mark this interrupt as timer interrupt |
| 482 | @@ -63,7 +62,6 @@ |
| 483 | * resume time. |
| 484 | */ |
| 485 | #define IRQF_DISABLED 0x00000020 |
| 486 | -#define IRQF_SAMPLE_RANDOM 0x00000040 |
| 487 | #define IRQF_SHARED 0x00000080 |
| 488 | #define IRQF_PROBE_SHARED 0x00000100 |
| 489 | #define __IRQF_TIMER 0x00000200 |
| 490 | --- a/include/linux/irqdesc.h |
| 491 | +++ b/include/linux/irqdesc.h |
| 492 | @@ -39,7 +39,6 @@ struct module; |
| 493 | */ |
| 494 | struct irq_desc { |
| 495 | struct irq_data irq_data; |
| 496 | - struct timer_rand_state *timer_rand_state; |
| 497 | unsigned int __percpu *kstat_irqs; |
| 498 | irq_flow_handler_t handle_irq; |
| 499 | #ifdef CONFIG_IRQ_PREFLOW_FASTEOI |
| 500 | --- a/include/linux/random.h |
| 501 | +++ b/include/linux/random.h |
| 502 | @@ -48,8 +48,6 @@ struct rnd_state { |
| 503 | |
| 504 | #ifdef __KERNEL__ |
| 505 | |
| 506 | -extern void rand_initialize_irq(int irq); |
| 507 | - |
| 508 | extern void add_device_randomness(const void *, unsigned int); |
| 509 | extern void add_input_randomness(unsigned int type, unsigned int code, |
| 510 | unsigned int value); |
| 511 | --- a/kernel/irq/manage.c |
| 512 | +++ b/kernel/irq/manage.c |
| 513 | @@ -891,22 +891,6 @@ __setup_irq(unsigned int irq, struct irq |
| 514 | return -ENOSYS; |
| 515 | if (!try_module_get(desc->owner)) |
| 516 | return -ENODEV; |
| 517 | - /* |
| 518 | - * Some drivers like serial.c use request_irq() heavily, |
| 519 | - * so we have to be careful not to interfere with a |
| 520 | - * running system. |
| 521 | - */ |
| 522 | - if (new->flags & IRQF_SAMPLE_RANDOM) { |
| 523 | - /* |
| 524 | - * This function might sleep, we want to call it first, |
| 525 | - * outside of the atomic block. |
| 526 | - * Yes, this might clear the entropy pool if the wrong |
| 527 | - * driver is attempted to be loaded, without actually |
| 528 | - * installing a new handler, but is this really a problem, |
| 529 | - * only the sysadmin is able to do this. |
| 530 | - */ |
| 531 | - rand_initialize_irq(irq); |
| 532 | - } |
| 533 | |
| 534 | /* |
| 535 | * Check whether the interrupt nests into another interrupt |
| 536 | @@ -1342,7 +1326,6 @@ EXPORT_SYMBOL(free_irq); |
| 537 | * Flags: |
| 538 | * |
| 539 | * IRQF_SHARED Interrupt is shared |
| 540 | - * IRQF_SAMPLE_RANDOM The interrupt can be used for entropy |
| 541 | * IRQF_TRIGGER_* Specify active edge(s) or level |
| 542 | * |
| 543 | */ |
| 544 | |
