Return to mac_nvram.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / hw

Annotation of qemu/hw/mac_nvram.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * PowerMac NVRAM emulation
                      3:  *
                      4:  * Copyright (c) 2005-2007 Fabrice Bellard
                      5:  * Copyright (c) 2007 Jocelyn Mayer
                      6:  *
                      7:  * Permission is hereby granted, free of charge, to any person obtaining a copy
                      8:  * of this software and associated documentation files (the "Software"), to deal
                      9:  * in the Software without restriction, including without limitation the rights
                     10:  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
                     11:  * copies of the Software, and to permit persons to whom the Software is
                     12:  * furnished to do so, subject to the following conditions:
                     13:  *
                     14:  * The above copyright notice and this permission notice shall be included in
                     15:  * all copies or substantial portions of the Software.
                     16:  *
                     17:  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
                     18:  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
                     19:  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
                     20:  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
                     21:  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
                     22:  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
                     23:  * THE SOFTWARE.
                     24:  */
                     25: #include "hw.h"
                     26: #include "ppc_mac.h"
                     27: 
                     28: struct MacIONVRAMState {
                     29:     target_phys_addr_t mem_base;
                     30:     target_phys_addr_t size;
                     31:     int mem_index;
                     32:     uint8_t data[0x2000];
                     33: };
                     34: 
                     35: /* Direct access to NVRAM */
                     36: uint32_t macio_nvram_read (void *opaque, uint32_t addr)
                     37: {
                     38:     MacIONVRAMState *s = opaque;
                     39:     uint32_t ret;
                     40: 
                     41:     //    printf("%s: %p addr %04x\n", __func__, s, addr);
                     42:     if (addr < 0x2000)
                     43:         ret = s->data[addr];
                     44:     else
                     45:         ret = -1;
                     46: 
                     47:     return ret;
                     48: }
                     49: 
                     50: void macio_nvram_write (void *opaque, uint32_t addr, uint32_t val)
                     51: {
                     52:     MacIONVRAMState *s = opaque;
                     53: 
                     54:     //    printf("%s: %p addr %04x val %02x\n", __func__, s, addr, val);
                     55:     if (addr < 0x2000)
                     56:         s->data[addr] = val;
                     57: }
                     58: 
                     59: /* macio style NVRAM device */
                     60: static void macio_nvram_writeb (void *opaque,
                     61:                                 target_phys_addr_t addr, uint32_t value)
                     62: {
                     63:     MacIONVRAMState *s = opaque;
                     64: 
                     65:     addr -= s->mem_base;
                     66:     addr = (addr >> 4) & 0x1fff;
                     67:     s->data[addr] = value;
                     68:     //    printf("macio_nvram_writeb %04x = %02x\n", addr, value);
                     69: }
                     70: 
                     71: static uint32_t macio_nvram_readb (void *opaque, target_phys_addr_t addr)
                     72: {
                     73:     MacIONVRAMState *s = opaque;
                     74:     uint32_t value;
                     75: 
                     76:     addr -= s->mem_base;
                     77:     addr = (addr >> 4) & 0x1fff;
                     78:     value = s->data[addr];
                     79:     //    printf("macio_nvram_readb %04x = %02x\n", addr, value);
                     80: 
                     81:     return value;
                     82: }
                     83: 
                     84: static CPUWriteMemoryFunc *nvram_write[] = {
                     85:     &macio_nvram_writeb,
                     86:     &macio_nvram_writeb,
                     87:     &macio_nvram_writeb,
                     88: };
                     89: 
                     90: static CPUReadMemoryFunc *nvram_read[] = {
                     91:     &macio_nvram_readb,
                     92:     &macio_nvram_readb,
                     93:     &macio_nvram_readb,
                     94: };
                     95: 
                     96: MacIONVRAMState *macio_nvram_init (int *mem_index, target_phys_addr_t size)
                     97: {
                     98:     MacIONVRAMState *s;
                     99: 
                    100:     s = qemu_mallocz(sizeof(MacIONVRAMState));
                    101:     if (!s)
                    102:         return NULL;
                    103:     s->size = size;
                    104:     s->mem_index = cpu_register_io_memory(0, nvram_read, nvram_write, s);
                    105:     *mem_index = s->mem_index;
                    106: 
                    107:     return s;
                    108: }
                    109: 
                    110: void macio_nvram_map (void *opaque, target_phys_addr_t mem_base)
                    111: {
                    112:     MacIONVRAMState *s;
                    113: 
                    114:     s = opaque;
                    115:     s->mem_base = mem_base;
                    116:     cpu_register_physical_memory(mem_base, s->size, s->mem_index);
                    117: }
                    118: 
                    119: static uint8_t nvram_chksum (const uint8_t *buf, int n)
                    120: {
                    121:     int sum, i;
                    122:     sum = 0;
                    123:     for(i = 0; i < n; i++)
                    124:         sum += buf[i];
                    125:     return (sum & 0xff) + (sum >> 8);
                    126: }
                    127: 
                    128: /* set a free Mac OS NVRAM partition */
                    129: void pmac_format_nvram_partition (MacIONVRAMState *nvr, int len)
                    130: {
                    131:     uint8_t *buf;
                    132:     char partition_name[12] = "wwwwwwwwwwww";
                    133: 
                    134:     buf = nvr->data;
                    135:     buf[0] = 0x7f; /* free partition magic */
                    136:     buf[1] = 0; /* checksum */
                    137:     buf[2] = len >> 8;
                    138:     buf[3] = len;
                    139:     memcpy(buf + 4, partition_name, 12);
                    140:     buf[1] = nvram_chksum(buf, 16);
                    141: }

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