Subversion Repositories HelenOS

Rev

Rev 1923 | Rev 1933 | 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.     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) = code->cmds[i].value;
  93.             break;
  94.         case CMD_MEM_WRITE_4:
  95.             *((uint32_t *)code->cmds[i].addr) = code->cmds[i].value;
  96.             break;
  97.         case CMD_MEM_WRITE_8:
  98.             *((uint64_t *)code->cmds[i].addr) = code->cmds[i].value;
  99.             break;
  100. #if defined(ia32) || defined(amd64)
  101.         case CMD_PORT_READ_1:
  102.             dstval = inb((long)code->cmds[i].addr);
  103.             break;
  104.         case CMD_PORT_WRITE_1:
  105.             outb((long)code->cmds[i].addr, code->cmds[i].value);
  106.             break;
  107. #endif
  108. #if defined(ia64)
  109.         case CMD_IA64_GETCHAR:
  110.             dstval = _getc(&ski_uconsole);
  111.             break;
  112. #endif
  113. #if defined(ppc32)
  114.         case CMD_PPC32_GETCHAR:
  115.             dstval = cuda_get_scancode();
  116.             break;
  117. #endif
  118.         default:
  119.             break;
  120.         }
  121.         if (code->cmds[i].dstarg && code->cmds[i].dstarg < 4) {
  122.             call->data.args[code->cmds[i].dstarg] = dstval;
  123.         }
  124.     }
  125. }
  126.  
  127. static void code_free(irq_code_t *code)
  128. {
  129.     if (code) {
  130.         free(code->cmds);
  131.         free(code);
  132.     }
  133. }
  134.  
  135. static irq_code_t * code_from_uspace(irq_code_t *ucode)
  136. {
  137.     irq_code_t *code;
  138.     irq_cmd_t *ucmds;
  139.     int rc;
  140.  
  141.     code = malloc(sizeof(*code), 0);
  142.     rc = copy_from_uspace(code, ucode, sizeof(*code));
  143.     if (rc != 0) {
  144.         free(code);
  145.         return NULL;
  146.     }
  147.    
  148.     if (code->cmdcount > IRQ_MAX_PROG_SIZE) {
  149.         free(code);
  150.         return NULL;
  151.     }
  152.     ucmds = code->cmds;
  153.     code->cmds = malloc(sizeof(code->cmds[0]) * (code->cmdcount), 0);
  154.     rc = copy_from_uspace(code->cmds, ucmds, sizeof(code->cmds[0]) * (code->cmdcount));
  155.     if (rc != 0) {
  156.         free(code->cmds);
  157.         free(code);
  158.         return NULL;
  159.     }
  160.  
  161.     return code;
  162. }
  163.  
  164. /** Unregister task from IRQ notification.
  165.  *
  166.  * @param box Answerbox associated with the notification.
  167.  * @param inr IRQ numbe.
  168.  * @param devno Device number.
  169.  */
  170. void ipc_irq_unregister(answerbox_t *box, inr_t inr, devno_t devno)
  171. {
  172.     ipl_t ipl;
  173.     irq_t *irq;
  174.  
  175.     ipl = interrupts_disable();
  176.     irq = irq_find_and_lock(inr, devno);
  177.     if (irq) {
  178.         if (irq->notif_cfg.answerbox == box) {
  179.             irq->notif_cfg.notify = false;
  180.             irq->notif_cfg.answerbox = NULL;
  181.             irq->notif_cfg.code = NULL;
  182.             irq->notif_cfg.method = 0;
  183.             irq->notif_cfg.counter = 0;
  184.             code_free(irq->notif_cfg.code);
  185.             spinlock_unlock(&irq->lock);
  186.         }
  187.     }
  188.     interrupts_restore(ipl);
  189. }
  190.  
  191. /** Register an answerbox as a receiving end for IRQ notifications.
  192.  *
  193.  * @param box Receiving answerbox.
  194.  * @param inr IRQ number.
  195.  * @param devno Device number.
  196.  * @param method Method to be associated with the notification.
  197.  * @param ucode Uspace pointer to top-half pseudocode.
  198.  *
  199.  * @return EBADMEM, ENOENT or EEXISTS on failure or 0 on success.
  200.  */
  201. int
  202. ipc_irq_register(answerbox_t *box, inr_t inr, devno_t devno, unative_t method, irq_code_t *ucode)
  203. {
  204.     ipl_t ipl;
  205.     irq_code_t *code;
  206.     irq_t *irq;
  207.  
  208.     if (ucode) {
  209.         code = code_from_uspace(ucode);
  210.         if (!code)
  211.             return EBADMEM;
  212.     } else
  213.         code = NULL;
  214.  
  215.     ipl = interrupts_disable();
  216.     irq = irq_find_and_lock(inr, devno);
  217.     if (!irq) {
  218.         interrupts_restore(ipl);
  219.         code_free(code);
  220.         return ENOENT;
  221.     }
  222.    
  223.     if (irq->notif_cfg.answerbox) {
  224.         spinlock_unlock(&irq->lock);
  225.         interrupts_restore(ipl);
  226.         code_free(code);
  227.         return EEXISTS;
  228.     }
  229.    
  230.     irq->notif_cfg.notify = true;
  231.     irq->notif_cfg.answerbox = box;
  232.     irq->notif_cfg.method = method;
  233.     irq->notif_cfg.code = code;
  234.     irq->notif_cfg.counter = 0;
  235.     spinlock_unlock(&irq->lock);
  236.     interrupts_restore(ipl);
  237.  
  238.     return 0;
  239. }
  240.  
  241. /** Add call to proper answerbox queue.
  242.  *
  243.  * Assume irq->lock is locked.
  244.  *
  245.  */
  246. static void send_call(irq_t *irq, call_t *call)
  247. {
  248.     spinlock_lock(&irq->notif_cfg.answerbox->irq_lock);
  249.     list_append(&call->link, &irq->notif_cfg.answerbox->irq_notifs);
  250.     spinlock_unlock(&irq->notif_cfg.answerbox->irq_lock);
  251.        
  252.     waitq_wakeup(&irq->notif_cfg.answerbox->wq, WAKEUP_FIRST);
  253. }
  254.  
  255. /** Send notification message
  256.  *
  257.  */
  258. void ipc_irq_send_msg(irq_t *irq, unative_t a1, unative_t a2, unative_t a3)
  259. {
  260.     call_t *call;
  261.  
  262.     spinlock_lock(&irq->lock);
  263.  
  264.     if (irq->notif_cfg.answerbox) {
  265.         call = ipc_call_alloc(FRAME_ATOMIC);
  266.         if (!call) {
  267.             spinlock_unlock(&irq->lock);
  268.             return;
  269.         }
  270.         call->flags |= IPC_CALL_NOTIF;
  271.         IPC_SET_METHOD(call->data, irq->notif_cfg.method);
  272.         IPC_SET_ARG1(call->data, a1);
  273.         IPC_SET_ARG2(call->data, a2);
  274.         IPC_SET_ARG3(call->data, a3);
  275.         /* Put a counter to the message */
  276.         call->private = ++irq->notif_cfg.counter;
  277.        
  278.         send_call(irq, call);
  279.     }
  280.     spinlock_unlock(&irq->lock);
  281. }
  282.  
  283. /** Notify task that an irq had occurred.
  284.  *
  285.  * We expect interrupts to be disabled and the irq->lock already held.
  286.  */
  287. void ipc_irq_send_notif(irq_t *irq)
  288. {
  289.     call_t *call;
  290.  
  291.     ASSERT(irq);
  292.  
  293.     if (irq->notif_cfg.answerbox) {
  294.         call = ipc_call_alloc(FRAME_ATOMIC);
  295.         if (!call) {
  296.             return;
  297.         }
  298.         call->flags |= IPC_CALL_NOTIF;
  299.         /* Put a counter to the message */
  300.         call->private = ++irq->notif_cfg.counter;
  301.         /* Set up args */
  302.         IPC_SET_METHOD(call->data, irq->notif_cfg.method);
  303.  
  304.         /* Execute code to handle irq */
  305.         code_execute(call, irq->notif_cfg.code);
  306.        
  307.         send_call(irq, call);
  308.     }
  309. }
  310.  
  311. /** Disconnect all IRQ notifications from an answerbox.
  312.  *
  313.  * @param box Answerbox for which we want to carry out the cleanup.
  314.  */
  315. void ipc_irq_cleanup(answerbox_t *box)
  316. {
  317.     /* TODO */
  318. }
  319.  
  320. /** @}
  321.  */
  322.