/*

 * A dataspace server exposing regions of a MMC/SD card.

 *

 * Copyright (C) 2020, 2021, 2023, 2024 Paul Boddie <paul@boddie.org.uk>

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License as

 * published by the Free Software Foundation; either version 2 of

 * the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA  02110-1301, USA

 */

#include <l4/devices/cpm-x1600.h>

#include <l4/devices/dma.h>

#include <l4/devices/dma-x1600.h>

#include <l4/devices/memory.h>

#include <l4/devices/msc-x1600.h>

#include <l4/re/c/util/cap_alloc.h>

#include <l4/sys/debugger.h>

#include <l4/sys/err.h>

#include <l4/sys/factory.h>

#include <l4/sys/icu.h>

#include <l4/sys/ipc.h>

#include <l4/sys/irq.h>

#include <ipc/thread.h>

#include <stdio.h>

#include <stdlib.h>

#include <mem/memory_incremental.h>

#include <fsserver/page_queue_shared.h>

#include <fsserver/pages.h>

#include <resource/resource_server.h>

#include <systypes/env.h>

#include "msc_region_opener.h"

#include "msc_region_operations.h"

/* Common configuration. */

static l4_cap_idx_t icucap;

/* Device and resource discovery. */

static long item_in_range(long start, long end, long index)

{

  if (start < end)

    return start + index;

  else if (start > end)

    return start - index;

  else

    return start;

}

/* Common functions. */

static int init_irq(int num, l4_cap_idx_t irq, l4_uint32_t start, l4_uint32_t end)

{

  /* Create interrupt object. */

  long err = l4_error(l4_factory_create_irq(l4re_global_env->factory, irq));

  if (err)

  {

    printf("Could not create IRQ object: %ld\n", err);

    return 1;

  }

  /* Bind interrupt objects to IRQ numbers. */

  err = l4_error(l4_icu_bind(icucap,

                             item_in_range(start, end, num),

                             irq));

  if (err)

  {

    printf("Could not bind IRQ to the ICU: %ld\n", err);

    return 1;

  }

  return 0;

}

/* Peripheral resources. */

static Cpm_x1600_chip *cpm;

static Dma_x1600_chip *dma;

static Msc_x1600_chip *msc;

/* Obtain an abstraction for the memory card. */

static MscRegionOperations *get_msc_region_operations(int msc_channel_num,

                                                      int dma_channel_num,

                                                      int card)

{

  l4_addr_t cpm_base = 0, cpm_base_end = 0;

  l4_addr_t dma_base = 0, dma_base_end = 0;

  l4_addr_t msc_base = 0, msc_base_end = 0;

  l4_addr_t msc_phys_base = 0, msc_phys_base_end = 0;

  l4_uint32_t dma_irq_start = 0, dma_irq_end = 0;

  l4_uint32_t msc_irq_start = 0, msc_irq_end = 0;

  icucap = l4re_env_get_cap("icu");

  /* Obtain resource details describing I/O memory. */

  if (get_memory("x1600-cpm", &cpm_base, &cpm_base_end) < 0)

    return NULL;

  cpm = new Cpm_x1600_chip(cpm_base);

  if (get_memory("x1600-dma", &dma_base, &dma_base_end) < 0)

    return NULL;

  dma = new Dma_x1600_chip(dma_base, dma_base_end, cpm);

  if (get_irq("x1600-dma", &dma_irq_start, &dma_irq_end) < 0)

    return NULL;

  l4_cap_idx_t dma_irq = l4re_util_cap_alloc();

  if (init_irq(0, dma_irq, dma_irq_start, dma_irq_end))

    return NULL;

  dma->enable();

  if (get_memory_complete("x1600-msc", &msc_base, &msc_base_end,

                          &msc_phys_base, &msc_phys_base_end) < 0)

    return NULL;

  msc = new Msc_x1600_chip(msc_phys_base, msc_base, msc_base_end, cpm);

  if (get_irq("x1600-msc", &msc_irq_start, &msc_irq_end) < 0)

    return NULL;

  l4_cap_idx_t msc_irq = l4re_util_cap_alloc();

  if (init_irq(msc_channel_num, msc_irq, msc_irq_start, msc_irq_end))

    return NULL;

  Dma_x1600_channel *dma_channel = dma->get_channel(dma_channel_num, dma_irq);

  Msc_channel *msc_channel = msc->get_channel(msc_channel_num, msc_irq, dma_channel);

  msc_channel->enable();

  if (card >= msc_channel->num_cards())

    return NULL;

  struct dma_region region;

  if (get_dma_region(512, 12, &region))

    return NULL;

  return new MscRegionOperations(msc_channel, card, region);

}

/* Default number of pages for files. */

const unsigned int MEMORY_PAGES = 20;

/* Server program. */

int main(int argc, char *argv[])

{

  l4_debugger_set_object_name(l4re_env()->main_thread, "block_server");

  long err;

  /* Introduce concurrency control. */

  err = ipc_thread_init();

  if (err)

  {

    printf("Initialisation error: %s\n", l4sys_errtostr(err));

    return 1;

  }

  if (argc < 4)

  {

    printf("Need a MSC channel/peripheral number, a DMA channel number, " \

           "and a card number.\n\n" \

           "A number of memory pages can be indicated for the use of the " \

           "server.\n\n" \

           "A named capability from the environment can be specified.\n");

    return 1;

  }

  int msc_channel_num = atoi(argv[1]);

  int dma_channel_num = atoi(argv[2]);

  int card = atoi(argv[3]);

  unsigned int memory_pages = MEMORY_PAGES;

  if (argc > 4)

    memory_pages = atoi(argv[4]);

  const char *server_name = (argc > 5) ? argv[5] : ENV_FILESYSTEM_SERVER_NAME;

  /* Obtain a DMA space for associating allocated memory with physical

     addresses. */

  l4_cap_idx_t dma_space;

  err = get_dma_space(&dma_space);

  if (err)

  {

    printf("Could not obtain DMA space: %s\n", l4sys_errtostr(err));

    return 1;

  }

  MscRegionOperations *ops = get_msc_region_operations(msc_channel_num,

                                                       dma_channel_num,

                                                       card);

  if (ops == NULL)

  {

    printf("Could not access memory card peripheral.\n");

    return 1;

  }

  /* Some memory plus infrastructure. */

  MemoryIncremental mem(memory_pages, PAGE_SIZE, dma_space);

  PageQueueShared queue;

  Pages pages(&mem, &queue);

  ResourceRegistry registry(&pages);

  MscRegionOpener opener(&registry, ops);

  /* Register a server associating it with the given object. */

  ResourceServer server(&opener);

  server.bind(server_name);

  printf("Starting server using %d pages...\n", memory_pages);

  server.start();

  return 0;

}

// vim: tabstop=2 expandtab shiftwidth=2