Changeset 91b60499 in mainline for uspace


Ignore:
Timestamp:
2017-09-30T06:29:42Z (8 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
300f4c4
Parents:
d076f16 (diff), 6636fb19 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge support for capabilities from lp:~jakub/helenos/caps

This commit introduces capabilities as task-local names for references to kernel
objects. Kernel objects are reference-counted wrappers for a select group of
objects allocated in and by the kernel that can be made accessible to userspace
in a controlled way via integer handles.

So far, a kernel object encapsulates either an irq_t or a phone_t.

Support for the former lead to the removal of kernel-assigned devnos and
unsecure deregistration of IRQs in which a random task was able to unregister
some other task's IRQ.

Location:
uspace
Files:
23 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/trace/ipc_desc.c

    rd076f16 r91b60499  
    4040        /* System methods */
    4141        { IPC_M_PHONE_HUNGUP,     "PHONE_HUNGUP" },
    42         { IPC_M_CONNECTION_CLONE, "CONNECTION_CLONE" },
    43         { IPC_M_CLONE_ESTABLISH,  "CLONE_ESTABLISH" },
    4442        { IPC_M_CONNECT_ME_TO,    "CONNECT_ME_TO" },
    4543        { IPC_M_CONNECT_TO_ME,    "CONNECT_TO_ME" },

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

    rd076f16 r91b60499  
    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

    rd076f16 r91b60499  
    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

    rd076f16 r91b60499  
    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

    rd076f16 r91b60499  
    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

    rd076f16 r91b60499  
    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

    rd076f16 r91b60499  
    160160        /** The irq assigned to this device. */
    161161        int irq;
     162        /** IRQ capability handle */
     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

    rd076f16 r91b60499  
    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

    rd076f16 r91b60499  
    12531253 * @param nic Driver data
    12541254 *
    1255  * @return EOK if the handler was registered
     1255 * @return IRQ capability handle 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

    rd076f16 r91b60499  
    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

    rd076f16 r91b60499  
    881881 *  @param nic_data  The driver data
    882882 *
    883  *  @return EOK if the handler was registered, negative error code otherwise
     883 *  @return IRQ capability handle 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

    rd076f16 r91b60499  
    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

    rd076f16 r91b60499  
    10481048 *
    10491049 * @param inr     IRQ number.
    1050  * @param devno   Device number of the device generating inr.
    10511050 * @param handler Notification handler.
    10521051 * @param data    Notification handler client data.
    10531052 * @param ucode   Top-half pseudocode handler.
    10541053 *
    1055  * @return Zero on success or a negative error code.
    1056  *
    1057  */
    1058 int async_irq_subscribe(int inr, int devno,
    1059     async_notification_handler_t handler, void *data, const irq_code_t *ucode)
     1054 * @return IRQ capability handle on success.
     1055 * @return Negative error code.
     1056 *
     1057 */
     1058int async_irq_subscribe(int inr, async_notification_handler_t handler,
     1059    void *data, const irq_code_t *ucode)
    10601060{
    10611061        notification_t *notification =
    … …  
    10771077        futex_up(&async_futex);
    10781078       
    1079         return ipc_irq_subscribe(inr, devno, imethod, ucode);
     1079        return ipc_irq_subscribe(inr, imethod, ucode);
    10801080}
    10811081
    10821082/** Unsubscribe from IRQ notification.
    10831083 *
    1084  * @param inr     IRQ number.
    1085  * @param devno   Device number of the device generating inr.
     1084 * @param cap     IRQ capability handle.
    10861085 *
    10871086 * @return Zero on success or a negative error code.
    10881087 *
    10891088 */
    1090 int async_irq_unsubscribe(int inr, int devno)
     1089int async_irq_unsubscribe(int cap)
    10911090{
    10921091        // TODO: Remove entry from hash table
    10931092        //       to avoid memory leak
    10941093       
    1095         return ipc_irq_unsubscribe(inr, devno);
     1094        return ipc_irq_unsubscribe(cap);
    10961095}
    10971096
    … …  
    13841383                async_new_connection(call->in_task_id, in_phone_hash, callid,
    13851384                    call, handler, data);
    1386                 return;
    1387         }
    1388        
    1389         /* Cloned connection */
    1390         if (IPC_GET_IMETHOD(*call) == IPC_M_CLONE_ESTABLISH) {
    1391                 // TODO: Currently ignores ports altogether
    1392                
    1393                 /* Open new connection with fibril, etc. */
    1394                 async_new_connection(call->in_task_id, IPC_GET_ARG5(*call),
    1395                     callid, call, fallback_port_handler, fallback_port_data);
    13961385                return;
    13971386        }
    … …  
    21112100       
    21122101        return EOK;
    2113 }
    2114 
    2115 /** Wrapper for making IPC_M_CLONE_ESTABLISH calls using the async framework.
    2116  *
    2117  * Ask for a cloned connection to some service.
    2118  *
    2119  * @param mgmt Exchange management style.
    2120  * @param exch Exchange for sending the message.
    2121  *
    2122  * @return New session on success or NULL on error.
    2123  *
    2124  */
    2125 async_sess_t *async_clone_establish(exch_mgmt_t mgmt, async_exch_t *exch)
    2126 {
    2127         if (exch == NULL) {
    2128                 errno = ENOENT;
    2129                 return NULL;
    2130         }
    2131        
    2132         async_sess_t *sess = (async_sess_t *) malloc(sizeof(async_sess_t));
    2133         if (sess == NULL) {
    2134                 errno = ENOMEM;
    2135                 return NULL;
    2136         }
    2137        
    2138         ipc_call_t result;
    2139        
    2140         amsg_t *msg = amsg_create();
    2141         if (!msg) {
    2142                 free(sess);
    2143                 errno = ENOMEM;
    2144                 return NULL;
    2145         }
    2146        
    2147         msg->dataptr = &result;
    2148         msg->wdata.active = true;
    2149        
    2150         ipc_call_async_0(exch->phone, IPC_M_CLONE_ESTABLISH, msg,
    2151             reply_received);
    2152        
    2153         sysarg_t rc;
    2154         async_wait_for((aid_t) msg, &rc);
    2155        
    2156         if (rc != EOK) {
    2157                 errno = rc;
    2158                 free(sess);
    2159                 return NULL;
    2160         }
    2161        
    2162         int phone = (int) IPC_GET_ARG5(result);
    2163        
    2164         if (phone < 0) {
    2165                 errno = phone;
    2166                 free(sess);
    2167                 return NULL;
    2168         }
    2169        
    2170         sess->iface = 0;
    2171         sess->mgmt = mgmt;
    2172         sess->phone = phone;
    2173         sess->arg1 = 0;
    2174         sess->arg2 = 0;
    2175         sess->arg3 = 0;
    2176        
    2177         fibril_mutex_initialize(&sess->remote_state_mtx);
    2178         sess->remote_state_data = NULL;
    2179        
    2180         list_initialize(&sess->exch_list);
    2181         fibril_mutex_initialize(&sess->mutex);
    2182         atomic_set(&sess->refcnt, 0);
    2183        
    2184         return sess;
    21852102}
    21862103
    … …  
    31533070}
    31543071
    3155 /** Wrapper for sending an exchange over different exchange for cloning
    3156  *
    3157  * @param exch       Exchange to be used for sending.
    3158  * @param clone_exch Exchange to be cloned.
    3159  *
    3160  */
    3161 int async_exchange_clone(async_exch_t *exch, async_exch_t *clone_exch)
    3162 {
    3163         return async_req_1_0(exch, IPC_M_CONNECTION_CLONE, clone_exch->phone);
    3164 }
    3165 
    3166 /** Wrapper for receiving the IPC_M_CONNECTION_CLONE calls.
    3167  *
    3168  * If the current call is IPC_M_CONNECTION_CLONE then a new
    3169  * async session is created for the accepted phone.
    3170  *
    3171  * @param mgmt Exchange management style.
    3172  *
    3173  * @return New async session or NULL on failure.
    3174  *
    3175  */
    3176 async_sess_t *async_clone_receive(exch_mgmt_t mgmt)
    3177 {
    3178         /* Accept the phone */
    3179         ipc_call_t call;
    3180         ipc_callid_t callid = async_get_call(&call);
    3181         int phone = (int) IPC_GET_ARG1(call);
    3182        
    3183         if ((IPC_GET_IMETHOD(call) != IPC_M_CONNECTION_CLONE) ||
    3184             (phone < 0)) {
    3185                 async_answer_0(callid, EINVAL);
    3186                 return NULL;
    3187         }
    3188        
    3189         async_sess_t *sess = (async_sess_t *) malloc(sizeof(async_sess_t));
    3190         if (sess == NULL) {
    3191                 async_answer_0(callid, ENOMEM);
    3192                 return NULL;
    3193         }
    3194        
    3195         sess->iface = 0;
    3196         sess->mgmt = mgmt;
    3197         sess->phone = phone;
    3198         sess->arg1 = 0;
    3199         sess->arg2 = 0;
    3200         sess->arg3 = 0;
    3201        
    3202         fibril_mutex_initialize(&sess->remote_state_mtx);
    3203         sess->remote_state_data = NULL;
    3204        
    3205         list_initialize(&sess->exch_list);
    3206         fibril_mutex_initialize(&sess->mutex);
    3207         atomic_set(&sess->refcnt, 0);
    3208        
    3209         /* Acknowledge the cloned phone */
    3210         async_answer_0(callid, EOK);
    3211        
    3212         return sess;
    3213 }
    3214 
    32153072/** Wrapper for receiving the IPC_M_CONNECT_TO_ME calls.
    32163073 *

  • uspace/lib/c/generic/ddi.c

    rd076f16 r91b60499  
    5050#include "private/libc.h"
    5151
    52 
    53 /** Return unique device number.
    54  *
    55  * @return New unique device number.
    56  *
    57  */
    58 int device_assign_devno(void)
    59 {
    60         return __SYSCALL0(SYS_DEVICE_ASSIGN_DEVNO);
    61 }
    6252
    6353/** Map a piece of physical memory to task.

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

    rd076f16 r91b60499  
    5555 *
    5656 * @param inr    IRQ number.
    57  * @param devno  Device number of the device generating inr.
    5857 * @param method Use this method for notifying me.
    5958 * @param ucode  Top-half pseudocode handler.
     59 *
     60 * @return IRQ capability handle returned by the kernel.
     61 * @return Error code returned by the kernel.
     62 *
     63 */
     64int ipc_irq_subscribe(int inr, sysarg_t method, const irq_code_t *ucode)
     65{
     66        if (ucode == NULL)
     67                ucode = &default_ucode;
     68       
     69        return __SYSCALL3(SYS_IPC_IRQ_SUBSCRIBE, inr, method, (sysarg_t) ucode);
     70}
     71
     72/** Unsubscribe from IRQ notification.
     73 *
     74 * @param cap   IRQ capability handle.
    6075 *
    6176 * @return Value returned by the kernel.
    6277 *
    6378 */
    64 int ipc_irq_subscribe(int inr, int devno, sysarg_t method,
    65     const irq_code_t *ucode)
     79int ipc_irq_unsubscribe(int cap)
    6680{
    67         if (ucode == NULL)
    68                 ucode = &default_ucode;
    69        
    70         return __SYSCALL4(SYS_IPC_IRQ_SUBSCRIBE, inr, devno, method,
    71             (sysarg_t) ucode);
    72 }
    73 
    74 /** Unsubscribe from IRQ notification.
    75  *
    76  * @param inr   IRQ number.
    77  * @param devno Device number of the device generating inr.
    78  *
    79  * @return Value returned by the kernel.
    80  *
    81  */
    82 int ipc_irq_unsubscribe(int inr, int devno)
    83 {
    84         return __SYSCALL2(SYS_IPC_IRQ_UNSUBSCRIBE, inr, devno);
     81        return __SYSCALL1(SYS_IPC_IRQ_UNSUBSCRIBE, cap);
    8582}
    8683

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

    rd076f16 r91b60499  
    166166    sysarg_t, async_port_handler_t, void *, port_id_t *);
    167167
    168 extern int async_irq_subscribe(int, int, async_notification_handler_t, void *,
     168extern int async_irq_subscribe(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,
    … …  
    343343    sysarg_t *, sysarg_t *);
    344344
    345 extern async_sess_t *async_clone_establish(exch_mgmt_t, async_exch_t *);
    346345extern async_sess_t *async_connect_me_to(exch_mgmt_t, async_exch_t *, sysarg_t,
    347346    sysarg_t, sysarg_t);
    … …  
    472471    sysarg_t, sysarg_t, sysarg_t, ipc_call_t *);
    473472
    474 extern int async_exchange_clone(async_exch_t *, async_exch_t *);
    475 extern async_sess_t *async_clone_receive(exch_mgmt_t);
    476473extern async_sess_t *async_callback_receive(exch_mgmt_t);
    477474extern async_sess_t *async_callback_receive_start(exch_mgmt_t, ipc_call_t *);

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

    rd076f16 r91b60499  
    3939#include <abi/ddi/irq.h>
    4040
    41 extern int ipc_irq_subscribe(int, int, sysarg_t, const irq_code_t *);
    42 extern int ipc_irq_unsubscribe(int, int);
     41extern int ipc_irq_subscribe(int, sysarg_t, const irq_code_t *);
     42extern int ipc_irq_unsubscribe(int);
    4343
    4444#endif

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

    rd076f16 r91b60499  
    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{
    48         return async_irq_subscribe(irq, dev->handle,
    49             (async_notification_handler_t) handler, dev, pseudocode);
     48        return async_irq_subscribe(irq, (async_notification_handler_t) handler,
     49            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

    rd076f16 r91b60499  
    748748 * @param[in] gen_irq_code IRQ code generator.
    749749 *
    750  * @return EOK on success or negative error code
     750 * @return IRQ capability handle 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;

  • uspace/srv/hid/input/port/msim.c

    rd076f16 r91b60499  
    9797        msim_ranges[0].base = paddr;
    9898        msim_cmds[0].addr = (void *) paddr;
    99         async_irq_subscribe(inr, device_assign_devno(), msim_irq_handler, NULL,
    100             &msim_kbd);
     99        async_irq_subscribe(inr, msim_irq_handler, NULL, &msim_kbd);
    101100       
    102101        return 0;

  • uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.c

    rd076f16 r91b60499  
    137137            (void *) ts->paddr, inr);
    138138
    139         async_irq_subscribe(inr, device_assign_devno(), s3c24xx_ts_irq_handler,
    140             NULL, &ts_irq_code);
     139        async_irq_subscribe(inr, s3c24xx_ts_irq_handler, NULL, &ts_irq_code);
    141140
    142141        s3c24xx_ts_wait_for_int_mode(ts, updn_down);

  • uspace/srv/hw/bus/cuda_adb/cuda_adb.c

    rd076f16 r91b60499  
    282282        cuda_irq_code.ranges[0].base = (uintptr_t) instance->cuda_physical;
    283283        cuda_irq_code.cmds[0].addr = (void *) &((cuda_t *) instance->cuda_physical)->ifr;
    284         async_irq_subscribe(10, device_assign_devno(), cuda_irq_handler, NULL,
    285             &cuda_irq_code);
     284        async_irq_subscribe(10, cuda_irq_handler, NULL, &cuda_irq_code);
    286285
    287286        /* Enable SR interrupt. */

  • uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.c

    rd076f16 r91b60499  
    193193            (void *) uart->paddr, inr);
    194194
    195         async_irq_subscribe(inr, device_assign_devno(), s3c24xx_uart_irq_handler,
    196             NULL, &uart_irq_code);
     195        async_irq_subscribe(inr, s3c24xx_uart_irq_handler, NULL, &uart_irq_code);
    197196
    198197        /* Enable FIFO, Tx trigger level: empty, Rx trigger level: 1 byte. */
Note: See TracChangeset for help on using the changeset viewer.