sim/ppc/hw_sem.c

   1 /*  This file is part of the program psim.
   2
   3     Copyright (C) 1997,2008, Joel Sherrill <joel@OARcorp.com>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18
  19     */
  20
  21
  22 #ifndef _HW_SEM_C_
  23 #define _HW_SEM_C_
  24
  25 #include "device_table.h"
  26
  27 #ifdef HAVE_STRING_H
  28 #include <string.h>
  29 #else
  30 #ifdef HAVE_STRINGS_H
  31 #include <strings.h>
  32 #endif
  33 #endif
  34
  35 #include <sys/ipc.h>
  36 #include <sys/sem.h>
  37
  38 #include <errno.h>
  39
  40 /* DEVICE
  41
  42
  43    sem - provide access to a unix semaphore
  44
  45
  46    DESCRIPTION
  47
  48
  49    This device implements an interface to a unix semaphore.
  50
  51
  52    PROPERTIES
  53
  54
  55    reg = <address> <size> (required)
  56
  57    Determine where the memory lives in the parents address space.
  58
  59    key = <integer> (required)
  60
  61    This is the key of the unix semaphore.
  62
  63    EXAMPLES
  64
  65
  66    Enable tracing of the sem:
  67
  68    |  bash$ psim -t sem-device \
  69
  70
  71    Configure a UNIX semaphore using key 0x12345678 mapped into psim
  72    address space at 0xfff00000:
  73
  74    |  -o '/sem@0xfff00000/reg 0xfff00000 0x80000' \
  75    |  -o '/sem@0xfff00000/key 0x12345678' \
  76
  77    sim/ppc/run -o '/#address-cells 1' \
  78          -o '/sem@0xfff00000/reg 0xfff00000 12' \
  79          -o '/sem@0xfff00000/key 0x12345678' ../psim-hello/hello
  80
  81    REGISTERS
  82
  83    offset 0 - lock count
  84    offset 4 - lock operation
  85    offset 8 - unlock operation
  86
  87    All reads return the current or resulting count.
  88
  89    BUGS
  90
  91    None known.
  92
  93    */
  94
  95 typedef struct _hw_sem_device {
  96   unsigned_word physical_address;
  97   key_t key;
  98   int id;
  99   int initial;
 100   int count;
 101 } hw_sem_device;
 102
 103 #ifndef HAVE_UNION_SEMUN
 104 union semun {
 105   int val;
 106   struct semid_ds *buf;
 107   unsigned short int *array;
 108 #if defined(__linux__)
 109   struct seminfo *__buf;
 110 #endif
 111 };
 112 #endif
 113
 114 static void
 115 hw_sem_init_data(device *me)
 116 {
 117   hw_sem_device *sem = (hw_sem_device*)device_data(me);
 118   const device_unit *d;
 119   int status;
 120   union semun help;
 121
 122   /* initialize the properties of the sem */
 123
 124   if (device_find_property(me, "key") == NULL)
 125     error("sem_init_data() required key property is missing\n");
 126
 127   if (device_find_property(me, "value") == NULL)
 128     error("sem_init_data() required value property is missing\n");
 129
 130   sem->key = (key_t) device_find_integer_property(me, "key");
 131   DTRACE(sem, ("semaphore key (%d)\n", sem->key) );
 132
 133   sem->initial = (int) device_find_integer_property(me, "value");
 134   DTRACE(sem, ("semaphore initial value (%d)\n", sem->initial) );
 135
 136   d = device_unit_address(me);
 137   sem->physical_address = d->cells[ d->nr_cells-1 ];
 138   DTRACE(sem, ("semaphore physical_address=0x%x\n", sem->physical_address));
 139
 140   /* Now to initialize the semaphore */
 141
 142   if ( sem->initial != -1 ) {
 143
 144     sem->id = semget(sem->key, 1, IPC_CREAT | 0660);
 145     if (sem->id == -1)
 146       error("hw_sem_init_data() semget failed\n");
 147
 148     help.val = sem->initial;
 149     status = semctl( sem->id, 0, SETVAL, help );
 150     if (status == -1)
 151       error("hw_sem_init_data() semctl -- set value failed\n");
 152
 153   } else {
 154     sem->id = semget(sem->key, 1, 0660);
 155     if (sem->id == -1)
 156       error("hw_sem_init_data() semget failed\n");
 157   }
 158
 159   sem->count = semctl( sem->id, 0, GETVAL, help );
 160   if (sem->count == -1)
 161     error("hw_sem_init_data() semctl -- get value failed\n");
 162   DTRACE(sem, ("semaphore OS value (%d)\n", sem->count) );
 163 }
 164
 165 static void
 166 hw_sem_attach_address_callback(device *me,
 167                                 attach_type attach,
 168                                 int space,
 169                                 unsigned_word addr,
 170                                 unsigned nr_bytes,
 171                                 access_type access,
 172                                 device *client) /*callback/default*/
 173 {
 174   hw_sem_device *sem = (hw_sem_device*)device_data(me);
 175
 176   if (space != 0)
 177     error("sem_attach_address_callback() invalid address space\n");
 178
 179   if (nr_bytes == 12)
 180     error("sem_attach_address_callback() invalid size\n");
 181
 182   sem->physical_address = addr;
 183   DTRACE(sem, ("semaphore physical_address=0x%x\n", addr));
 184 }
 185
 186 static unsigned
 187 hw_sem_io_read_buffer(device *me,
 188                          void *dest,
 189                          int space,
 190                          unsigned_word addr,
 191                          unsigned nr_bytes,
 192                          cpu *processor,
 193                          unsigned_word cia)
 194 {
 195   hw_sem_device *sem = (hw_sem_device*)device_data(me);
 196   struct sembuf sb;
 197   int status;
 198   unsigned32 u32;
 199   union semun help;
 200
 201   /* do we need to worry about out of range addresses? */
 202
 203   DTRACE(sem, ("semaphore read addr=0x%x length=%d\n", addr, nr_bytes));
 204
 205   if (!(addr >= sem->physical_address && addr <= sem->physical_address + 11))
 206     error("hw_sem_io_read_buffer() invalid address - out of range\n");
 207
 208   if ((addr % 4) != 0)
 209     error("hw_sem_io_read_buffer() invalid address - alignment\n");
 210
 211   if (nr_bytes != 4)
 212     error("hw_sem_io_read_buffer() invalid length\n");
 213
 214   switch ( (addr - sem->physical_address) / 4 ) {
 215
 216     case 0:  /* OBTAIN CURRENT VALUE */
 217       break;
 218
 219     case 1:  /* LOCK */
 220       sb.sem_num = 0;
 221       sb.sem_op  = -1;
 222       sb.sem_flg = 0;
 223
 224       status = semop(sem->id, &sb, 1);
 225       if (status == -1) {
 226         perror( "hw_sem.c: lock" );
 227         error("hw_sem_io_read_buffer() sem lock\n");
 228       }
 229
 230       DTRACE(sem, ("semaphore lock %d\n", sem->count));
 231       break;
 232
 233     case 2: /* UNLOCK */
 234       sb.sem_num = 0;
 235       sb.sem_op  = 1;
 236       sb.sem_flg = 0;
 237
 238       status = semop(sem->id, &sb, 1);
 239       if (status == -1) {
 240         perror( "hw_sem.c: unlock" );
 241         error("hw_sem_io_read_buffer() sem unlock\n");
 242       }
 243       DTRACE(sem, ("semaphore unlock %d\n", sem->count));
 244       break;
 245
 246     default:
 247       error("hw_sem_io_read_buffer() invalid address - unknown error\n");
 248       break;
 249   }
 250
 251   /* assume target is big endian */
 252   u32 = H2T_4(semctl( sem->id, 0, GETVAL, help ));
 253
 254   DTRACE(sem, ("semaphore OS value (%d)\n", u32) );
 255   if (u32 == 0xffffffff) {
 256     perror( "hw_sem.c: getval" );
 257     error("hw_sem_io_read_buffer() semctl -- get value failed\n");
 258   }
 259
 260   memcpy(dest, &u32, nr_bytes);
 261   return nr_bytes;
 262
 263 }
 264
 265 static device_callbacks const hw_sem_callbacks = {
 266   { generic_device_init_address, hw_sem_init_data },
 267   { hw_sem_attach_address_callback, }, /* address */
 268   { hw_sem_io_read_buffer, NULL }, /* IO */
 269   { NULL, }, /* DMA */
 270   { NULL, }, /* interrupt */
 271   { NULL, }, /* unit */
 272   NULL,
 273 };
 274
 275 static void *
 276 hw_sem_create(const char *name,
 277                  const device_unit *unit_address,
 278                  const char *args)
 279 {
 280   hw_sem_device *sem = ZALLOC(hw_sem_device);
 281   return sem;
 282 }
 283
 284 const device_descriptor hw_sem_device_descriptor[] = {
 285   { "sem", hw_sem_create, &hw_sem_callbacks },
 286   { NULL },
 287 };
 288
 289 #endif /* _HW_SEM_C_ */