Subversion Repositories openrisc_me

/*  This file is part of the program psim.

    Copyright (C) 1994-1996, Andrew Cagney <cagney@highland.com.au>

    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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

    */

#ifndef _DEVICE_TABLE_C_

#define _DEVICE_TABLE_C_

#include "device_table.h"

#if HAVE_STDLIB_H

#include <stdlib.h>

#endif

#include <ctype.h>

/* Helper functions */

/* Go through the devices various reg properties for those that

   specify attach addresses */

void

generic_device_init_address(device *me)

{

  static const char *(reg_property_names[]) = {

    "attach-addresses",

    "assigned-addresses",

    "reg",

    "alternate-reg" ,

    NULL

  };

  const char **reg_property_name;

  int nr_valid_reg_properties = 0;

  for (reg_property_name = reg_property_names;

       *reg_property_name != NULL;

       reg_property_name++) {

    if (device_find_property(me, *reg_property_name) != NULL) {

      reg_property_spec reg;

      int reg_entry;

      for (reg_entry = 0;

           device_find_reg_array_property(me, *reg_property_name, reg_entry,

                                          &reg);

           reg_entry++) {

        unsigned_word attach_address;

        int attach_space;

        unsigned attach_size;

        if (!device_address_to_attach_address(device_parent(me),

                                              &reg.address,

                                              &attach_space, &attach_address,

                                              me))

          continue;

        if (!device_size_to_attach_size(device_parent(me),

                                        &reg.size,

                                        &attach_size, me))

          continue;

        device_attach_address(device_parent(me),

                              attach_callback,

                              attach_space, attach_address, attach_size,

                              access_read_write_exec,

                              me);

        nr_valid_reg_properties++;

      }

      /* if first option matches don't try for any others */

      if (reg_property_name == reg_property_names)

        break;

    }

  }

}

int

generic_device_unit_decode(device *bus,

                           const char *unit,

                           device_unit *phys)

{

  memset(phys, 0, sizeof(device_unit));

  if (unit == NULL)

    return 0;

  else {

    int nr_cells = 0;

    const int max_nr_cells = device_nr_address_cells(bus);

    while (1) {

      char *end = NULL;

      unsigned long val;

      val = strtoul(unit, &end, 0);

      /* parse error? */

      if (unit == end)

        return -1;

      /* two many cells? */

      if (nr_cells >= max_nr_cells)

        return -1;

      /* save it */

      phys->cells[nr_cells] = val;

      nr_cells++;

      unit = end;

      /* more to follow? */

      if (isspace(*unit) || *unit == '\0')

        break;

      if (*unit != ',')

        return -1;

      unit++;

    }

    if (nr_cells < max_nr_cells) {

      /* shift everything to correct position */

      int i;

      for (i = 1; i <= nr_cells; i++)

        phys->cells[max_nr_cells - i] = phys->cells[nr_cells - i];

      for (i = 0; i < (max_nr_cells - nr_cells); i++)

        phys->cells[i] = 0;

    }

    phys->nr_cells = max_nr_cells;

    return max_nr_cells;

  }

}

int

generic_device_unit_encode(device *bus,

                           const device_unit *phys,

                           char *buf,

                           int sizeof_buf)

{

  int i;

  int len;

  char *pos = buf;

  /* skip leading zero's */

  for (i = 0; i < phys->nr_cells; i++) {

    if (phys->cells[i] != 0)

      break;

  }

  /* don't output anything if empty */

  if (phys->nr_cells == 0) {

    strcpy(pos, "");

    len = 0;

  }

  else if (i == phys->nr_cells) {

    /* all zero */

    strcpy(pos, "0");

    len = 1;

  }

  else {

    for (; i < phys->nr_cells; i++) {

      if (pos != buf) {

        strcat(pos, ",");

        pos = strchr(pos, '\0');

      }

      if (phys->cells[i] < 10)

        sprintf(pos, "%ld", (unsigned long)phys->cells[i]);

      else

        sprintf(pos, "0x%lx", (unsigned long)phys->cells[i]);

      pos = strchr(pos, '\0');

    }

    len = pos - buf;

  }

  if (len >= sizeof_buf)

    error("generic_unit_encode - buffer overflow\n");

  return len;

}

