Changeset e9d15d9 in mainline for uspace/drv


Ignore:
Timestamp:
2017-08-18T21:15:26Z (9 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
24abb85d
Parents:
1c85bae
Message:

Turn IRQ structures into kernel objects

ipc_irq_subscribe() now returns a capability for the underlying IRQ kernel
object. ipc_irq_unsubscribe() can now be done only with a valid IRQ capability.

Location:
uspace/drv
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/audio/hdaudio/hdaudio.c

    r1c85bae re9d15d9  
    263263        }
    264264
    265         rc = register_interrupt_handler(dev, res.irqs.irqs[0],
     265        int irq_cap = register_interrupt_handler(dev, res.irqs.irqs[0],
    266266            hdaudio_interrupt, &irq_code);
    267         if (rc != EOK) {
     267        if (irq_cap < 0) {
     268                rc = irq_cap;
    268269                ddf_msg(LVL_ERROR, "Failed registering interrupt handler. (%d)",
    269270                    rc);

  • uspace/drv/audio/sb16/main.c

    r1c85bae re9d15d9  
    9494        irq_cmd_t irq_cmds[irq_cmd_count];
    9595        irq_pio_range_t irq_ranges[1];
     96        int irq_cap;
    9697
    9798        sb16_t *soft_state = ddf_dev_data_alloc(device, sizeof(sb16_t));
    … …  
    123124        };
    124125
    125         rc = register_interrupt_handler(device, irq, irq_handler, &irq_code);
    126         if (rc != EOK) {
     126        irq_cap = register_interrupt_handler(device, irq, irq_handler,
     127            &irq_code);
     128        if (irq_cap < 0) {
     129                rc = irq_cap;
    127130                ddf_log_error("Failed to register irq handler: %s.",
    128131                    str_error(rc));
    … …  
    168171error:
    169172        if (handler_regd)
    170                 unregister_interrupt_handler(device, irq);
     173                unregister_interrupt_handler(device, irq_cap);
    171174        return rc;
    172175}

  • uspace/drv/block/ahci/ahci.c

    r1c85bae re9d15d9  
    11851185        ct.ranges = ahci_ranges;
    11861186       
    1187         int rc = register_interrupt_handler(dev, hw_res_parsed.irqs.irqs[0],
    1188             ahci_interrupt, &ct);
    1189         if (rc != EOK) {
     1187        int irq_cap = register_interrupt_handler(dev,
     1188            hw_res_parsed.irqs.irqs[0], ahci_interrupt, &ct);
     1189        if (irq_cap < 0) {
    11901190                ddf_msg(LVL_ERROR, "Failed registering interrupt handler.");
    11911191                goto error_register_interrupt_handler;
    11921192        }
    11931193       
    1194         rc = irc_enable_interrupt(hw_res_parsed.irqs.irqs[0]);
     1194        int rc = irc_enable_interrupt(hw_res_parsed.irqs.irqs[0]);
    11951195        if (rc != EOK) {
    11961196                ddf_msg(LVL_ERROR, "Failed enable interupt.");
    … …  
    12021202       
    12031203error_enable_interrupt:
    1204         unregister_interrupt_handler(dev, hw_res_parsed.irqs.irqs[0]);
     1204        unregister_interrupt_handler(dev, irq_cap);
    12051205       
    12061206error_register_interrupt_handler:

  • uspace/drv/block/ddisk/ddisk.c

    r1c85bae re9d15d9  
    112112        ddisk_regs_t *ddisk_regs;
    113113
     114        int irq_cap;
     115
    114116        bd_srvs_t bds;
    115117} ddisk_t;
    … …  
    447449        ddisk->bds.sarg = ddisk;
    448450
     451        ddisk->irq_cap = -1;
     452
    449453        /*
    450454         * Enable access to ddisk's PIO registers.
    … …  
    499503        ddisk_irq_commands[0].addr = (void *) &res_phys->status;
    500504        ddisk_irq_commands[3].addr = (void *) &res_phys->command;
    501         rc = register_interrupt_handler(dev, ddisk->ddisk_res.irq,
     505        ddisk->irq_cap = register_interrupt_handler(dev, ddisk->ddisk_res.irq,
    502506            ddisk_irq_handler, &ddisk_irq_code);
    503         if (rc != EOK) {
     507        if (ddisk->irq_cap < 0) {
     508                rc = ddisk->irq_cap;
    504509                ddf_msg(LVL_ERROR, "Failed to register interrupt handler.");
    505510                goto error;
    … …  
    541546        }
    542547
    543         unregister_interrupt_handler(ddisk->dev, ddisk->ddisk_res.irq);
     548        unregister_interrupt_handler(ddisk->dev, ddisk->irq_cap);
    544549       
    545550        rc = pio_disable(ddisk->ddisk_regs, sizeof(ddisk_regs_t));

  • uspace/drv/char/i8042/i8042.c

    r1c85bae re9d15d9  
    269269        };
    270270       
    271         rc = register_interrupt_handler(ddf_dev, irq_kbd, i8042_irq_handler,
    272             &irq_code);
    273         if (rc != EOK) {
     271        const int irq_kbd_cap = register_interrupt_handler(ddf_dev, irq_kbd,
     272            i8042_irq_handler, &irq_code);
     273        if (irq_kbd_cap < 0) {
     274                rc = irq_kbd_cap;
    274275                ddf_msg(LVL_ERROR, "Failed set handler for kbd: %s.",
    275276                    ddf_dev_get_name(ddf_dev));
    … …  
    277278        }
    278279       
    279         rc = register_interrupt_handler(ddf_dev, irq_mouse, i8042_irq_handler,
    280             &irq_code);
    281         if (rc != EOK) {
     280        const int irq_mouse_cap = register_interrupt_handler(ddf_dev, irq_mouse,
     281            i8042_irq_handler, &irq_code);
     282        if (irq_mouse_cap < 0) {
     283                rc = irq_mouse_cap;
    282284                ddf_msg(LVL_ERROR, "Failed set handler for mouse: %s.",
    283285                    ddf_dev_get_name(ddf_dev));

  • uspace/drv/char/ns8250/ns8250.c

    r1c85bae re9d15d9  
    160160        /** The irq assigned to this device. */
    161161        int irq;
     162        /** IRQ capability */
     163        int irq_cap;
    162164        /** The base i/o address of the devices registers. */
    163165        uintptr_t io_addr;
    … …  
    797799static inline int ns8250_unregister_interrupt_handler(ns8250_t *ns)
    798800{
    799         return unregister_interrupt_handler(ns->dev, ns->irq);
     801        return unregister_interrupt_handler(ns->dev, ns->irq_cap);
    800802}
    801803
    … …  
    849851       
    850852        /* Register interrupt handler. */
    851         if (ns8250_register_interrupt_handler(ns) != EOK) {
     853        ns->irq_cap = ns8250_register_interrupt_handler(ns);
     854        if (ns->irq_cap < 0) {
    852855                ddf_msg(LVL_ERROR, "Failed to register interrupt handler.");
    853856                rc = EADDRNOTAVAIL;

  • uspace/drv/char/pl050/pl050.c

    r1c85bae re9d15d9  
    212212        pl050->regs = regs;
    213213
    214         rc = register_interrupt_handler(pl050->dev, res.irqs.irqs[0],
    215             pl050_interrupt, &pl050_irq_code);
    216         if (rc != EOK) {
     214        const int irq_cap = register_interrupt_handler(pl050->dev,
     215            res.irqs.irqs[0], pl050_interrupt, &pl050_irq_code);
     216        if (irq_cap < 0) {
     217                rc = irq_cap;
    217218                ddf_msg(LVL_ERROR, "Failed registering interrupt handler. (%d)",
    218219                    rc);

  • uspace/drv/nic/e1k/e1k.c

    r1c85bae re9d15d9  
    12531253 * @param nic Driver data
    12541254 *
    1255  * @return EOK if the handler was registered
     1255 * @return IRQ capability if the handler was registered
    12561256 * @return Negative error code otherwise
    12571257 *
    … …  
    12681268        e1000_irq_code.cmds[2].addr = e1000->reg_base_phys + E1000_IMC;
    12691269       
    1270         int rc = register_interrupt_handler(nic_get_ddf_dev(nic),
    1271             e1000->irq, e1000_interrupt_handler, &e1000_irq_code);
     1270        int cap = register_interrupt_handler(nic_get_ddf_dev(nic), e1000->irq,
     1271            e1000_interrupt_handler, &e1000_irq_code);
    12721272       
    12731273        fibril_mutex_unlock(&irq_reg_mutex);
    1274         return rc;
     1274        return cap;
    12751275}
    12761276
    … …  
    21522152        ddf_fun_set_ops(fun, &e1000_dev_ops);
    21532153       
    2154         rc = e1000_register_int_handler(nic);
    2155         if (rc != EOK)
     2154        int irq_cap = e1000_register_int_handler(nic);
     2155        if (irq_cap < 0) {
     2156                rc = irq_cap;
    21562157                goto err_fun_create;
     2158        }
    21572159       
    21582160        rc = e1000_initialize_rx_structure(nic);
    … …  
    21892191        e1000_uninitialize_rx_structure(nic);
    21902192err_irq:
    2191         unregister_interrupt_handler(dev, DRIVER_DATA_DEV(dev)->irq);
     2193        unregister_interrupt_handler(dev, irq_cap);
    21922194err_fun_create:
    21932195        ddf_fun_destroy(fun);

  • uspace/drv/nic/ne2k/ne2k.c

    r1c85bae re9d15d9  
    160160        }
    161161
    162         int rc = register_interrupt_handler(nic_get_ddf_dev(nic_data),
     162        int irq_cap = register_interrupt_handler(nic_get_ddf_dev(nic_data),
    163163                ne2k->irq, ne2k_interrupt_handler, &ne2k->code);
    164         return rc;
     164        return irq_cap;
    165165}
    166166
    … …  
    228228        ne2k->probed = true;
    229229       
    230         rc = ne2k_register_interrupt(nic_data);
    231         if (rc != EOK)
     230        int irq_cap = ne2k_register_interrupt(nic_data);
     231        if (irq_cap < 0)
    232232                return EINVAL;
    233233       

  • uspace/drv/nic/rtl8139/driver.c

    r1c85bae re9d15d9  
    881881 *  @param nic_data  The driver data
    882882 *
    883  *  @return EOK if the handler was registered, negative error code otherwise
     883 *  @return IRQ capability if the handler was registered.
     884 *  @return Negative error code otherwise.
    884885 */
    885886inline static int rtl8139_register_int_handler(nic_t *nic_data)
    … …  
    894895        rtl8139_irq_code.cmds[2].addr = rtl8139->io_addr + ISR;
    895896        rtl8139_irq_code.cmds[3].addr = rtl8139->io_addr + IMR;
    896         int rc = register_interrupt_handler(nic_get_ddf_dev(nic_data),
     897        int cap = register_interrupt_handler(nic_get_ddf_dev(nic_data),
    897898            rtl8139->irq, rtl8139_interrupt_handler, &rtl8139_irq_code);
    898899
    899900        RTL8139_IRQ_STRUCT_UNLOCK();
    900901
    901         return rc;
     902        return cap;
    902903}
    903904
    … …  
    13211322
    13221323        /* Register interrupt handler */
    1323         rc = rtl8139_register_int_handler(nic_data);
    1324         if (rc != EOK)
     1324        int irq_cap = rtl8139_register_int_handler(nic_data);
     1325        if (irq_cap < 0) {
     1326                rc = irq_cap;
    13251327                goto err_pio;
     1328        }
    13261329
    13271330        fun = ddf_fun_create(nic_get_ddf_dev(nic_data), fun_exposed, "port0");
    … …  
    13551358        ddf_fun_destroy(fun);
    13561359err_srv:
    1357         unregister_interrupt_handler(dev, rtl8139->irq);
     1360        unregister_interrupt_handler(dev, irq_cap);
    13581361err_pio:
    13591362        // rtl8139_pio_disable(dev);

  • uspace/drv/nic/rtl8169/driver.c

    r1c85bae re9d15d9  
    371371        rtl8169_irq_code.cmds[2].addr = rtl8169->regs + ISR;
    372372        rtl8169_irq_code.cmds[3].addr = rtl8169->regs + IMR;
    373         int rc = register_interrupt_handler(nic_get_ddf_dev(nic_data),
     373        int irq_cap = register_interrupt_handler(nic_get_ddf_dev(nic_data),
    374374            rtl8169->irq, rtl8169_irq_handler, &rtl8169_irq_code);
    375375
    376         return rc;
     376        return irq_cap;
    377377}
    378378
    … …  
    426426                goto err_pio;
    427427
    428         rc = rtl8169_register_int_handler(nic_data);
    429         if (rc != EOK) {
     428        int irq_cap = rtl8169_register_int_handler(nic_data);
     429        if (irq_cap < 0) {
     430                rc = irq_cap;
    430431                ddf_msg(LVL_ERROR, "Failed to register IRQ handler (%d)", rc);
    431432                goto err_irq;
    432 
    433433        }
    434434
    … …  
    469469err_srv:
    470470        /* XXX Disconnect from services */
     471        unregister_interrupt_handler(dev, irq_cap);
    471472err_irq:
    472         //unregister_interrupt_handler(dev, rtl8169->irq);
    473473err_pio:
    474474err_destroy:
Note: See TracChangeset for help on using the changeset viewer.