arch/m68k-amiga/hidd/parallel/ParallelUnitClass.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Parallel Unit hidd class implementation.
   6     Lang: english
   7 */
   8
   9 #define __OOP_NOATTRBASES__
  10
  11 /* the rest are Amiga includes */
  12 #include <proto/exec.h>
  13 #include <proto/utility.h>
  14 #include <proto/oop.h>
  15 #include <proto/alib.h>
  16 #include <proto/cia.h>
  17
  18 #include <exec/libraries.h>
  19 #include <exec/ports.h>
  20 #include <exec/memory.h>
  21 #include <exec/interrupts.h>
  22 #include <exec/lists.h>
  23 #include <aros/symbolsets.h>
  24
  25 #include <utility/tagitem.h>
  26 #include <hidd/parallel.h>
  27
  28 #include <hardware/cia.h>
  29
  30 #include "parallel_intern.h"
  31
  32 #include LC_LIBDEFS_FILE
  33
  34 #include <aros/debug.h>
  35
  36 void parallelunit_receive_data();
  37 void parallelunit_write_more_data();
  38
  39 /*************************** Classes *****************************/
  40
  41 static OOP_AttrBase HiddParallelUnitAB;
  42
  43 static struct OOP_ABDescr attrbases[] =
  44 {
  45     { IID_Hidd_ParallelUnit, &HiddParallelUnitAB },
  46     { NULL,     NULL }
  47 };
  48
  49 /******* ParallelUnit::New() ***********************************/
  50 OOP_Object *AmigaParUnit__Root__New(OOP_Class *cl, OOP_Object *obj, struct pRoot_New *msg)
  51 {
  52         struct TagItem *tag, *tstate;
  53         ULONG unitnum = 0;
  54
  55         EnterFunc(bug("ParallelUnit::New()\n"));
  56
  57         tstate = msg->attrList;
  58         while ((tag = NextTagItem(&tstate))) {
  59                 ULONG idx;
  60
  61                 if (IS_HIDDPARALLELUNIT_ATTR(tag->ti_Tag, idx)) {
  62                         switch (idx) {
  63                                 case aoHidd_ParallelUnit_Unit:
  64                                         unitnum = (ULONG)tag->ti_Data;
  65                                 break;
  66                         }
  67                 }
  68
  69         } /* while (tags to process) */
  70
  71         if (unitnum != 0)
  72             ReturnPtr("ParallelUnit::New()", OOP_Object *, NULL);
  73
  74         D(bug("!!!!Request for unit number %d\n",unitnum));
  75
  76         obj = (OOP_Object *)OOP_DoSuperMethod(cl, obj, (OOP_Msg)msg);
  77
  78         if (!obj) {
  79             D(bug("%s - an error occurred!\n",__FUNCTION__));
  80         }
  81
  82         ReturnPtr("ParallelUnit::New()", OOP_Object *, obj);
  83 }
  84
  85 /******* ParallelUnit::Dispose() ***********************************/
  86 OOP_Object *AmigaParUnit__Root__Dispose(OOP_Class *cl, OOP_Object *obj, OOP_Msg msg)
  87 {
  88         struct HIDDParallelUnitData * data = OOP_INST_DATA(cl, obj);
  89         struct Interrupt *irq = &data->parint;
  90
  91         EnterFunc(bug("ParallelUnit::Dispose()\n"));
  92
  93         /* stop all interrupts */
  94         if (data->ciares)
  95             RemICRVector(data->ciares, 4, irq);
  96
  97         OOP_DoSuperMethod(cl, obj, (OOP_Msg)msg);
  98         ReturnPtr("ParallelUnit::Dispose()", OOP_Object *, obj);
  99 }
 100
 101 static AROS_INTH1(parallel_interrupt, struct HIDDParallelUnitData *, data)
 102 {
 103     AROS_INTFUNC_INIT
 104
 105     data->DataWriteCallBack(0, data->DataWriteUserData);
 106
 107     return 0;
 108
 109     AROS_INTFUNC_EXIT
 110 }
 111
 112 /******* ParallelUnit::Init() **********************************/
 113 BOOL AmigaParUnit__Hidd_ParallelUnit__Init(OOP_Class *cl, OOP_Object *o, struct pHidd_ParallelUnit_Init *msg)
 114 {
 115     struct HIDDParallelUnitData * data = OOP_INST_DATA(cl, o);
 116     struct Interrupt *irq = &data->parint;
 117
 118     EnterFunc(bug("ParallelUnit::Init()\n"));
 119     data->ciares = OpenResource("ciaa.resource");
 120     if (!data->ciares)
 121         ReturnBool("ParallelUnit::Init()", FALSE);
 122
 123     data->DataReceivedCallBack = msg->DataReceived;
 124     data->DataReceivedUserData = msg->DataReceivedUserData;
 125     data->DataWriteCallBack    = msg->WriteData;
 126     data->DataWriteUserData    = msg->WriteDataUserData;
 127
 128     irq = &data->parint;
 129     irq->is_Node.ln_Pri = 0;
 130     irq->is_Node.ln_Type = NT_INTERRUPT;
 131     irq->is_Node.ln_Name = "par";
 132     irq->is_Code = (APTR)parallel_interrupt;
 133     irq->is_Data = data;
 134
 135     if (AddICRVector(data->ciares, 4, irq))
 136         Alert(AT_DeadEnd | AG_NoMemory | AN_Unknown);
 137
 138     ReturnBool("ParallelUnit::Init()", TRUE);
 139 }
 140
 141 /******* ParallelUnit::Write() **********************************/
 142 ULONG AmigaParUnit__Hidd_ParallelUnit__Write(OOP_Class *cl, OOP_Object *o, struct pHidd_ParallelUnit_Write *msg)
 143 {
 144         struct HIDDParallelUnitData * data = OOP_INST_DATA(cl, o);
 145         volatile struct CIA *ciaa = (struct CIA*)0xbfe001;
 146         ULONG len = msg->Length;
 147
 148         EnterFunc(bug("ParallelUnit::Write()\n"));
 149         /*
 150          * If the output is currently stopped just don't do anything here.
 151          */
 152         if (TRUE == data->stopped || len < 1)
 153                 return 0;
 154
 155         ciaa->ciaprb = msg->Outbuffer[0];
 156
 157         ReturnInt("ParallelUnit::Write()",ULONG, 1);
 158 }
 159
 160 /******* ParallelUnit::Start() **********************************/
 161 VOID AmigaParUnit__Hidd_ParallelUnit__Start(OOP_Class *cl, OOP_Object *o, struct pHidd_ParallelUnit_Start *msg)
 162 {
 163         struct HIDDParallelUnitData * data = OOP_INST_DATA(cl, o);
 164         volatile struct CIA *ciaa = (struct CIA*)0xbfe001;
 165
 166         /* Ensure that the parallel port is in output mode */
 167         ciaa->ciaddrb = 0xff;
 168
 169         /*
 170          * Allow or start feeding the CIA with data. Get the data
 171          * from upper layer.
 172          */
 173         if (TRUE == data->stopped) {
 174                 if (NULL != data->DataWriteCallBack)
 175                          data->DataWriteCallBack(0, data->DataWriteUserData);
 176                 /*
 177                  * Also mark the stopped flag as FALSE.
 178                  */
 179                 data->stopped = FALSE;
 180         }
 181 }
 182
 183 /******* ParallelUnit::Stop() **********************************/
 184 VOID AmigaParUnit__Hidd_ParallelUnit__Stop(OOP_Class *cl, OOP_Object *o, struct pHidd_ParallelUnit_Stop *msg)
 185 {
 186         struct HIDDParallelUnitData * data = OOP_INST_DATA(cl, o);
 187
 188         /*
 189          * The next time the interrupt comes along and asks for
 190          * more data we just don't do anything...
 191          */
 192         data->stopped = TRUE;
 193 }
 194
 195 /****** ParallelUnit::GetStatus ********************************/
 196 UWORD AmigaParUnit__Hidd_ParallelUnit__GetStatus(OOP_Class *cl, OOP_Object *o, struct pHidd_ParallelUnit_GetStatus *msg)
 197 {
 198         volatile struct CIA *ciab = (struct CIA*)0xbfd000;
 199
 200         return ciab->ciapra & 7;
 201 }
 202
 203
 204 /******* init_parallelunitclass ********************************/
 205
 206 static int AmigaParUnit_Init(LIBBASETYPEPTR LIBBASE)
 207 {
 208     ReturnInt("AmigaParUnit_Init", ULONG, OOP_ObtainAttrBases(attrbases));
 209 }
 210
 211
 212 static int AmigaParUnit_Expunge(LIBBASETYPEPTR LIBBASE)
 213 {
 214     OOP_ReleaseAttrBases(attrbases);
 215     ReturnInt("AmigaParUnit_Expunge", int, TRUE);
 216 }
 217
 218 ADD2INITLIB(AmigaParUnit_Init, 0)
 219 ADD2EXPUNGELIB(AmigaParUnit_Expunge, 0)