int

generic_device_address_to_attach_address(device *me,

                                         const device_unit *address,

                                         int *attach_space,

                                         unsigned_word *attach_address,

                                         device *client)

{

  int i;

  for (i = 0; i < address->nr_cells - 2; i++) {

    if (address->cells[i] != 0)

      device_error(me, "Only 32bit addresses supported");

  }

  if (address->nr_cells >= 2)

    *attach_space = address->cells[address->nr_cells - 2];

  else

    *attach_space = 0;

  *attach_address = address->cells[address->nr_cells - 1];

  return 1;

}

int

generic_device_size_to_attach_size(device *me,

                                   const device_unit *size,

                                   unsigned *nr_bytes,

                                   device *client)

{

  int i;

  for (i = 0; i < size->nr_cells - 1; i++) {

    if (size->cells[i] != 0)

      device_error(me, "Only 32bit sizes supported");

  }

  *nr_bytes = size->cells[0];

  return *nr_bytes;

}

/* ignore/passthrough versions of each function */

void

passthrough_device_address_attach(device *me,

                                  attach_type attach,

                                  int space,

                                  unsigned_word addr,

                                  unsigned nr_bytes,

                                  access_type access,

                                  device *client) /*callback/default*/

{

  device_attach_address(device_parent(me), attach,

                        space, addr, nr_bytes,

                        access,

                        client);

}

void

passthrough_device_address_detach(device *me,

                                  attach_type attach,

                                  int space,

                                  unsigned_word addr,

                                  unsigned nr_bytes,

                                  access_type access,

                                  device *client) /*callback/default*/

{

  device_detach_address(device_parent(me), attach,

                        space, addr, nr_bytes, access,

                        client);

}

unsigned

passthrough_device_dma_read_buffer(device *me,

                                   void *dest,

                                   int space,

                                   unsigned_word addr,

                                   unsigned nr_bytes)

{

  return device_dma_read_buffer(device_parent(me), dest,

                                space, addr, nr_bytes);

}

unsigned

passthrough_device_dma_write_buffer(device *me,

                             const void *source,

                             int space,

                             unsigned_word addr,

                             unsigned nr_bytes,

                             int violate_read_only_section)

{

  return device_dma_write_buffer(device_parent(me), source,

                                 space, addr,

                                 nr_bytes,

                                 violate_read_only_section);

}

int

ignore_device_unit_decode(device *me,

                          const char *unit,

                          device_unit *phys)

{

  memset(phys, 0, sizeof(device_unit));

  return 0;

}

static const device_callbacks passthrough_callbacks = {

  { NULL, }, /* init */

  { passthrough_device_address_attach,

    passthrough_device_address_detach, },

  { NULL, }, /* IO */

  { passthrough_device_dma_read_buffer, passthrough_device_dma_write_buffer, },

  { NULL, }, /* interrupt */

  { generic_device_unit_decode,

    generic_device_unit_encode, },

};

static const device_descriptor ob_device_table[] = {

  /* standard OpenBoot devices */

  { "aliases", NULL, &passthrough_callbacks },

  { "options", NULL, &passthrough_callbacks },

  { "chosen", NULL, &passthrough_callbacks },

  { "packages", NULL, &passthrough_callbacks },

  { "cpus", NULL, &passthrough_callbacks },

  { "openprom", NULL, &passthrough_callbacks },

  { "init", NULL, &passthrough_callbacks },

  { NULL },

};

const device_descriptor *const device_table[] = {

  ob_device_table,

#include "hw.c"

  NULL,

};

#endif /* _DEVICE_TABLE_C_ */