Return to ds_bus.c CVS log

Up to [GnuMach] / OSKit-Mach / oskit

Annotation of OSKit-Mach/oskit/ds_bus.c, revision 1.1

1.1     ! root        1: /* This is a total crock of shit.  */
        !             2: 
        !             3: #include "ds_oskit.h"
        !             4: 
        !             5: #include <oskit/error.h>
        !             6: #include <oskit/dev/bus.h>
        !             7: 
        !             8: #include <vm/vm_map.h>
        !             9: #include <vm/vm_kern.h>
        !            10: #include <vm/vm_page.h>
        !            11: 
        !            12: #include <string.h>
        !            13: 
        !            14: 
        !            15: oskit_error_t
        !            16: populate_bus (device_t dev, oskit_bus_t *bus)
        !            17: {
        !            18:   kern_return_t kr;
        !            19:   oskit_error_t rc;
        !            20:   unsigned int i;
        !            21:   char *p;
        !            22: 
        !            23:   /* First, we probe the bus so it knows what devices are on it.  */
        !            24:   rc = oskit_bus_probe (bus);
        !            25:   if (OSKIT_FAILED (rc) && rc != OSKIT_E_NOTIMPL)
        !            26:     return rc;
        !            27: 
        !            28:   /* Next, we will get a page of kernel memory to hold our ridiculous
        !            29:      text representation of the bus's device list.  */
        !            30: 
        !            31:   kr = kmem_alloc_pageable (kernel_map, (vm_offset_t *) &dev->com.bus.contents,
        !            32:                            PAGE_SIZE);
        !            33:   if (kr)
        !            34:     return OSKIT_E_OUTOFMEMORY;
        !            35: 
        !            36:   p = dev->com.bus.contents;
        !            37:   i = 0;
        !            38:   do
        !            39:     {
        !            40:       inline void append (char sep, const char *str)
        !            41:        {
        !            42:          extern char *stpcpy (char *, const char *);
        !            43:          if (str)
        !            44:            {
        !            45:              *p++ = sep;
        !            46:              p = stpcpy (p, str);
        !            47:            }
        !            48:        }
        !            49: 
        !            50:       char pos[OSKIT_BUS_POS_MAX];
        !            51:       oskit_device_t *child;
        !            52:       oskit_devinfo_t info;
        !            53: 
        !            54:       rc = oskit_bus_getchild (bus, i++, &child, pos);
        !            55:       if (rc == OSKIT_E_DEV_NOMORE_CHILDREN)
        !            56:        break;
        !            57:       if (OSKIT_SUCCEEDED (rc))
        !            58:        {
        !            59:          rc = oskit_device_getinfo (child, &info);
        !            60:          oskit_device_release (child);
        !            61:        }
        !            62:       if (OSKIT_FAILED (rc))
        !            63:        {
        !            64:          kmem_free (kernel_map,
        !            65:                     (vm_offset_t) dev->com.bus.contents, PAGE_SIZE);
        !            66:          return rc;
        !            67:        }
        !            68: 
        !            69:       append ('@', pos);
        !            70:       append (':', info.name);
        !            71:       append ('=', info.description);
        !            72:       append (';', info.author);
        !            73:       append ('/', info.version);
        !            74:       *p++ = '\n';
        !            75: 
        !            76:       assert (p < dev->com.bus.contents + PAGE_SIZE);
        !            77:     } while (rc == 0);
        !            78: 
        !            79:   dev->com.bus.size = p - dev->com.bus.contents;
        !            80:   memset (p, 0, PAGE_SIZE - dev->com.bus.size);
        !            81: 
        !            82:   return 0;
        !            83: }
        !            84: 
        !            85: void
        !            86: ds_bus_close (device_t dev)
        !            87: {
        !            88:   kmem_free (kernel_map, (vm_offset_t) dev->com.bus.contents, PAGE_SIZE);
        !            89: }
        !            90: 
        !            91: io_return_t
        !            92: ds_bus_read (device_t dev, ipc_port_t reply_port,
        !            93:             mach_msg_type_name_t reply_port_type, dev_mode_t mode,
        !            94:             recnum_t recnum, int count, io_buf_ptr_t *data,
        !            95:             unsigned *bytes_read)
        !            96: {
        !            97:   if (recnum % PAGE_SIZE != 0)
        !            98:     return D_INVALID_OPERATION;        /* let generic code use inband read */
        !            99: 
        !           100:   if (recnum + count > dev->com.bus.size)
        !           101:     INVALREC;
        !           102: 
        !           103:   if (count == 0)
        !           104:     {
        !           105:       *bytes_read = 0;
        !           106:       return D_SUCCESS;
        !           107:     }
        !           108: 
        !           109:   *bytes_read = count;
        !           110:   return vm_map_copyin_page_list (kernel_map,
        !           111:                                  (vm_offset_t) dev->com.bus.contents + recnum,
        !           112:                                  round_page (count),
        !           113:                                  FALSE, FALSE, (vm_map_copy_t *) data,
        !           114:                                  FALSE);
        !           115: }
        !           116: 
        !           117: io_return_t
        !           118: ds_bus_read_inband (device_t dev, ipc_port_t reply_port,
        !           119:                    mach_msg_type_name_t reply_port_type, dev_mode_t mode,
        !           120:                    recnum_t recnum, int count, char *data,
        !           121:                    unsigned *bytes_read)
        !           122: {
        !           123:   if (recnum + count > dev->com.bus.size)
        !           124:     INVALREC;
        !           125:   memcpy (data, dev->com.bus.contents + recnum, count);
        !           126:   *bytes_read = count;
        !           127:   return D_SUCCESS;
        !           128: }
        !           129: 
        !           130: io_return_t
        !           131: ds_bus_get_status (device_t dev, dev_flavor_t flavor, dev_status_t status,
        !           132:                   mach_msg_type_number_t *status_count)
        !           133: {
        !           134:   switch (flavor)
        !           135:     {
        !           136:     case DEV_GET_SIZE:
        !           137:       status[DEV_GET_SIZE_RECORD_SIZE] = 1;
        !           138:       status[DEV_GET_SIZE_DEVICE_SIZE] = dev->com.bus.size;
        !           139:       *status_count = 2;
        !           140:       return D_SUCCESS;
        !           141:     }
        !           142:   INVALOP;
        !           143: }
        !           144: 
        !           145: 
        !           146: const struct device_ops bus_device_ops =
        !           147: {
        !           148:   read_inband: ds_bus_read_inband,
        !           149:   read: ds_bus_read,
        !           150:   get_status: ds_bus_get_status,
        !           151:   close: ds_bus_close
        !           152: };

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.