Subversion Repositories HelenOS

Rev

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

  1. /*
  2.  * Copyright (c) 2009 Jiri Svoboda
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  *
  9.  * - Redistributions of source code must retain the above copyright
  10.  *   notice, this list of conditions and the following disclaimer.
  11.  * - Redistributions in binary form must reproduce the above copyright
  12.  *   notice, this list of conditions and the following disclaimer in the
  13.  *   documentation and/or other materials provided with the distribution.
  14.  * - The name of the author may not be used to endorse or promote products
  15.  *   derived from this software without specific prior written permission.
  16.  *
  17.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18.  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20.  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21.  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26.  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27.  */
  28.  
  29. /** @addtogroup bd
  30.  * @{
  31.  */
  32.  
  33. /**
  34.  * @file
  35.  * @brief GXemul disk driver
  36.  */
  37.  
  38. #include <stdio.h>
  39. #include <libarch/ddi.h>
  40. #include <ddi.h>
  41. #include <ipc/ipc.h>
  42. #include <ipc/bd.h>
  43. #include <async.h>
  44. #include <as.h>
  45. #include <futex.h>
  46. #include <devmap.h>
  47. #include <sys/types.h>
  48. #include <errno.h>
  49.  
  50. #define NAME "gxe_bd"
  51.  
  52. enum {
  53.     CTL_READ_START  = 0,
  54.     CTL_WRITE_START = 1,
  55. };
  56.  
  57. enum {
  58.     STATUS_FAILURE  = 0
  59. };
  60.  
  61. typedef struct {
  62.     uint32_t offset_lo;
  63.     uint32_t pad0;
  64.     uint32_t offset_hi;
  65.     uint32_t pad1;
  66.  
  67.     uint32_t disk_id;
  68.     uint32_t pad2[3];
  69.  
  70.     uint32_t control;
  71.     uint32_t pad3[3];
  72.  
  73.     uint32_t status;
  74.  
  75. /*  FIXME: Need to fix pio_enable() to support >= page_size areas.
  76.  
  77.     uint32_t pad4[3];
  78.     uint32_t pad5[0x3fc0];
  79.  
  80.     uint8_t buffer[512];*/
  81. } gxe_bd_t;
  82.  
  83. typedef struct {
  84.     uint8_t buffer[512];
  85. } gxe_buf_t;
  86.  
  87. static size_t maxblock_size = 512;
  88. static uintptr_t dev_physical = 0x13000000;
  89. static gxe_bd_t *dev;
  90. static gxe_buf_t *devbuf;
  91.  
  92. static uint32_t disk_id = 0;
  93.  
  94. static atomic_t dev_futex = FUTEX_INITIALIZER;
  95.  
  96. static int gxe_bd_init(void);
  97. static void gxe_bd_connection(ipc_callid_t iid, ipc_call_t *icall);
  98. static int gxe_bd_read_block(uint64_t offset, size_t block_size, void *buf);
  99. static int gxe_bd_write_block(uint64_t offset, size_t block_size,
  100.     const void *buf);
  101.  
  102. int main(int argc, char **argv)
  103. {
  104.     printf(NAME ": GXemul disk driver\n");
  105.  
  106.     if (gxe_bd_init() != EOK)
  107.         return -1;
  108.  
  109.     printf(NAME ": Accepting connections\n");
  110.     async_manager();
  111.  
  112.     /* Not reached */
  113.     return 0;
  114. }
  115.  
  116. static int gxe_bd_init(void)
  117. {
  118.     dev_handle_t dev_handle;
  119.     void *vaddr;
  120.     int rc;
  121.  
  122.     rc = devmap_driver_register(NAME, gxe_bd_connection);
  123.     if (rc < 0) {
  124.         printf(NAME ": Unable to register driver.\n");
  125.         return rc;
  126.     }
  127.  
  128.     rc = pio_enable((void *) dev_physical, sizeof(gxe_bd_t), &vaddr);
  129.     if (rc != EOK) {
  130.         printf(NAME ": Could not initialize device I/O space.\n");
  131.         return rc;
  132.     }
  133.  
  134.     dev = vaddr;
  135.  
  136.     rc = pio_enable((void *) dev_physical + 0x4000, sizeof(gxe_buf_t), &vaddr);
  137.     if (rc != EOK) {
  138.         printf(NAME ": Could not initialize device I/O space.\n");
  139.         return rc;
  140.     }
  141.  
  142.     devbuf = vaddr;
  143.  
  144.     rc = devmap_device_register("disk0", &dev_handle);
  145.     if (rc != EOK) {
  146.         devmap_hangup_phone(DEVMAP_DRIVER);
  147.         printf(NAME ": Unable to register device.\n");
  148.         return rc;
  149.     }
  150.  
  151.     return EOK;
  152. }
  153.  
  154. static void gxe_bd_connection(ipc_callid_t iid, ipc_call_t *icall)
  155. {
  156.     void *fs_va = NULL;
  157.     ipc_callid_t callid;
  158.     ipc_call_t call;
  159.     int flags;
  160.     int retval;
  161.     off_t offset;
  162.     size_t block_size;
  163.  
  164.     /* Answer the IPC_M_CONNECT_ME_TO call. */
  165.     ipc_answer_0(iid, EOK);
  166.  
  167.     if (!ipc_share_out_receive(&callid, &maxblock_size, &flags)) {
  168.         ipc_answer_0(callid, EHANGUP);
  169.         return;
  170.     }
  171.     maxblock_size = 512;
  172.  
  173.     fs_va = as_get_mappable_page(maxblock_size);
  174.     if (fs_va == NULL) {
  175.         ipc_answer_0(callid, EHANGUP);
  176.         return;
  177.     }
  178.  
  179.     (void) ipc_share_out_finalize(callid, fs_va);
  180.  
  181.     while (1) {
  182.         callid = async_get_call(&call);
  183.         switch (IPC_GET_METHOD(call)) {
  184.         case IPC_M_PHONE_HUNGUP:
  185.             /* The other side has hung up. */
  186.             ipc_answer_0(callid, EOK);
  187.             return;
  188.         case BD_READ_BLOCK:
  189.             offset = IPC_GET_ARG1(call);
  190.             block_size = IPC_GET_ARG2(call);
  191.             retval = gxe_bd_read_block(offset, block_size, fs_va);
  192.             break;
  193.         case BD_WRITE_BLOCK:
  194.             offset = IPC_GET_ARG1(call);
  195.             block_size = IPC_GET_ARG2(call);
  196.             retval = gxe_bd_write_block(offset, block_size, fs_va);
  197.             break;
  198.         default:
  199.             retval = EINVAL;
  200.             break;
  201.         }
  202.         ipc_answer_0(callid, retval);
  203.     }
  204. }
  205.  
  206. static int gxe_bd_read_block(uint64_t offset, size_t block_size, void *buf)
  207. {
  208.     uint32_t status;
  209.     size_t i;
  210.     uint32_t w;
  211.  
  212.     if (block_size != maxblock_size) {
  213.         printf("Failed: bs = %d, mbs = %d\n", block_size,
  214.             maxblock_size);
  215.         return EINVAL;
  216.     }
  217.  
  218.     futex_down(&dev_futex);
  219.     pio_write_32(&dev->offset_lo, (uint32_t) offset);
  220.     pio_write_32(&dev->offset_hi, offset >> 32);
  221.     pio_write_32(&dev->disk_id, disk_id);
  222.     pio_write_32(&dev->control, CTL_READ_START);
  223.  
  224.     status = pio_read_32(&dev->status);
  225.     if (status == STATUS_FAILURE) {
  226.         return EIO;
  227.     }
  228.  
  229.     for (i = 0; i < maxblock_size; i++) {
  230.         ((uint8_t *) buf)[i] = w =
  231.             pio_read_8(&devbuf->buffer[i]);
  232.     }
  233.  
  234.     futex_up(&dev_futex);
  235.     return EOK;
  236. }
  237.  
  238. static int gxe_bd_write_block(uint64_t offset, size_t block_size,
  239.     const void *buf)
  240. {
  241.     uint32_t status;
  242.     size_t i;
  243.     uint32_t w;
  244.  
  245.     if (block_size != maxblock_size) {
  246.         printf("Failed: bs = %d, mbs = %d\n", block_size,
  247.             maxblock_size);
  248.         return EINVAL;
  249.     }
  250.  
  251.     for (i = 0; i < maxblock_size; i++) {
  252.         pio_write_8(&devbuf->buffer[i], ((const uint8_t *) buf)[i]);
  253.     }
  254.  
  255.     futex_down(&dev_futex);
  256.     pio_write_32(&dev->offset_lo, (uint32_t) offset);
  257.     pio_write_32(&dev->offset_hi, offset >> 32);
  258.     pio_write_32(&dev->disk_id, disk_id);
  259.     pio_write_32(&dev->control, CTL_WRITE_START);
  260.  
  261.     status = pio_read_32(&dev->status);
  262.     if (status == STATUS_FAILURE) {
  263.         return EIO;
  264.     }
  265.  
  266.     futex_up(&dev_futex);
  267.     return EOK;
  268. }
  269.  
  270. /**
  271.  * @}
  272.  */
  273.