arch/all-unix/hidd/parallel/ParallelUnitClass.c

   1 /*
   2     Copyright © 1995-2006, 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 /* Some POSIX includes */
  12 #include <stdio.h>
  13 #include <termios.h>
  14 #include <unistd.h>
  15
  16 #include "unix_funcs.h"
  17
  18
  19 /* the rest are Amiga includes */
  20 #define timeval aros_timeval
  21 #include <proto/exec.h>
  22 #include <proto/utility.h>
  23 #include <proto/oop.h>
  24 #include <proto/alib.h>
  25 #include <exec/libraries.h>
  26 #include <exec/ports.h>
  27 #include <exec/memory.h>
  28 #include <exec/interrupts.h>
  29 #include <exec/lists.h>
  30
  31 #include <utility/tagitem.h>
  32 #include <hidd/parallel.h>
  33 #include <hidd/unixio.h>
  34
  35 #include <aros/symbolsets.h>
  36
  37 #include "parallel_intern.h"
  38 #undef timeval
  39
  40 #include LC_LIBDEFS_FILE
  41
  42 #undef  SDEBUG
  43 #undef  DEBUG
  44 #define SDEBUG 1
  45 #define DEBUG 1
  46 #include <aros/debug.h>
  47
  48 void parallelunit_receive_data();
  49 void parallelunit_write_more_data();
  50
  51 static char * unitname[] =
  52 {
  53         "/dev/lp0",
  54         "/dev/lp1",
  55         "/dev/lp2"
  56 };
  57
  58 /*************************** Classes *****************************/
  59
  60 static OOP_AttrBase HiddParallelUnitAB;
  61
  62 static struct OOP_ABDescr attrbases[] =
  63 {
  64     { IID_Hidd_ParallelUnit, &HiddParallelUnitAB },
  65     { NULL,     NULL }
  66 };
  67
  68 /******* ParallelUnit::New() ***********************************/
  69 OOP_Object *UXParUnit__Root__New(OOP_Class *cl, OOP_Object *obj, struct pRoot_New *msg)
  70 {
  71         struct HIDDParallelUnitData * data;
  72         static const struct TagItem tags[] = {{ TAG_END, 0}};
  73         struct TagItem *tag, *tstate;
  74         ULONG unitnum = 0;
  75
  76         EnterFunc(bug("ParallelUnit::New()\n"));
  77
  78         tstate = msg->attrList;
  79         while ((tag = NextTagItem((const struct TagItem **)&tstate))) {
  80                 ULONG idx;
  81
  82                 if (IS_HIDDPARALLELUNIT_ATTR(tag->ti_Tag, idx)) {
  83                         switch (idx) {
  84                                 case aoHidd_ParallelUnit_Unit:
  85                                         unitnum = (ULONG)tag->ti_Data;
  86                                 break;
  87                         }
  88                 }
  89
  90         } /* while (tags to process) */
  91
  92         D(bug("!!!!Request for unit number %d\n",unitnum));
  93
  94         obj = (OOP_Object *)OOP_DoSuperMethod(cl, obj, (OOP_Msg)msg);
  95
  96         if (obj) {
  97                 data = OOP_INST_DATA(cl, obj);
  98
  99                 data->unitnum = unitnum;
 100
 101                 D(bug("Opening %s.\n",unitname[data->unitnum]));
 102
 103                 data->filedescriptor = unix_open_nonblock(unitname[data->unitnum]);
 104
 105                 D(bug("Opened %s on handle %d\n",unitname[data->unitnum], data->filedescriptor));
 106
 107                 if (-1 != data->filedescriptor) {
 108                         /*
 109                         ** Configure the tty driver ?!?!?!
 110                         */
 111                         {
 112                                 data->replyport_read = AllocMem(sizeof(struct MsgPort), MEMF_PUBLIC|MEMF_CLEAR);
 113                                 data->replyport_write= AllocMem(sizeof(struct MsgPort), MEMF_PUBLIC|MEMF_CLEAR);
 114
 115                                 if (data->replyport_read && data->replyport_write) {
 116                                         /*
 117                                         ** Init the msg ports. They don't need a signal to be allocated
 118                                         */
 119                                         NEWLIST(&data->replyport_read->mp_MsgList);
 120                                         data->replyport_read ->mp_Node.ln_Type = NT_MSGPORT;
 121
 122                                         NEWLIST(&data->replyport_write->mp_MsgList);
 123                                         data->replyport_write->mp_Node.ln_Type = NT_MSGPORT;
 124
 125                                         data->softint_read      = AllocMem(sizeof(struct Interrupt), MEMF_CLEAR);
 126                                         data->softint_write = AllocMem(sizeof(struct Interrupt), MEMF_CLEAR);
 127
 128                                         if (data->softint_read && data->softint_write) {
 129                                                 data->softint_read->is_Data = data;
 130                                                 data->softint_read->is_Code = parallelunit_receive_data;
 131
 132                                                 data->softint_write->is_Data = data;
 133                                                 data->softint_write->is_Code = parallelunit_write_more_data;
 134
 135                                                 data->replyport_read->mp_Flags = PA_SOFTINT;
 136                                                 data->replyport_read->mp_SoftInt = data->softint_read;
 137
 138                                                 data->replyport_write->mp_Flags = PA_SOFTINT;
 139                                                 data->replyport_write->mp_SoftInt = data->softint_write;
 140
 141                                                 data->unixio_read       = OOP_NewObject(NULL, CLID_Hidd_UnixIO, (struct TagItem *)tags);
 142                                                 data->unixio_write = OOP_NewObject(NULL, CLID_Hidd_UnixIO, (struct TagItem *)tags);
 143
 144                                                 if (NULL != data->unixio_read && NULL != data->unixio_write) {
 145                                                         ULONG error;
 146                                                         D(bug("Creating UnixIO AsyncIO command!\n"));
 147
 148                                                         error = Hidd_UnixIO_AsyncIO(data->unixio_read,
 149                                                                                     data->filedescriptor,
 150                                                                                     vHidd_UnixIO_Terminal,
 151                                                                                     data->replyport_read,
 152                                                                                     vHidd_UnixIO_Read | vHidd_UnixIO_Keep,
 153                                                                                     SysBase);
 154
 155                                                         error = Hidd_UnixIO_AsyncIO(data->unixio_write,
 156                                                                                     data->filedescriptor,
 157                                                                                     vHidd_UnixIO_Terminal,
 158                                                                                     data->replyport_write,
 159                                                                                     vHidd_UnixIO_Write | vHidd_UnixIO_Keep,
 160                                                                                     SysBase);
 161                                                         goto exit;
 162
 163                                                 }
 164
 165                                                 if (NULL != data->unixio_read)
 166                                                         OOP_DisposeObject(data->unixio_read);
 167
 168                                                 if (NULL != data->unixio_write)
 169                                                         OOP_DisposeObject(data->unixio_write);
 170                                         }
 171
 172                                         if (data->softint_read)
 173                                                 FreeMem(data->softint_read, sizeof(struct Interrupt));
 174                                         if (data->softint_write)
 175                                                 FreeMem(data->softint_write, sizeof(struct Interrupt));
 176                                 }
 177
 178                                 if (data->replyport_read)
 179                                         FreeMem(data->replyport_read , sizeof(struct MsgPort));
 180                                 if (data->replyport_write)
 181                                         FreeMem(data->replyport_write, sizeof(struct MsgPort));
 182
 183                         }
 184
 185                         close(data->filedescriptor);
 186                 }
 187
 188                 OOP_DisposeObject(obj);
 189                 obj = NULL;
 190         } /* if (obj) */
 191
 192         D(bug("%s - an error occurred!\n",__FUNCTION__));
 193
 194 exit:
 195         ReturnPtr("ParallelUnit::New()", OOP_Object *, obj);
 196 }
 197
 198 /******* ParallelUnit::Dispose() ***********************************/
 199 OOP_Object *UXParUnit__Root__Dispose(OOP_Class *cl, OOP_Object *obj, OOP_Msg msg)
 200 {
 201         struct HIDDParallelUnitData * data;
 202         EnterFunc(bug("ParallelUnit::Dispose()\n"));
 203
 204         data = OOP_INST_DATA(cl, obj);
 205         D(bug("Freeing filedescriptor (%d)!\n",data->filedescriptor));
 206
 207         if (-1 != data->filedescriptor) {
 208                 Hidd_UnixIO_AbortAsyncIO(data->unixio_read,
 209                                          data->filedescriptor,
 210                                          SysBase);
 211
 212                 close(data->filedescriptor);
 213
 214                 FreeMem(data->replyport_read,   sizeof(struct MsgPort));
 215                 FreeMem(data->replyport_write, sizeof(struct MsgPort));
 216
 217                 FreeMem(data->softint_read , sizeof(struct Interrupt));
 218                 FreeMem(data->softint_write, sizeof(struct Interrupt));
 219
 220                 OOP_DisposeObject(data->unixio_read);
 221                 OOP_DisposeObject(data->unixio_write);
 222         }
 223         OOP_DoSuperMethod(cl, obj, (OOP_Msg)msg);
 224         ReturnPtr("ParallelUnit::Dispose()", OOP_Object *, obj);
 225 }
 226
 227
 228
 229 /******* ParallelUnit::Init() **********************************/
 230 BOOL UXParUnit__Hidd_ParallelUnit__Init(OOP_Class *cl, OOP_Object *o, struct pHidd_ParallelUnit_Init *msg)
 231 {
 232         struct HIDDParallelUnitData * data = OOP_INST_DATA(cl, o);
 233
 234         EnterFunc(bug("ParallelUnit::Init()\n"));
 235         data->DataReceivedCallBack = msg->DataReceived;
 236         data->DataReceivedUserData = msg->DataReceivedUserData;
 237         data->DataWriteCallBack         = msg->WriteData;
 238         data->DataWriteUserData         = msg->WriteDataUserData;
 239
 240         ReturnBool("ParallelUnit::Init()", TRUE);
 241 }
 242
 243 /******* ParallelUnit::Write() **********************************/
 244 ULONG UXParUnit__Hidd_ParallelUnit__Write(OOP_Class *cl, OOP_Object *o, struct pHidd_ParallelUnit_Write *msg)
 245 {
 246         struct HIDDParallelUnitData * data = OOP_INST_DATA(cl, o);
 247         ULONG len = 0;
 248
 249         EnterFunc(bug("ParallelUnit::Write()\n"));
 250
 251         if (TRUE == data->stopped)
 252                 return 0;
 253
 254         D(bug("Writing %d bytes to fd %d (stream: %s)\n",
 255                                 msg->Length,
 256                                 data->filedescriptor,
 257                                 msg->Outbuffer));
 258
 259         len = write(data->filedescriptor,
 260                     msg->Outbuffer,
 261                     msg->Length);
 262
 263
 264         ReturnInt("ParallelUnit::Write()",ULONG, len);
 265 }
 266
 267 /******* ParallelUnit::Start() **********************************/
 268 VOID UXParUnit__Hidd_ParallelUnit__Start(OOP_Class *cl, OOP_Object *o, struct pHidd_ParallelUnit_Start *msg)
 269 {
 270         struct HIDDParallelUnitData * data = OOP_INST_DATA(cl, o);
 271
 272         /*
 273          * Allow or start feeding the UART with data. Get the data
 274          * from upper layer.
 275          */
 276         if (TRUE == data->stopped) {
 277                 if (NULL != data->DataWriteCallBack)
 278                          data->DataWriteCallBack(data->unitnum, data->DataWriteUserData);
 279                 /*
 280                  * Also mark the stopped flag as FALSE.
 281                  */
 282                 data->stopped = FALSE;
 283         }
 284 }
 285
 286 /******* ParallelUnit::Stop() **********************************/
 287 VOID UXParUnit__Hidd_ParallelUnit__Stop(OOP_Class *cl, OOP_Object *o, struct pHidd_ParallelUnit_Stop *msg)
 288 {
 289         struct HIDDParallelUnitData * data = OOP_INST_DATA(cl, o);
 290
 291         /*
 292          * The next time the interrupt comes along and asks for
 293          * more data we just don't do anything...
 294          */
 295         data->stopped = TRUE;
 296 }
 297
 298 /****** ParallelUnit::GetStatus ********************************/
 299 UWORD UXParUnit__Hidd_ParallelUnit__GetStatus(OOP_Class *cl, OOP_Object *o, struct pHidd_ParallelUnit_GetStatus *msg)
 300 {
 301 #if 0
 302         struct HIDDParallelUnitData * data = OOP_INST_DATA(cl, o);
 303 #endif
 304
 305         return 0;
 306 }
 307
 308
 309 /************* The software interrupt handler that gets data from PORT *****/
 310
 311
 312 #define READBUFFER_SIZE 513
 313
 314 AROS_UFH3(void, parallelunit_receive_data,
 315          AROS_UFHA(APTR, iD, A1),
 316          AROS_UFHA(APTR, iC, A5),
 317          AROS_UFHA(struct ExecBase *, SysBase, A6))
 318 {
 319         AROS_USERFUNC_INIT
 320
 321         struct HIDDParallelUnitData * data = iD;
 322         ssize_t len;
 323         UBYTE buffer[READBUFFER_SIZE];
 324
 325         /*
 326         ** Read the data from the port ...
 327         */
 328         len = read(data->filedescriptor, buffer, READBUFFER_SIZE);
 329         /*
 330         ** ... and deliver them to whoever is interested.
 331         */
 332
 333         if (NULL != data->DataReceivedCallBack)
 334                 data->DataReceivedCallBack(buffer, len, data->unitnum, data->DataReceivedUserData);
 335
 336         AROS_USERFUNC_EXIT
 337 }
 338
 339 AROS_UFH3(void, parallelunit_write_more_data,
 340          AROS_UFHA(APTR, iD, A1),
 341          AROS_UFHA(APTR, iC, A5),
 342          AROS_UFHA(struct ExecBase *, SysBase, A6))
 343 {
 344         AROS_USERFUNC_INIT
 345
 346         struct HIDDParallelUnitData * data = iD;
 347         struct Message * msg;
 348
 349         /*
 350         ** Ask for more data be written to the unit
 351         */
 352         D(bug("Asking for more data to be written to unit %d\n",data->unitnum));
 353
 354         if (NULL != data->DataWriteCallBack)
 355                 data->DataWriteCallBack(data->unitnum, data->DataWriteUserData);
 356
 357         AROS_USERFUNC_EXIT
 358 }
 359
 360
 361 /******* init_parallelunitclass ********************************/
 362
 363 static int UXParUnit_InitAttrBases(LIBBASETYPEPTR LIBBASE)
 364 {
 365     return OOP_ObtainAttrBases(attrbases);
 366 }
 367
 368
 369 static int UXParUnit_ExpungeAttrBases(LIBBASETYPEPTR LIBBASE)
 370 {
 371     OOP_ReleaseAttrBases(attrbases);
 372     return TRUE;
 373 }
 374
 375 ADD2INITLIB(UXParUnit_InitAttrBases, 0)
 376 ADD2EXPUNGELIB(UXParUnit_ExpungeAttrBases, 0)