arch/.unmaintained/m68k-pp-native/Drivers/serial.hidd/serial_init.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Serial hidd initialization code.
   6     Lang: English.
   7 */
   8 #include <stddef.h>
   9 #include <exec/types.h>
  10 #include <exec/alerts.h>
  11
  12 #include <aros/system.h>
  13 #include <aros/asmcall.h>
  14
  15 #include <hidd/irq.h>
  16
  17 #include <proto/oop.h>
  18 #include <proto/exec.h>
  19
  20 #include "serial_intern.h"
  21
  22
  23 #undef SysBase
  24
  25 /* Customize libheader.c */
  26 #define LC_SYSBASE_FIELD(lib)   (((LIBBASETYPEPTR       )(lib))->hdg_SysBase)
  27 #define LC_SEGLIST_FIELD(lib)   (((LIBBASETYPEPTR       )(lib))->hdg_SegList)
  28 #define LC_RESIDENTNAME         hiddserial_resident
  29 #define LC_RESIDENTFLAGS        RTF_AUTOINIT | RTF_COLDSTART
  30 #define LC_RESIDENTPRI          9
  31 #define LC_LIBBASESIZE          sizeof(LIBBASETYPE)
  32 #define LC_LIBHEADERTYPEPTR     LIBBASETYPEPTR
  33 #define LC_LIB_FIELD(lib)       (((LIBBASETYPEPTR)(lib))->hdg_LibNode)
  34
  35 #define LC_NO_OPENLIB
  36 #define LC_NO_CLOSELIB
  37
  38 /* to avoid removing the serialhiddclass from memory add #define NOEXPUNGE */
  39
  40 #include <libcore/libheader.c>
  41
  42 #undef  SDEBUG
  43 #undef  DEBUG
  44 #define DEBUG 1
  45 #include <aros/debug.h>
  46
  47 #define SysBase      (LC_SYSBASE_FIELD(lh))
  48
  49 void serial_int_uart1(HIDDT_IRQ_Handler *, HIDDT_IRQ_HwInfo *);
  50 void serial_int_uart2(HIDDT_IRQ_Handler *, HIDDT_IRQ_HwInfo *);
  51
  52 #undef OOPBase
  53 #define OOPBase (csd->oopbase)
  54
  55 ULONG SAVEDS STDARGS LC_BUILDNAME(L_InitLib) (LC_LIBHEADERTYPEPTR lh)
  56 {
  57         struct class_static_data *csd; /* SerialHidd static data */
  58
  59         EnterFunc(bug("SerialHIDD_Init()\n"));
  60
  61         /*
  62                 We map the memory into the shared memory space, because it is
  63                 to be accessed by many processes, eg searching for a HIDD etc.
  64
  65                 Well, maybe once we've got MP this might help...:-)
  66         */
  67         csd = AllocVec(sizeof(struct class_static_data), MEMF_CLEAR|MEMF_PUBLIC);
  68         lh->hdg_csd = csd;
  69         if(csd) {
  70                 csd->sysbase = SysBase;
  71
  72                 D(bug("  Got csd\n"));
  73
  74                 csd->oopbase = OpenLibrary(AROSOOP_NAME, 0);
  75                 if (csd->oopbase) {
  76                         D(bug("  Got OOPBase\n"));
  77                         csd->utilitybase = OpenLibrary("utility.library", 37);
  78                         if (csd->utilitybase) {
  79                                 D(bug("  Got UtilityBase\n"));
  80
  81                                 csd->serialhiddclass = init_serialhiddclass(csd);
  82
  83                                 D(bug("  SerialHiddClass: %p\n", csd->serialhiddclass));
  84
  85                                 if(csd->serialhiddclass) {
  86                                         D(bug("  Got SerialHIDDClass\n"));
  87
  88                                         csd->irqhidd = OOP_NewObject(NULL, CLID_Hidd_IRQ, NULL);
  89
  90                                         if (csd->irqhidd) {
  91                                                 HIDDT_IRQ_Handler *irq;
  92
  93                                                 /* Install COM1 and COM3 interrupt */
  94                                                 irq = AllocMem(sizeof(HIDDT_IRQ_Handler), MEMF_CLEAR|MEMF_PUBLIC);
  95                                                 if(!irq) {
  96                                                         kprintf("  ERROR: Cannot install Serial\n");
  97                                                         Alert( AT_DeadEnd | AN_IntrMem );
  98                                                 }
  99                                                 irq->h_Node.ln_Pri=127;         /* Set the highest pri */
 100                                                 irq->h_Code = serial_int_uart1;
 101                                                 irq->h_Data = (APTR)csd;
 102                                                 HIDD_IRQ_AddHandler(csd->irqhidd, irq, vHidd_IRQ_Serial1);
 103
 104                                                 /* Install UART1 and UART2 interrupt */
 105                                                 irq = AllocMem(sizeof(HIDDT_IRQ_Handler), MEMF_CLEAR|MEMF_PUBLIC);
 106                                                 if(!irq) {
 107                                                         kprintf("  ERROR: Cannot install Serial\n");
 108                                                         Alert( AT_DeadEnd | AN_IntrMem );
 109                                                 }
 110                                                 irq->h_Node.ln_Pri=127;         /* Set the highest pri */
 111                                                 irq->h_Code = serial_int_uart2;
 112                                                 irq->h_Data = (APTR)csd;
 113                                                 HIDD_IRQ_AddHandler(csd->irqhidd, irq, vHidd_IRQ_Serial2);
 114
 115                                                 D(bug("  Got Interrupts\n"));
 116                                                 ReturnInt("SerialHIDD_Init", ULONG, TRUE);
 117                                         }
 118                                 }
 119
 120                                 CloseLibrary(csd->utilitybase);
 121                         }
 122                         CloseLibrary(csd->oopbase);
 123                 }
 124
 125                 FreeVec(csd);
 126                 lh->hdg_csd = NULL;
 127         }
 128
 129
 130         ReturnInt("SerialHIDD_Init", ULONG, FALSE);
 131
 132 }
 133
 134 void  SAVEDS STDARGS LC_BUILDNAME(L_ExpungeLib) (LC_LIBHEADERTYPEPTR lh)
 135 {
 136         EnterFunc(bug("SerialHIDD_Expunge()\n"));
 137
 138         if(lh->hdg_csd) {
 139                 free_serialhiddclass(lh->hdg_csd);
 140
 141                 CloseLibrary(lh->hdg_csd->utilitybase);
 142                 CloseLibrary(lh->hdg_csd->oopbase);
 143
 144                 FreeVec(lh->hdg_csd);
 145         }
 146
 147         ReturnVoid("SerialHIDD_Expunge");
 148 }