Changeset e9d15d9 in mainline for uspace


Ignore:
Timestamp:
2017-08-18T21:15:26Z (8 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
Files:
17 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:

  • uspace/lib/c/generic/async.c

    r1c85bae re9d15d9  
    10271027 * @param ucode   Top-half pseudocode handler.
    10281028 *
    1029  * @return Zero on success or a negative error code.
     1029 * @return IRQ capability on success.
     1030 * @return Negative error code.
    10301031 *
    10311032 */
    … …  
    10561057/** Unsubscribe from IRQ notification.
    10571058 *
    1058  * @param inr     IRQ number.
    1059  * @param devno   Device number of the device generating inr.
     1059 * @param cap     IRQ capability.
    10601060 *
    10611061 * @return Zero on success or a negative error code.
    10621062 *
    10631063 */
    1064 int async_irq_unsubscribe(int inr, int devno)
     1064int async_irq_unsubscribe(int cap)
    10651065{
    10661066        // TODO: Remove entry from hash table
    10671067        //       to avoid memory leak
    10681068       
    1069         return ipc_irq_unsubscribe(inr, devno);
     1069        return ipc_irq_unsubscribe(cap);
    10701070}
    10711071

  • uspace/lib/c/generic/irq.c

    r1c85bae re9d15d9  
    5959 * @param ucode  Top-half pseudocode handler.
    6060 *
    61  * @return Value returned by the kernel.
     61 * @return IRQ capability returned by the kernel.
     62 * @return Error code returned by the kernel.
    6263 *
    6364 */
    … …  
    7475/** Unsubscribe from IRQ notification.
    7576 *
    76  * @param inr   IRQ number.
    77  * @param devno Device number of the device generating inr.
     77 * @param cap   IRQ capability.
    7878 *
    7979 * @return Value returned by the kernel.
    8080 *
    8181 */
    82 int ipc_irq_unsubscribe(int inr, int devno)
     82int ipc_irq_unsubscribe(int cap)
    8383{
    84         return __SYSCALL2(SYS_IPC_IRQ_UNSUBSCRIBE, inr, devno);
     84        return __SYSCALL1(SYS_IPC_IRQ_UNSUBSCRIBE, cap);
    8585}
    8686

  • uspace/lib/c/include/async.h

    r1c85bae re9d15d9  
    168168extern int async_irq_subscribe(int, int, async_notification_handler_t, void *,
    169169    const irq_code_t *);
    170 extern int async_irq_unsubscribe(int, int);
     170extern int async_irq_unsubscribe(int);
    171171
    172172extern int async_event_subscribe(event_type_t, async_notification_handler_t,

  • uspace/lib/c/include/ipc/irq.h

    r1c85bae re9d15d9  
    4040
    4141extern int ipc_irq_subscribe(int, int, sysarg_t, const irq_code_t *);
    42 extern int ipc_irq_unsubscribe(int, int);
     42extern int ipc_irq_unsubscribe(int);
    4343
    4444#endif

  • uspace/lib/drv/generic/interrupt.c

    r1c85bae re9d15d9  
    4444
    4545int register_interrupt_handler(ddf_dev_t *dev, int irq,
    46     interrupt_handler_t *handler, const irq_code_t *pseudocode)
     46    interrupt_handler_t *handler, const irq_code_t *irq_code)
    4747{
    4848        return async_irq_subscribe(irq, dev->handle,
    49             (async_notification_handler_t) handler, dev, pseudocode);
     49            (async_notification_handler_t) handler, dev, irq_code);
    5050}
    5151
    52 int unregister_interrupt_handler(ddf_dev_t *dev, int irq)
     52int unregister_interrupt_handler(ddf_dev_t *dev, int cap)
    5353{
    54         return async_irq_unsubscribe(irq, dev->handle);
     54        return async_irq_unsubscribe(cap);
    5555}
    5656

  • uspace/lib/usbhost/src/ddf_helpers.c

    r1c85bae re9d15d9  
    748748 * @param[in] gen_irq_code IRQ code generator.
    749749 *
    750  * @return EOK on success or negative error code
     750 * @return IRQ kernel object capability on success.
     751 * @return Negative error code.
    751752 */
    752753int hcd_ddf_setup_interrupts(ddf_dev_t *device,
    … …  
    770771
    771772        /* Register handler to avoid interrupt lockup */
    772         int ret = register_interrupt_handler(device, irq, handler, &irq_code);
     773        const int irq_cap = register_interrupt_handler(device, irq, handler,
     774            &irq_code);
    773775        irq_code_clean(&irq_code);
     776        if (irq_cap < 0) {
     777                usb_log_error("Failed to register interrupt handler: %s.\n",
     778                    str_error(irq_cap));
     779                return irq_cap;
     780        }
     781
     782        /* Enable interrupts */
     783        int ret = hcd_ddf_enable_interrupts(device);
    774784        if (ret != EOK) {
    775785                usb_log_error("Failed to register interrupt handler: %s.\n",
    776786                    str_error(ret));
    777                 return ret;
    778         }
    779 
    780         /* Enable interrupts */
    781         ret = hcd_ddf_enable_interrupts(device);
    782         if (ret != EOK) {
    783                 usb_log_error("Failed to register interrupt handler: %s.\n",
    784                     str_error(ret));
    785                 unregister_interrupt_handler(device, irq);
    786                 return ret;
    787         }
    788         assert(irq > 0);
    789         return irq;
     787                unregister_interrupt_handler(device, irq_cap);
     788                return ret;
     789        }
     790        return irq_cap;
    790791}
    791792
    … …  
    882883        interrupt_handler_t *irq_handler =
    883884            driver->irq_handler ? driver->irq_handler : ddf_hcd_gen_irq_handler;
    884         const int irq = hcd_ddf_setup_interrupts(device, &hw_res, irq_handler,
    885             driver->irq_code_gen);
    886         if (!(irq < 0)) {
     885        const int irq_cap = hcd_ddf_setup_interrupts(device, &hw_res,
     886            irq_handler, driver->irq_code_gen);
     887        bool irqs_enabled = !(irq_cap < 0);
     888        if (irqs_enabled) {
    887889                usb_log_debug("Hw interrupts enabled.\n");
    888890        }
    … …  
    899901        /* Init hw driver */
    900902        hcd_t *hcd = dev_to_hcd(device);
    901         ret = driver->init(hcd, &hw_res, !(irq < 0));
     903        ret = driver->init(hcd, &hw_res, irqs_enabled);
    902904        hw_res_list_parsed_clean(&hw_res);
    903905        if (ret != EOK) {
    … …  
    907909
    908910        /* Need working irq replacement to setup root hub */
    909         if ((irq < 0) && hcd->ops.status_hook) {
     911        if (!irqs_enabled && hcd->ops.status_hook) {
    910912                hcd->polling_fibril = fibril_create(interrupt_polling, hcd);
    911913                if (hcd->polling_fibril == 0) {
    … …  
    916918                fibril_add_ready(hcd->polling_fibril);
    917919                usb_log_warning("Failed to enable interrupts: %s."
    918                     " Falling back to polling.\n", str_error(irq));
     920                    " Falling back to polling.\n", str_error(irq_cap));
    919921        }
    920922
    … …  
    930932irq_unregister:
    931933                /* Unregistering non-existent should be ok */
    932                 unregister_interrupt_handler(device, irq);
     934                unregister_interrupt_handler(device, irq_cap);
    933935                hcd_ddf_clean_hc(device);
    934936                return ret;
Note: See TracChangeset for help on using the changeset viewer.