- Timestamp:
- 2017-09-30T06:29:42Z (8 years ago)
- 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. - Location:
- uspace
- Files:
-
- 23 edited
Legend:
- Unmodified
- Added
- Removed
-
uspace/app/trace/ipc_desc.c
rd076f16 r91b60499 40 40 /* System methods */ 41 41 { IPC_M_PHONE_HUNGUP, "PHONE_HUNGUP" }, 42 { IPC_M_CONNECTION_CLONE, "CONNECTION_CLONE" },43 { IPC_M_CLONE_ESTABLISH, "CLONE_ESTABLISH" },44 42 { IPC_M_CONNECT_ME_TO, "CONNECT_ME_TO" }, 45 43 { IPC_M_CONNECT_TO_ME, "CONNECT_TO_ME" }, -
uspace/drv/audio/hdaudio/hdaudio.c
rd076f16 r91b60499 263 263 } 264 264 265 rc= register_interrupt_handler(dev, res.irqs.irqs[0],265 int irq_cap = register_interrupt_handler(dev, res.irqs.irqs[0], 266 266 hdaudio_interrupt, &irq_code); 267 if (rc != EOK) { 267 if (irq_cap < 0) { 268 rc = irq_cap; 268 269 ddf_msg(LVL_ERROR, "Failed registering interrupt handler. (%d)", 269 270 rc); -
uspace/drv/audio/sb16/main.c
rd076f16 r91b60499 94 94 irq_cmd_t irq_cmds[irq_cmd_count]; 95 95 irq_pio_range_t irq_ranges[1]; 96 int irq_cap; 96 97 97 98 sb16_t *soft_state = ddf_dev_data_alloc(device, sizeof(sb16_t)); … … 123 124 }; 124 125 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; 127 130 ddf_log_error("Failed to register irq handler: %s.", 128 131 str_error(rc)); … … 168 171 error: 169 172 if (handler_regd) 170 unregister_interrupt_handler(device, irq );173 unregister_interrupt_handler(device, irq_cap); 171 174 return rc; 172 175 } -
uspace/drv/block/ahci/ahci.c
rd076f16 r91b60499 1185 1185 ct.ranges = ahci_ranges; 1186 1186 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) { 1190 1190 ddf_msg(LVL_ERROR, "Failed registering interrupt handler."); 1191 1191 goto error_register_interrupt_handler; 1192 1192 } 1193 1193 1194 rc = irc_enable_interrupt(hw_res_parsed.irqs.irqs[0]);1194 int rc = irc_enable_interrupt(hw_res_parsed.irqs.irqs[0]); 1195 1195 if (rc != EOK) { 1196 1196 ddf_msg(LVL_ERROR, "Failed enable interupt."); … … 1202 1202 1203 1203 error_enable_interrupt: 1204 unregister_interrupt_handler(dev, hw_res_parsed.irqs.irqs[0]);1204 unregister_interrupt_handler(dev, irq_cap); 1205 1205 1206 1206 error_register_interrupt_handler: -
uspace/drv/block/ddisk/ddisk.c
rd076f16 r91b60499 112 112 ddisk_regs_t *ddisk_regs; 113 113 114 int irq_cap; 115 114 116 bd_srvs_t bds; 115 117 } ddisk_t; … … 447 449 ddisk->bds.sarg = ddisk; 448 450 451 ddisk->irq_cap = -1; 452 449 453 /* 450 454 * Enable access to ddisk's PIO registers. … … 499 503 ddisk_irq_commands[0].addr = (void *) &res_phys->status; 500 504 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, 502 506 ddisk_irq_handler, &ddisk_irq_code); 503 if (rc != EOK) { 507 if (ddisk->irq_cap < 0) { 508 rc = ddisk->irq_cap; 504 509 ddf_msg(LVL_ERROR, "Failed to register interrupt handler."); 505 510 goto error; … … 541 546 } 542 547 543 unregister_interrupt_handler(ddisk->dev, ddisk-> ddisk_res.irq);548 unregister_interrupt_handler(ddisk->dev, ddisk->irq_cap); 544 549 545 550 rc = pio_disable(ddisk->ddisk_regs, sizeof(ddisk_regs_t)); -
uspace/drv/char/i8042/i8042.c
rd076f16 r91b60499 269 269 }; 270 270 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; 274 275 ddf_msg(LVL_ERROR, "Failed set handler for kbd: %s.", 275 276 ddf_dev_get_name(ddf_dev)); … … 277 278 } 278 279 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; 282 284 ddf_msg(LVL_ERROR, "Failed set handler for mouse: %s.", 283 285 ddf_dev_get_name(ddf_dev)); -
uspace/drv/char/ns8250/ns8250.c
rd076f16 r91b60499 160 160 /** The irq assigned to this device. */ 161 161 int irq; 162 /** IRQ capability handle */ 163 int irq_cap; 162 164 /** The base i/o address of the devices registers. */ 163 165 uintptr_t io_addr; … … 797 799 static inline int ns8250_unregister_interrupt_handler(ns8250_t *ns) 798 800 { 799 return unregister_interrupt_handler(ns->dev, ns->irq );801 return unregister_interrupt_handler(ns->dev, ns->irq_cap); 800 802 } 801 803 … … 849 851 850 852 /* 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) { 852 855 ddf_msg(LVL_ERROR, "Failed to register interrupt handler."); 853 856 rc = EADDRNOTAVAIL; -
uspace/drv/char/pl050/pl050.c
rd076f16 r91b60499 212 212 pl050->regs = regs; 213 213 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; 217 218 ddf_msg(LVL_ERROR, "Failed registering interrupt handler. (%d)", 218 219 rc); -
uspace/drv/nic/e1k/e1k.c
rd076f16 r91b60499 1253 1253 * @param nic Driver data 1254 1254 * 1255 * @return EOKif the handler was registered1255 * @return IRQ capability handle if the handler was registered 1256 1256 * @return Negative error code otherwise 1257 1257 * … … 1268 1268 e1000_irq_code.cmds[2].addr = e1000->reg_base_phys + E1000_IMC; 1269 1269 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); 1272 1272 1273 1273 fibril_mutex_unlock(&irq_reg_mutex); 1274 return rc;1274 return cap; 1275 1275 } 1276 1276 … … 2152 2152 ddf_fun_set_ops(fun, &e1000_dev_ops); 2153 2153 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; 2156 2157 goto err_fun_create; 2158 } 2157 2159 2158 2160 rc = e1000_initialize_rx_structure(nic); … … 2189 2191 e1000_uninitialize_rx_structure(nic); 2190 2192 err_irq: 2191 unregister_interrupt_handler(dev, DRIVER_DATA_DEV(dev)->irq);2193 unregister_interrupt_handler(dev, irq_cap); 2192 2194 err_fun_create: 2193 2195 ddf_fun_destroy(fun); -
uspace/drv/nic/ne2k/ne2k.c
rd076f16 r91b60499 160 160 } 161 161 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), 163 163 ne2k->irq, ne2k_interrupt_handler, &ne2k->code); 164 return rc;164 return irq_cap; 165 165 } 166 166 … … 228 228 ne2k->probed = true; 229 229 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) 232 232 return EINVAL; 233 233 -
uspace/drv/nic/rtl8139/driver.c
rd076f16 r91b60499 881 881 * @param nic_data The driver data 882 882 * 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. 884 885 */ 885 886 inline static int rtl8139_register_int_handler(nic_t *nic_data) … … 894 895 rtl8139_irq_code.cmds[2].addr = rtl8139->io_addr + ISR; 895 896 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), 897 898 rtl8139->irq, rtl8139_interrupt_handler, &rtl8139_irq_code); 898 899 899 900 RTL8139_IRQ_STRUCT_UNLOCK(); 900 901 901 return rc;902 return cap; 902 903 } 903 904 … … 1321 1322 1322 1323 /* 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; 1325 1327 goto err_pio; 1328 } 1326 1329 1327 1330 fun = ddf_fun_create(nic_get_ddf_dev(nic_data), fun_exposed, "port0"); … … 1355 1358 ddf_fun_destroy(fun); 1356 1359 err_srv: 1357 unregister_interrupt_handler(dev, rtl8139->irq);1360 unregister_interrupt_handler(dev, irq_cap); 1358 1361 err_pio: 1359 1362 // rtl8139_pio_disable(dev); -
uspace/drv/nic/rtl8169/driver.c
rd076f16 r91b60499 371 371 rtl8169_irq_code.cmds[2].addr = rtl8169->regs + ISR; 372 372 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), 374 374 rtl8169->irq, rtl8169_irq_handler, &rtl8169_irq_code); 375 375 376 return rc;376 return irq_cap; 377 377 } 378 378 … … 426 426 goto err_pio; 427 427 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; 430 431 ddf_msg(LVL_ERROR, "Failed to register IRQ handler (%d)", rc); 431 432 goto err_irq; 432 433 433 } 434 434 … … 469 469 err_srv: 470 470 /* XXX Disconnect from services */ 471 unregister_interrupt_handler(dev, irq_cap); 471 472 err_irq: 472 //unregister_interrupt_handler(dev, rtl8169->irq);473 473 err_pio: 474 474 err_destroy: -
uspace/lib/c/generic/async.c
rd076f16 r91b60499 1048 1048 * 1049 1049 * @param inr IRQ number. 1050 * @param devno Device number of the device generating inr.1051 1050 * @param handler Notification handler. 1052 1051 * @param data Notification handler client data. 1053 1052 * @param ucode Top-half pseudocode handler. 1054 1053 * 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 */ 1058 int async_irq_subscribe(int inr, async_notification_handler_t handler, 1059 void *data, const irq_code_t *ucode) 1060 1060 { 1061 1061 notification_t *notification = … … 1077 1077 futex_up(&async_futex); 1078 1078 1079 return ipc_irq_subscribe(inr, devno,imethod, ucode);1079 return ipc_irq_subscribe(inr, imethod, ucode); 1080 1080 } 1081 1081 1082 1082 /** Unsubscribe from IRQ notification. 1083 1083 * 1084 * @param inr IRQ number. 1085 * @param devno Device number of the device generating inr. 1084 * @param cap IRQ capability handle. 1086 1085 * 1087 1086 * @return Zero on success or a negative error code. 1088 1087 * 1089 1088 */ 1090 int async_irq_unsubscribe(int inr, int devno)1089 int async_irq_unsubscribe(int cap) 1091 1090 { 1092 1091 // TODO: Remove entry from hash table 1093 1092 // to avoid memory leak 1094 1093 1095 return ipc_irq_unsubscribe( inr, devno);1094 return ipc_irq_unsubscribe(cap); 1096 1095 } 1097 1096 … … 1384 1383 async_new_connection(call->in_task_id, in_phone_hash, callid, 1385 1384 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 altogether1392 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);1396 1385 return; 1397 1386 } … … 2111 2100 2112 2101 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;2185 2102 } 2186 2103 … … 3153 3070 } 3154 3071 3155 /** Wrapper for sending an exchange over different exchange for cloning3156 *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 new3169 * 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 3215 3072 /** Wrapper for receiving the IPC_M_CONNECT_TO_ME calls. 3216 3073 * -
uspace/lib/c/generic/ddi.c
rd076f16 r91b60499 50 50 #include "private/libc.h" 51 51 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 }62 52 63 53 /** Map a piece of physical memory to task. -
uspace/lib/c/generic/irq.c
rd076f16 r91b60499 55 55 * 56 56 * @param inr IRQ number. 57 * @param devno Device number of the device generating inr.58 57 * @param method Use this method for notifying me. 59 58 * @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 */ 64 int 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. 60 75 * 61 76 * @return Value returned by the kernel. 62 77 * 63 78 */ 64 int ipc_irq_subscribe(int inr, int devno, sysarg_t method, 65 const irq_code_t *ucode) 79 int ipc_irq_unsubscribe(int cap) 66 80 { 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); 85 82 } 86 83 -
uspace/lib/c/include/async.h
rd076f16 r91b60499 166 166 sysarg_t, async_port_handler_t, void *, port_id_t *); 167 167 168 extern int async_irq_subscribe(int, int,async_notification_handler_t, void *,168 extern int async_irq_subscribe(int, async_notification_handler_t, void *, 169 169 const irq_code_t *); 170 extern int async_irq_unsubscribe(int , int);170 extern int async_irq_unsubscribe(int); 171 171 172 172 extern int async_event_subscribe(event_type_t, async_notification_handler_t, … … 343 343 sysarg_t *, sysarg_t *); 344 344 345 extern async_sess_t *async_clone_establish(exch_mgmt_t, async_exch_t *);346 345 extern async_sess_t *async_connect_me_to(exch_mgmt_t, async_exch_t *, sysarg_t, 347 346 sysarg_t, sysarg_t); … … 472 471 sysarg_t, sysarg_t, sysarg_t, ipc_call_t *); 473 472 474 extern int async_exchange_clone(async_exch_t *, async_exch_t *);475 extern async_sess_t *async_clone_receive(exch_mgmt_t);476 473 extern async_sess_t *async_callback_receive(exch_mgmt_t); 477 474 extern async_sess_t *async_callback_receive_start(exch_mgmt_t, ipc_call_t *); -
uspace/lib/c/include/ipc/irq.h
rd076f16 r91b60499 39 39 #include <abi/ddi/irq.h> 40 40 41 extern int ipc_irq_subscribe(int, int,sysarg_t, const irq_code_t *);42 extern int ipc_irq_unsubscribe(int , int);41 extern int ipc_irq_subscribe(int, sysarg_t, const irq_code_t *); 42 extern int ipc_irq_unsubscribe(int); 43 43 44 44 #endif -
uspace/lib/drv/generic/interrupt.c
rd076f16 r91b60499 44 44 45 45 int 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) 47 47 { 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); 50 50 } 51 51 52 int unregister_interrupt_handler(ddf_dev_t *dev, int irq)52 int unregister_interrupt_handler(ddf_dev_t *dev, int cap) 53 53 { 54 return async_irq_unsubscribe( irq, dev->handle);54 return async_irq_unsubscribe(cap); 55 55 } 56 56 -
uspace/lib/usbhost/src/ddf_helpers.c
rd076f16 r91b60499 748 748 * @param[in] gen_irq_code IRQ code generator. 749 749 * 750 * @return EOK on success or negative error code 750 * @return IRQ capability handle on success. 751 * @return Negative error code. 751 752 */ 752 753 int hcd_ddf_setup_interrupts(ddf_dev_t *device, … … 770 771 771 772 /* 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); 773 775 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); 774 784 if (ret != EOK) { 775 785 usb_log_error("Failed to register interrupt handler: %s.\n", 776 786 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; 790 791 } 791 792 … … 882 883 interrupt_handler_t *irq_handler = 883 884 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) { 887 889 usb_log_debug("Hw interrupts enabled.\n"); 888 890 } … … 899 901 /* Init hw driver */ 900 902 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); 902 904 hw_res_list_parsed_clean(&hw_res); 903 905 if (ret != EOK) { … … 907 909 908 910 /* Need working irq replacement to setup root hub */ 909 if ( (irq < 0)&& hcd->ops.status_hook) {911 if (!irqs_enabled && hcd->ops.status_hook) { 910 912 hcd->polling_fibril = fibril_create(interrupt_polling, hcd); 911 913 if (hcd->polling_fibril == 0) { … … 916 918 fibril_add_ready(hcd->polling_fibril); 917 919 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)); 919 921 } 920 922 … … 930 932 irq_unregister: 931 933 /* Unregistering non-existent should be ok */ 932 unregister_interrupt_handler(device, irq );934 unregister_interrupt_handler(device, irq_cap); 933 935 hcd_ddf_clean_hc(device); 934 936 return ret; -
uspace/srv/hid/input/port/msim.c
rd076f16 r91b60499 97 97 msim_ranges[0].base = paddr; 98 98 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); 101 100 102 101 return 0; -
uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.c
rd076f16 r91b60499 137 137 (void *) ts->paddr, inr); 138 138 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); 141 140 142 141 s3c24xx_ts_wait_for_int_mode(ts, updn_down); -
uspace/srv/hw/bus/cuda_adb/cuda_adb.c
rd076f16 r91b60499 282 282 cuda_irq_code.ranges[0].base = (uintptr_t) instance->cuda_physical; 283 283 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); 286 285 287 286 /* Enable SR interrupt. */ -
uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.c
rd076f16 r91b60499 193 193 (void *) uart->paddr, inr); 194 194 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); 197 196 198 197 /* Enable FIFO, Tx trigger level: empty, Rx trigger level: 1 byte. */
Note:
See TracChangeset
for help on using the changeset viewer.