arch/ppc-chrp/efika/timer/beginio.c

   1 /*
   2     Copyright © 1995-2013, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: BeginIO - Start up a timer.device request.
   6     Lang: english
   7 */
   8
   9 #include "lowlevel.h"
  10 #include <devices/newstyle.h>
  11 #include <exec/errors.h>
  12 #include <exec/initializers.h>
  13 #include <proto/exec.h>
  14 #include <asm/io.h>
  15 #include <asm/mpc5200b.h>
  16
  17 /* See rom/timer/beginio.c for documentation */
  18
  19 /****************************************************************************************/
  20
  21 #define NEWSTYLE_DEVICE 1
  22
  23 #define ioStd(x)        ((struct IOStdReq *)x)
  24
  25 /****************************************************************************************/
  26
  27 #if NEWSTYLE_DEVICE
  28
  29 static const UWORD SupportedCommands[] =
  30 {
  31     TR_GETSYSTIME,
  32     TR_SETSYSTIME,
  33     TR_ADDREQUEST,
  34     NSCMD_DEVICEQUERY,
  35     0
  36 };
  37
  38 #endif
  39
  40 /****************************************************************************************/
  41
  42 BOOL timer_addToWaitList(struct TimerBase *, struct MinList *, struct timerequest *);
  43
  44 #include <devices/timer.h>
  45 #include <proto/timer.h>
  46
  47 AROS_LH1(void, BeginIO,
  48         AROS_LHA(struct timerequest *, timereq, A1),
  49         struct TimerBase *, TimerBase, 5, Timer)
  50 {
  51     AROS_LIBFUNC_INIT
  52
  53     ULONG unitNum;
  54     BOOL replyit = FALSE;
  55
  56     uint32_t initial_time = mftbl();
  57
  58     Disable();
  59     EClockUpdate(TimerBase);
  60     Enable();
  61
  62     timereq->tr_node.io_Message.mn_Node.ln_Type = NT_MESSAGE;
  63     timereq->tr_node.io_Error = 0;
  64
  65     unitNum = (ULONG)timereq->tr_node.io_Unit;
  66
  67     switch(timereq->tr_node.io_Command)
  68     {
  69 #if NEWSTYLE_DEVICE
  70         case NSCMD_DEVICEQUERY:
  71 #warning In timer.device this is maybe a bit problematic, as the timerequest structure does not have io_Data and io_Length members
  72
  73             if (timereq->tr_node.io_Message.mn_Length < sizeof(struct IOStdReq))
  74             {
  75                 timereq->tr_node.io_Error = IOERR_BADLENGTH;
  76             }
  77             else if(ioStd(timereq)->io_Length < ((LONG)OFFSET(NSDeviceQueryResult, SupportedCommands)) + sizeof(UWORD *))
  78             {
  79                 timereq->tr_node.io_Error = IOERR_BADLENGTH;
  80             }
  81             else
  82             {
  83                 struct NSDeviceQueryResult *d;
  84
  85                 d = (struct NSDeviceQueryResult *)ioStd(timereq)->io_Data;
  86
  87                 d->DevQueryFormat        = 0;
  88                 d->SizeAvailable         = sizeof(struct NSDeviceQueryResult);
  89                 d->DeviceType            = NSDEVTYPE_TIMER;
  90                 d->DeviceSubType         = 0;
  91                 d->SupportedCommands     = (UWORD *)SupportedCommands;
  92
  93             ioStd(timereq)->io_Actual = sizeof(struct NSDeviceQueryResult);
  94             }
  95             break;
  96 #endif
  97
  98         case TR_GETSYSTIME:
  99             Disable();
 100             EClockUpdate(TimerBase);
 101             Enable();
 102             GetSysTime(&timereq->tr_time);
 103
 104             if(!(timereq->tr_node.io_Flags & IOF_QUICK))
 105             {
 106                 ReplyMsg((struct Message *)timereq);
 107             }
 108             replyit = FALSE; /* Because replyit will clear the timeval */
 109             break;
 110
 111         case TR_SETSYSTIME:
 112             Disable();
 113             TimerBase->tb_CurrentTime.tv_secs = timereq->tr_time.tv_secs;
 114             TimerBase->tb_CurrentTime.tv_micro = timereq->tr_time.tv_micro;
 115             EClockSet(TimerBase);
 116             Enable();
 117             replyit = TRUE;
 118             break;
 119
 120         case TR_ADDREQUEST:
 121             switch(unitNum)
 122             {
 123                 case UNIT_WAITUNTIL:
 124                     /* Firstly, check to see if request is for past */
 125                     Disable();
 126                     if(CmpTime(&TimerBase->tb_CurrentTime, &timereq->tr_time) <= 0)
 127                     {
 128                         Enable();
 129                         timereq->tr_time.tv_secs = timereq->tr_time.tv_micro = 0;
 130                         timereq->tr_node.io_Error = 0;
 131                         replyit = TRUE;
 132                     }
 133                     else
 134                     {
 135                         /* Ok, we add this to the list */
 136                         if (timer_addToWaitList(TimerBase, &TimerBase->tb_Lists[TL_WAITVBL], timereq))
 137                         {
 138                             TimerSetup(TimerBase, initial_time);
 139                         }
 140                         Enable();
 141                         replyit = FALSE;
 142                         timereq->tr_node.io_Flags &= ~IOF_QUICK;
 143                     }
 144                     break;
 145
 146                 case UNIT_MICROHZ:
 147                 case UNIT_VBLANK:
 148                     Disable();
 149                     AddTime(&timereq->tr_time, &TimerBase->tb_Elapsed);
 150                     /* Slot it into the list */
 151                     if (timer_addToWaitList(TimerBase, &TimerBase->tb_Lists[TL_VBLANK], timereq))
 152                     {
 153                         TimerSetup(TimerBase, initial_time);
 154                     }
 155                     Enable();
 156                     timereq->tr_node.io_Flags &= ~IOF_QUICK;
 157                     replyit = FALSE;
 158                     break;
 159
 160                 case UNIT_ECLOCK:
 161                 case UNIT_WAITECLOCK:
 162                 default:
 163                     replyit = FALSE;
 164                     timereq->tr_node.io_Error = IOERR_NOCMD;
 165                     break;
 166             } /* switch(unitNum) */
 167             break;
 168
 169         case CMD_CLEAR:
 170         case CMD_FLUSH:
 171         case CMD_INVALID:
 172         case CMD_READ:
 173         case CMD_RESET:
 174         case CMD_START:
 175         case CMD_STOP:
 176         case CMD_UPDATE:
 177         case CMD_WRITE:
 178         default:
 179             replyit = TRUE;
 180             timereq->tr_node.io_Error = IOERR_NOCMD;
 181             break;
 182     } /* switch(command) */
 183
 184     if(replyit)
 185     {
 186         timereq->tr_time.tv_secs = 0;
 187         timereq->tr_time.tv_micro = 0;
 188         if(!(timereq->tr_node.io_Flags & IOF_QUICK))
 189         {
 190             ReplyMsg((struct Message *)timereq);
 191         }
 192     }
 193
 194     AROS_LIBFUNC_EXIT
 195 } /* BeginIO */
 196
 197 BOOL
 198 timer_addToWaitList(struct TimerBase *TimerBase,
 199                     struct MinList *list,
 200                     struct timerequest *iotr)
 201 {
 202     /* We are disabled, so we should take as little time as possible. */
 203     struct timerequest *tr;
 204     BOOL added = FALSE;
 205
 206     ForeachNode(list, tr)
 207     {
 208         /* If the time in the new request is less than the next request */
 209         if(CmpTime(&tr->tr_time, &iotr->tr_time) < 0)
 210         {
 211             /* Add the node before the next request */
 212             Insert(
 213                         (struct List *)list,
 214                         (struct Node *)iotr,
 215                         tr->tr_node.io_Message.mn_Node.ln_Pred
 216             );
 217             added = TRUE;
 218             break;
 219         }
 220     }
 221
 222     /*
 223         This will catch the case of either an empty list, or request is
 224         for after all other requests
 225     */
 226
 227     if(!added)
 228         AddTail((struct List *)list, (struct Node *)iotr);
 229
 230     /* Return TRUE if it ended up on head of list */
 231
 232     return ((struct timerequest *)list->mlh_Head == iotr) ? TRUE : FALSE;
 233
 234 }