arch/i386-pc/drivers/parallel.hidd/ParallelUnitClass.c

   1 /*
   2     Copyright © 1995-2017, 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 <exec/libraries.h>
  17 #include <exec/ports.h>
  18 #include <exec/memory.h>
  19 #include <exec/interrupts.h>
  20 #include <exec/lists.h>
  21 #include <aros/symbolsets.h>
  22
  23 #include <utility/tagitem.h>
  24 #include <hidd/parallel.h>
  25 #include <hidd/unixio.h>
  26
  27 #include "parallel_intern.h"
  28
  29 #include LC_LIBDEFS_FILE
  30
  31 #undef  SDEBUG
  32 #undef  DEBUG
  33 #define SDEBUG 0
  34 #define DEBUG 0
  35 #include <aros/debug.h>
  36
  37 void parallelunit_receive_data();
  38 void parallelunit_write_more_data();
  39
  40 static inline unsigned char inb(unsigned short port)
  41 {
  42
  43     unsigned char  _v;
  44
  45     __asm__ __volatile__
  46     ("inb %w1,%0"
  47      : "=a" (_v)
  48      : "Nd" (port)
  49     );
  50
  51     return _v;
  52 }
  53
  54 static inline void outb(unsigned char value, unsigned short port)
  55 {
  56     __asm__ __volatile__
  57     ("outb %b0,%w1"
  58      :
  59      : "a" (value), "Nd" (port)
  60     );
  61 }
  62
  63 #define parallel_usleep(x) __asm__ __volatile__("\noutb %al,$0x80\n")
  64
  65 static inline void parallel_out(struct HIDDParallelUnitData * data,
  66                                 int offset,
  67                                 int value)
  68 {
  69         outb(value, data->baseaddr+offset);
  70 }
  71
  72 static inline unsigned int parallel_in(struct HIDDParallelUnitData * data,
  73                                        int offset)
  74 {
  75         return inb(data->baseaddr+offset);
  76 }
  77
  78 /*************************** Classes *****************************/
  79
  80 /* IO bases for every Parallel port */
  81
  82 static ULONG bases[] = { 0x378, 0x278, 0x3bc};
  83
  84 static OOP_AttrBase HiddParallelUnitAB;
  85
  86 static struct OOP_ABDescr attrbases[] =
  87 {
  88     { IID_Hidd_ParallelUnit, &HiddParallelUnitAB },
  89     { NULL,     NULL }
  90 };
  91
  92 /******* ParallelUnit::New() ***********************************/
  93 OOP_Object *PCParUnit__Root__New(OOP_Class *cl, OOP_Object *obj, struct pRoot_New *msg)
  94 {
  95         struct HIDDParallelUnitData * data;
  96 //      static const struct TagItem tags[] = {{ TAG_END, 0}};
  97         struct TagItem *tag, *tstate;
  98         ULONG unitnum = 0;
  99
 100         EnterFunc(bug("ParallelUnit::New()\n"));
 101
 102         tstate = msg->attrList;
 103         while ((tag = NextTagItem(&tstate))) {
 104                 ULONG idx;
 105
 106                 if (IS_HIDDPARALLELUNIT_ATTR(tag->ti_Tag, idx)) {
 107                         switch (idx) {
 108                                 case aoHidd_ParallelUnit_Unit:
 109                                         unitnum = (ULONG)tag->ti_Data;
 110                                 break;
 111                         }
 112                 }
 113
 114         } /* while (tags to process) */
 115
 116         D(bug("!!!!Request for unit number %d\n",unitnum));
 117
 118         obj = (OOP_Object *)OOP_DoSuperMethod(cl, obj, (OOP_Msg)msg);
 119
 120         if (obj) {
 121                 data = OOP_INST_DATA(cl, obj);
 122
 123                 data->baseaddr = bases[unitnum];
 124                 data->unitnum  = unitnum;
 125
 126             #if 0
 127                 /*
 128                  * Enable the interrupt
 129                  */
 130                 parallel_outp(data, UART_PCP, UART_PCP_IRQ_EN);
 131             #endif
 132
 133                 /* Reset? */
 134
 135                 parallel_out(data, PAR_PCP, PAR_PCP_SLCT_IN);
 136                 parallel_usleep(60);
 137                 parallel_out(data, PAR_PCP, PAR_PCP_SLCT_IN | PAR_PCP_INIT);
 138
 139                 /* Reset ? */
 140
 141         } /* if (obj) */
 142
 143         D(bug("%s - an error occurred!\n",__FUNCTION__));
 144
 145         ReturnPtr("ParallelUnit::New()", OOP_Object *, obj);
 146 }
 147
 148 /******* ParallelUnit::Dispose() ***********************************/
 149 OOP_Object *PCParUnit__Root__Dispose(OOP_Class *cl, OOP_Object *obj, OOP_Msg msg)
 150 {
 151     #if 0
 152         struct HIDDParallelUnitData * data;
 153     #endif
 154         EnterFunc(bug("ParallelUnit::Dispose()\n"));
 155
 156     #if 0
 157         data = OOP_INST_DATA(cl, obj);
 158
 159         /* stop all interrupts */
 160         serial_outp(data, UART_PCP, 0);
 161     #endif
 162
 163         OOP_DoSuperMethod(cl, obj, (OOP_Msg)msg);
 164         ReturnPtr("ParallelUnit::Dispose()", OOP_Object *, obj);
 165 }
 166
 167
 168
 169 /******* ParallelUnit::Init() **********************************/
 170 BOOL PCParUnit__Hidd_ParallelUnit__Init(OOP_Class *cl, OOP_Object *o, struct pHidd_ParallelUnit_Init *msg)
 171 {
 172     struct HIDDParallelUnitData * data = OOP_INST_DATA(cl, o);
 173
 174     EnterFunc(bug("ParallelUnit::Init()\n"));
 175     data->DataReceivedCallBack = msg->DataReceived;
 176     data->DataReceivedUserData = msg->DataReceivedUserData;
 177     data->DataWriteCallBack    = msg->WriteData;
 178     data->DataWriteUserData    = msg->WriteDataUserData;
 179
 180     ReturnBool("ParallelUnit::Init()", TRUE);
 181 }
 182
 183 /******* ParallelUnit::Write() **********************************/
 184 ULONG PCParUnit__Hidd_ParallelUnit__Write(OOP_Class *cl, OOP_Object *o, struct pHidd_ParallelUnit_Write *msg)
 185 {
 186         struct HIDDParallelUnitData * data = OOP_INST_DATA(cl, o);
 187         ULONG len = msg->Length, count;
 188 //      ULONG error;
 189 //      unsigned char status;
 190
 191         EnterFunc(bug("ParallelUnit::Write()\n"));
 192         /*
 193          * If the output is currently stopped just don't do anything here.
 194          */
 195         if (TRUE == data->stopped)
 196                 return 0;
 197
 198         parallel_usleep(1);
 199
 200         for(count = 0; count < len; count++)
 201         {
 202             parallel_out(data, PAR_DATA, msg->Outbuffer[count]);
 203
 204             while((parallel_in(data, PAR_SP) & (PAR_SP_BUSY | PAR_SP_ERROR)) !=
 205                   (PAR_SP_BUSY | PAR_SP_ERROR))
 206             {
 207                 parallel_usleep(1);
 208             }
 209
 210             parallel_usleep(1);
 211             parallel_out(data, PAR_PCP, PAR_PCP_SLCT_IN | PAR_PCP_INIT | PAR_PCP_STROBE);
 212             parallel_usleep(1);
 213             parallel_out(data, PAR_PCP, PAR_PCP_SLCT_IN | PAR_PCP_INIT);
 214             parallel_usleep(1);
 215         }
 216
 217         ReturnInt("ParallelUnit::Write()",ULONG, count);
 218 }
 219
 220 /******* ParallelUnit::Start() **********************************/
 221 VOID PCParUnit__Hidd_ParallelUnit__Start(OOP_Class *cl, OOP_Object *o, struct pHidd_ParallelUnit_Start *msg)
 222 {
 223         struct HIDDParallelUnitData * data = OOP_INST_DATA(cl, o);
 224
 225         /*
 226          * Allow or start feeding the UART with data. Get the data
 227          * from upper layer.
 228          */
 229         if (TRUE == data->stopped) {
 230                 if (NULL != data->DataWriteCallBack)
 231                          data->DataWriteCallBack(data->unitnum, data->DataWriteUserData);
 232                 /*
 233                  * Also mark the stopped flag as FALSE.
 234                  */
 235                 data->stopped = FALSE;
 236         }
 237 }
 238
 239 /******* ParallelUnit::Stop() **********************************/
 240 VOID PCParUnit__Hidd_ParallelUnit__Stop(OOP_Class *cl, OOP_Object *o, struct pHidd_ParallelUnit_Stop *msg)
 241 {
 242         struct HIDDParallelUnitData * data = OOP_INST_DATA(cl, o);
 243
 244         /*
 245          * The next time the interrupt comes along and asks for
 246          * more data we just don't do anything...
 247          */
 248         data->stopped = TRUE;
 249 }
 250
 251 /****** ParallelUnit::GetStatus ********************************/
 252 UWORD PCParUnit__Hidd_ParallelUnit__GetStatus(OOP_Class *cl, OOP_Object *o, struct pHidd_ParallelUnit_GetStatus *msg)
 253 {
 254         struct HIDDParallelUnitData * data = OOP_INST_DATA(cl, o);
 255
 256         BYTE status;
 257         UWORD rc = 0;
 258
 259         status = parallel_in(data, PAR_SP);
 260
 261         if (status & PAR_SP_BUSY)
 262                 rc |= (1 << 0);
 263         if (status & PAR_SP_PE)
 264                 rc |= (1 << 1);
 265         if (status & PAR_SP_SLCT)
 266                 rc |= (1 << 2);
 267
 268         return rc;
 269 }
 270
 271
 272 #if 0 /* !! STUFF BELOW DESABLED !! */
 273
 274 /************* The software interrupt handler that gets data from PORT *****/
 275
 276
 277 #define READBUFFER_SIZE 513
 278
 279 AROS_UFH3(void, parallelunit_receive_data,
 280          AROS_UFHA(APTR, iD, A1),
 281          AROS_UFHA(APTR, iC, A5),
 282          AROS_UFHA(struct ExecBase *, SysBase, A6))
 283 {
 284         AROS_USERFUNC_INIT
 285
 286         struct HIDDSerialUnitData * data = iD;
 287         int len = 0;
 288         UBYTE buffer[READBUFFER_SIZE];
 289
 290         buffer[len++] = parallel_inp(data, PAR_DATA);
 291         /*
 292         ** ... and deliver them to whoever is interested.
 293         */
 294
 295         if (NULL != data->DataReceivedCallBack)
 296                 data->DataReceivedCallBack(buffer, len, data->unitnum, data->DataReceivedUserData);
 297
 298         AROS_USERFUNC_EXIT
 299 }
 300
 301 AROS_UFH3(void, parallelunit_write_more_data,
 302          AROS_UFHA(APTR, iD, A1),
 303          AROS_UFHA(APTR, iC, A5),
 304          AROS_UFHA(struct ExecBase *, SysBase, A6))
 305 {
 306         AROS_USERFUNC_INIT
 307
 308         struct HIDDParallelUnitData * data = iD;
 309         struct Message * msg;
 310
 311         /*
 312         ** Get the unixio message from my port and free it
 313         */
 314         msg = GetMsg(data->replyport_read);
 315         FreeMem(msg, sizeof(struct uioMessage));
 316
 317         /*
 318         ** Ask for more data be written to the unit
 319         */
 320         D(bug("Asking for more data to be written to unit %d\n",data->unitnum));
 321
 322         if (NULL != data->DataWriteCallBack)
 323                 data->DataWriteCallBack(data->unitnum, data->DataWriteUserData);
 324
 325         AROS_USERFUNC_EXIT
 326 }
 327
 328 #endif /* !! END DISABLED STUFF !! */
 329
 330 /******* init_parallelunitclass ********************************/
 331
 332 static int PCParUnit_Init(LIBBASETYPEPTR LIBBASE)
 333 {
 334     ReturnInt("PCParUnit_Init", ULONG, OOP_ObtainAttrBases(attrbases));
 335 }
 336
 337
 338 static int PCParUnit_Expunge(LIBBASETYPEPTR LIBBASE)
 339 {
 340     OOP_ReleaseAttrBases(attrbases);
 341     ReturnInt("PCParUnit_Expunge", int, TRUE);
 342 }
 343
 344 ADD2INITLIB(PCParUnit_Init, 0)
 345 ADD2EXPUNGELIB(PCParUnit_Expunge, 0)