Subversion Repositories HelenOS

Rev

Rev 3875 | Rev 3947 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Copyright (c) 2006 Ondrej Palkovsky
  3.  * Copyright (c) 2006 Jakub Jermar
  4.  * All rights reserved.
  5.  *
  6.  * Redistribution and use in source and binary forms, with or without
  7.  * modification, are permitted provided that the following conditions
  8.  * are met:
  9.  *
  10.  * - Redistributions of source code must retain the above copyright
  11.  *   notice, this list of conditions and the following disclaimer.
  12.  * - Redistributions in binary form must reproduce the above copyright
  13.  *   notice, this list of conditions and the following disclaimer in the
  14.  *   documentation and/or other materials provided with the distribution.
  15.  * - The name of the author may not be used to endorse or promote products
  16.  *   derived from this software without specific prior written permission.
  17.  *
  18.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19.  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21.  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22.  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27.  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28.  */
  29.  
  30. /** @addtogroup genericipc
  31.  * @{
  32.  */
  33. /**
  34.  * @file
  35.  * @brief IRQ notification framework.
  36.  *
  37.  * This framework allows applications to register to receive a notification
  38.  * when interrupt is detected. The application may provide a simple 'top-half'
  39.  * handler as part of its registration, which can perform simple operations
  40.  * (read/write port/memory, add information to notification ipc message).
  41.  *
  42.  * The structure of a notification message is as follows:
  43.  * - METHOD: method as registered by the SYS_IPC_REGISTER_IRQ syscall
  44.  * - ARG1: payload modified by a 'top-half' handler
  45.  * - ARG2: payload modified by a 'top-half' handler
  46.  * - ARG3: payload modified by a 'top-half' handler
  47.  * - in_phone_hash: interrupt counter (may be needed to assure correct order
  48.  *         in multithreaded drivers)
  49.  */
  50.  
  51. #include <arch.h>
  52. #include <mm/slab.h>
  53. #include <errno.h>
  54. #include <ddi/irq.h>
  55. #include <ipc/ipc.h>
  56. #include <ipc/irq.h>
  57. #include <syscall/copy.h>
  58. #include <console/console.h>
  59. #include <print.h>
  60.  
  61. /** Execute code associated with IRQ notification.
  62.  *
  63.  * @param call      Notification call.
  64.  * @param code      Top-half pseudocode.
  65.  */
  66. static void code_execute(call_t *call, irq_code_t *code)
  67. {
  68.     unsigned int i;
  69.     unative_t dstval = 0;
  70.    
  71.     if (!code)
  72.         return;
  73.    
  74.     for (i = 0; i < code->cmdcount; i++) {
  75.         switch (code->cmds[i].cmd) {
  76.         case CMD_MEM_READ_1:
  77.             dstval = *((uint8_t *) code->cmds[i].addr);
  78.             break;
  79.         case CMD_MEM_READ_2:
  80.             dstval = *((uint16_t *) code->cmds[i].addr);
  81.             break;
  82.         case CMD_MEM_READ_4:
  83.             dstval = *((uint32_t *) code->cmds[i].addr);
  84.             break;
  85.         case CMD_MEM_READ_8:
  86.             dstval = *((uint64_t *) code->cmds[i].addr);
  87.             break;
  88.         case CMD_MEM_WRITE_1:
  89.             *((uint8_t *) code->cmds[i].addr) = code->cmds[i].value;
  90.             break;
  91.         case CMD_MEM_WRITE_2:
  92.             *((uint16_t *) code->cmds[i].addr) =
  93.                 code->cmds[i].value;
  94.             break;
  95.         case CMD_MEM_WRITE_4:
  96.             *((uint32_t *) code->cmds[i].addr) =
  97.                 code->cmds[i].value;
  98.             break;
  99.         case CMD_MEM_WRITE_8:
  100.             *((uint64_t *) code->cmds[i].addr) =
  101.                 code->cmds[i].value;
  102.             break;
  103.         case CMD_PORT_READ_1:
  104.             dstval = pio_read_8((long) code->cmds[i].addr);
  105.             break;
  106.         case CMD_PORT_WRITE_1:
  107.             pio_write_8((long) code->cmds[i].addr, code->cmds[i].value);
  108.             break;
  109.         default:
  110.             break;
  111.         }
  112.         if (code->cmds[i].dstarg && code->cmds[i].dstarg <
  113.             IPC_CALL_LEN) {
  114.             call->data.args[code->cmds[i].dstarg] = dstval;
  115.         }
  116.     }
  117. }
  118.  
  119. /** Free top-half pseudocode.
  120.  *
  121.  * @param code      Pointer to the top-half pseudocode.
  122.  */
  123. static void code_free(irq_code_t *code)
  124. {
  125.     if (code) {
  126.         free(code->cmds);
  127.         free(code);
  128.     }
  129. }
  130.  
  131. /** Copy top-half pseudocode from userspace into the kernel.
  132.  *
  133.  * @param ucode     Userspace address of the top-half pseudocode.
  134.  *
  135.  * @return      Kernel address of the copied pseudocode.
  136.  */
  137. static irq_code_t *code_from_uspace(irq_code_t *ucode)
  138. {
  139.     irq_code_t *code;
  140.     irq_cmd_t *ucmds;
  141.     int rc;
  142.  
  143.     code = malloc(sizeof(*code), 0);
  144.     rc = copy_from_uspace(code, ucode, sizeof(*code));
  145.     if (rc != 0) {
  146.         free(code);
  147.         return NULL;
  148.     }
  149.    
  150.     if (code->cmdcount > IRQ_MAX_PROG_SIZE) {
  151.         free(code);
  152.         return NULL;
  153.     }
  154.     ucmds = code->cmds;
  155.     code->cmds = malloc(sizeof(code->cmds[0]) * code->cmdcount, 0);
  156.     rc = copy_from_uspace(code->cmds, ucmds,
  157.         sizeof(code->cmds[0]) * code->cmdcount);
  158.     if (rc != 0) {
  159.         free(code->cmds);
  160.         free(code);
  161.         return NULL;
  162.     }
  163.  
  164.     return code;
  165. }
  166.  
  167. /** Unregister task from IRQ notification.
  168.  *
  169.  * @param box       Answerbox associated with the notification.
  170.  * @param inr       IRQ number.
  171.  * @param devno     Device number.
  172.  */
  173. void ipc_irq_unregister(answerbox_t *box, inr_t inr, devno_t devno)
  174. {
  175.     ipl_t ipl;
  176.     irq_t *irq;
  177.  
  178.     ipl = interrupts_disable();
  179.     irq = irq_find_and_lock(inr, devno);
  180.     if (irq) {
  181.         if (irq->notif_cfg.answerbox == box) {
  182.             code_free(irq->notif_cfg.code);
  183.             irq->notif_cfg.notify = false;
  184.             irq->notif_cfg.answerbox = NULL;
  185.             irq->notif_cfg.code = NULL;
  186.             irq->notif_cfg.method = 0;
  187.             irq->notif_cfg.counter = 0;
  188.  
  189.             spinlock_lock(&box->irq_lock);
  190.             list_remove(&irq->notif_cfg.link);
  191.             spinlock_unlock(&box->irq_lock);
  192.            
  193.             spinlock_unlock(&irq->lock);
  194.         }
  195.     }
  196.     interrupts_restore(ipl);
  197. }
  198.  
  199. /** Register an answerbox as a receiving end for IRQ notifications.
  200.  *
  201.  * @param box       Receiving answerbox.
  202.  * @param inr       IRQ number.
  203.  * @param devno     Device number.
  204.  * @param method    Method to be associated with the notification.
  205.  * @param ucode     Uspace pointer to top-half pseudocode.
  206.  *
  207.  * @return      EBADMEM, ENOENT or EEXISTS on failure or 0 on success.
  208.  */
  209. int ipc_irq_register(answerbox_t *box, inr_t inr, devno_t devno,
  210.     unative_t method, irq_code_t *ucode)
  211. {
  212.     ipl_t ipl;
  213.     irq_code_t *code;
  214.     irq_t *irq;
  215.  
  216.     if (ucode) {
  217.         code = code_from_uspace(ucode);
  218.         if (!code)
  219.             return EBADMEM;
  220.     } else {
  221.         code = NULL;
  222.     }
  223.  
  224.     ipl = interrupts_disable();
  225.     irq = irq_find_and_lock(inr, devno);
  226.     if (!irq) {
  227.         interrupts_restore(ipl);
  228.         code_free(code);
  229.         return ENOENT;
  230.     }
  231.    
  232.     if (irq->notif_cfg.answerbox) {
  233.         spinlock_unlock(&irq->lock);
  234.         interrupts_restore(ipl);
  235.         code_free(code);
  236.         return EEXISTS;
  237.     }
  238.    
  239.     irq->notif_cfg.notify = true;
  240.     irq->notif_cfg.answerbox = box;
  241.     irq->notif_cfg.method = method;
  242.     irq->notif_cfg.code = code;
  243.     irq->notif_cfg.counter = 0;
  244.  
  245.     spinlock_lock(&box->irq_lock);
  246.     list_append(&irq->notif_cfg.link, &box->irq_head);
  247.     spinlock_unlock(&box->irq_lock);
  248.  
  249.     spinlock_unlock(&irq->lock);
  250.     interrupts_restore(ipl);
  251.  
  252.     return 0;
  253. }
  254.  
  255. /** Add a call to the proper answerbox queue.
  256.  *
  257.  * Assume irq->lock is locked.
  258.  *
  259.  * @param irq       IRQ structure referencing the target answerbox.
  260.  * @param call      IRQ notification call.
  261.  */
  262. static void send_call(irq_t *irq, call_t *call)
  263. {
  264.     spinlock_lock(&irq->notif_cfg.answerbox->irq_lock);
  265.     list_append(&call->link, &irq->notif_cfg.answerbox->irq_notifs);
  266.     spinlock_unlock(&irq->notif_cfg.answerbox->irq_lock);
  267.        
  268.     waitq_wakeup(&irq->notif_cfg.answerbox->wq, WAKEUP_FIRST);
  269. }
  270.  
  271. /** Send notification message.
  272.  *
  273.  * @param irq       IRQ structure.
  274.  * @param a1        Driver-specific payload argument.
  275.  * @param a2        Driver-specific payload argument.
  276.  * @param a3        Driver-specific payload argument.
  277.  * @param a4        Driver-specific payload argument.
  278.  * @param a5        Driver-specific payload argument.
  279.  */
  280. void ipc_irq_send_msg(irq_t *irq, unative_t a1, unative_t a2, unative_t a3,
  281.     unative_t a4, unative_t a5)
  282. {
  283.     call_t *call;
  284.  
  285.     spinlock_lock(&irq->lock);
  286.  
  287.     if (irq->notif_cfg.answerbox) {
  288.         call = ipc_call_alloc(FRAME_ATOMIC);
  289.         if (!call) {
  290.             spinlock_unlock(&irq->lock);
  291.             return;
  292.         }
  293.         call->flags |= IPC_CALL_NOTIF;
  294.         IPC_SET_METHOD(call->data, irq->notif_cfg.method);
  295.         IPC_SET_ARG1(call->data, a1);
  296.         IPC_SET_ARG2(call->data, a2);
  297.         IPC_SET_ARG3(call->data, a3);
  298.         IPC_SET_ARG4(call->data, a4);
  299.         IPC_SET_ARG5(call->data, a5);
  300.         /* Put a counter to the message */
  301.         call->priv = ++irq->notif_cfg.counter;
  302.        
  303.         send_call(irq, call);
  304.     }
  305.     spinlock_unlock(&irq->lock);
  306. }
  307.  
  308. /** Notify a task that an IRQ had occurred.
  309.  *
  310.  * We expect interrupts to be disabled and the irq->lock already held.
  311.  *
  312.  * @param irq       IRQ structure.
  313.  */
  314. void ipc_irq_send_notif(irq_t *irq)
  315. {
  316.     call_t *call;
  317.  
  318.     ASSERT(irq);
  319.  
  320.     if (irq->notif_cfg.answerbox) {
  321.         call = ipc_call_alloc(FRAME_ATOMIC);
  322.         if (!call) {
  323.             return;
  324.         }
  325.         call->flags |= IPC_CALL_NOTIF;
  326.         /* Put a counter to the message */
  327.         call->priv = ++irq->notif_cfg.counter;
  328.         /* Set up args */
  329.         IPC_SET_METHOD(call->data, irq->notif_cfg.method);
  330.  
  331.         /* Execute code to handle irq */
  332.         code_execute(call, irq->notif_cfg.code);
  333.        
  334.         send_call(irq, call);
  335.     }
  336. }
  337.  
  338. /** Disconnect all IRQ notifications from an answerbox.
  339.  *
  340.  * This function is effective because the answerbox contains
  341.  * list of all irq_t structures that are registered to
  342.  * send notifications to it.
  343.  *
  344.  * @param box       Answerbox for which we want to carry out the cleanup.
  345.  */
  346. void ipc_irq_cleanup(answerbox_t *box)
  347. {
  348.     ipl_t ipl;
  349.    
  350. loop:
  351.     ipl = interrupts_disable();
  352.     spinlock_lock(&box->irq_lock);
  353.    
  354.     while (box->irq_head.next != &box->irq_head) {
  355.         link_t *cur = box->irq_head.next;
  356.         irq_t *irq;
  357.         DEADLOCK_PROBE_INIT(p_irqlock);
  358.        
  359.         irq = list_get_instance(cur, irq_t, notif_cfg.link);
  360.         if (!spinlock_trylock(&irq->lock)) {
  361.             /*
  362.              * Avoid deadlock by trying again.
  363.              */
  364.             spinlock_unlock(&box->irq_lock);
  365.             interrupts_restore(ipl);
  366.             DEADLOCK_PROBE(p_irqlock, DEADLOCK_THRESHOLD);
  367.             goto loop;
  368.         }
  369.        
  370.         ASSERT(irq->notif_cfg.answerbox == box);
  371.        
  372.         list_remove(&irq->notif_cfg.link);
  373.        
  374.         /*
  375.          * Don't forget to free any top-half pseudocode.
  376.          */
  377.         code_free(irq->notif_cfg.code);
  378.        
  379.         irq->notif_cfg.notify = false;
  380.         irq->notif_cfg.answerbox = NULL;
  381.         irq->notif_cfg.code = NULL;
  382.         irq->notif_cfg.method = 0;
  383.         irq->notif_cfg.counter = 0;
  384.  
  385.         spinlock_unlock(&irq->lock);
  386.     }
  387.    
  388.     spinlock_unlock(&box->irq_lock);
  389.     interrupts_restore(ipl);
  390. }
  391.  
  392. /** @}
  393.  */
  394.