rom/hidds/base/storage/storage_controllerclass.c

   1 /*
   2     Copyright (C) 2018, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <aros/debug.h>
   7
   8 #include <oop/oop.h>
   9 #include <utility/tagitem.h>
  10
  11 #include "storage_intern.h"
  12
  13 OOP_Object *StorageController__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
  14 {
  15     D(bug ("[Storage:Controller] Root__New()\n");)
  16     o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
  17     if (o)
  18     {
  19         struct HIDDStorageControllerData *data = OOP_INST_DATA(cl, o);
  20         NEWLIST(&data->scd_Buses);
  21         InitSemaphore(&data->scd_BusLock);
  22     }
  23     D(bug ("[Storage:Controller] Root__New: Instance @ 0x%p\n", o);)
  24     return o;
  25 }
  26
  27 VOID StorageController__Root__Dispose(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
  28 {
  29     D(bug ("[Storage:Controller] Root__Dispose(0x%p)\n", o);)
  30     OOP_DoSuperMethod(cl, o, msg);
  31 }
  32
  33
  34 /*****************************************************************************************
  35
  36     NAME
  37         moHidd_StorageController_AddBus
  38
  39     SYNOPSIS
  40         OOP_Object *OOP_DoMethod(OOP_Object *obj, struct pHidd_StorageController_AddBus *Msg);
  41
  42         OOP_Object *Hidd_StorageController_AddBus(OOP_Object *obj, OOP_Class *busClass,
  43                                  struct TagItem *tags);
  44
  45     LOCATION
  46         CLID_HW
  47
  48     FUNCTION
  49         Creates a bus driver object and registers it in the controller.
  50
  51     INPUTS
  52         obj         - An ATA Controller object to operate on.
  53         busClass - A pointer to OOP class of the bus. In order to create an object
  54                       of some previously registered public class, use
  55                       oop.library/OOP_FindClass().
  56         tags        - An optional taglist which will be passed to bus class' New() method.
  57
  58     RESULT
  59         A pointer to bus object or NULL in case of failure.
  60
  61     NOTES
  62         Do not dispose the returned bus yourself, use Hidd_StorageController_RemoveBus() for it.
  63
  64     EXAMPLE
  65
  66     BUGS
  67
  68     SEE ALSO
  69         moHidd_StorageController_RemoveBus
  70
  71     INTERNALS
  72
  73 *****************************************************************************************/
  74
  75 OOP_Object *StorageController__Hidd_StorageController__AddBus(OOP_Class *cl, OOP_Object *o,
  76             struct pHidd_StorageController_AddBus *msg)
  77 {
  78     struct HIDDStorageControllerData *data = OOP_INST_DATA(cl, o);
  79     OOP_Object *bus = NULL;
  80     struct BusNode *bn;
  81
  82     D(bug("[Storage:Controller] Hidd_StorageController__AddBus: Adding Bus class 0x%p\n", msg->busClass));
  83
  84     if (msg->busClass != NULL)
  85     {
  86         // Get some extra memory for bus node
  87         bn = AllocPooled( CSD(cl)->cs_MemPool, sizeof(struct BusNode));
  88         if (bn)
  89         {
  90             D(bug("[Storage:Controller] Hidd_StorageController__AddBus: Bus Node @ 0x%p\n", bn));
  91             bus = OOP_NewObject(msg->busClass, NULL, msg->tags);
  92
  93             if (!bus)
  94             {
  95                 FreePooled( CSD(cl)->cs_MemPool, bn, sizeof(struct BusNode));
  96                 D(bug("[Storage:Controller] Hidd_StorageController__AddBus: Failed to instantiate Bus\n"));
  97                 return NULL;
  98             }
  99
 100            D(bug("[Storage:Controller] Hidd_StorageController__AddBus: Bus Instance @ 0x%p\n", bus));
 101
 102             if (HIDD_StorageController_SetUpBus(o, bus))
 103             {
 104                 D(bug("[Storage:Controller] Hidd_StorageController__AddBus: Bus Initialized\n"));
 105                 /* Add the driver to the end of drivers list */
 106                 bn->busObject = bus;
 107                 ObtainSemaphore(&data->scd_BusLock);
 108                 ADDTAIL(&data->scd_Buses, bn);
 109                 ReleaseSemaphore(&data->scd_BusLock);
 110
 111                 return bus;
 112             }
 113
 114             D(bug("[Storage:Controller] Hidd_StorageController__AddBus: Bus failed to Initialize\n"));
 115
 116             FreePooled( CSD(cl)->cs_MemPool, bn, sizeof(struct BusNode));
 117             OOP_DisposeObject(bus);
 118         }
 119     }
 120     return NULL;
 121 }
 122
 123 /*****************************************************************************************
 124
 125     NAME
 126         moHidd_StorageController_RemoveBus
 127
 128     SYNOPSIS
 129         void OOP_DoMethod(OOP_Object *obj, struct pHidd_StorageController_RemoveBus *Msg);
 130
 131         void Hidd_StorageController_RemoveBus(OOP_Object *obj, OOP_Object *driver);
 132
 133     LOCATION
 134         CLID_HW
 135
 136     FUNCTION
 137         Unregisters and disposes hardware bus object.
 138
 139     INPUTS
 140         obj    - An ATA Controller object from which the bus should be removed.
 141         driver - A pointer to a bus object, returned by Hidd_StorageController_AddBus().
 142
 143     RESULT
 144         TRUE if removal successful or FALSE upon failure.
 145
 146     NOTES
 147
 148     EXAMPLE
 149
 150     BUGS
 151
 152     SEE ALSO
 153         moHidd_StorageController_AddBus
 154
 155     INTERNALS
 156
 157 *****************************************************************************************/
 158
 159 BOOL StorageController__Hidd_StorageController__RemoveBus(OOP_Class *cl, OOP_Object *o, struct pHidd_StorageController_RemoveBus *Msg)
 160 {
 161     /*
 162      * Currently we don't support unloading bus drivers.
 163      * This is a very-very big TODO.
 164      */
 165     D(bug ("[Storage:Controller] Hidd_StorageController__RemoveBus(0x%p)\n", o);)
 166     return FALSE;
 167 }
 168
 169 /*****************************************************************************************
 170
 171     NAME
 172         moHidd_StorageController_EnumBuses
 173
 174     SYNOPSIS
 175         void OOP_DoMethod(OOP_Object *obj, struct pHidd_StorageController_EnumBuses *Msg);
 176
 177         void Hidd_StorageController_EnumBuses(OOP_Object *obj, struct Hook *callback, APTR hookMsg);
 178
 179     LOCATION
 180         CLID_HW
 181
 182     FUNCTION
 183         Enumerates all installed driver in the subsystem.
 184
 185     INPUTS
 186         obj      - A subsystem object to query.
 187         callback - A user-supplied hook which will be called for every driver.
 188         hookMsg  - A user-defined data to be passed to the hook.
 189
 190         The hook will be called with the following parameters:
 191             AROS_UFHA(struct Hook *, hook        , A0)
 192                 - A pointer to hook structure itself
 193             AROS_UFHA(OOP_Object * , busObject, A2)
 194                 - A bus object
 195             AROS_UFHA(APTR         , message     , A1)
 196                 - User-defined data
 197
 198         The hook should return FALSE in order to continue enumeration
 199         or TRUE in order to stop it.
 200
 201     RESULT
 202         None.
 203
 204     NOTES
 205
 206     EXAMPLE
 207
 208     BUGS
 209
 210     SEE ALSO
 211
 212     INTERNALS
 213         The function uses internal semaphore locking. Because of this,
 214         it is illegal to attempt to add or remove buses within the hook.
 215
 216 *****************************************************************************************/
 217
 218 void StorageController__Hidd_StorageController__EnumBuses(OOP_Class *cl, OOP_Object *o, struct pHidd_StorageController_EnumBuses *msg)
 219 {
 220     struct HIDDStorageControllerData *data = OOP_INST_DATA(cl, o);
 221     struct BusNode *bn;
 222
 223     /* Lock Bus list for shared use */
 224     ObtainSemaphoreShared(&data->scd_BusLock);
 225
 226     /* For every Bus on the controller... */
 227     ForeachNode(&data->scd_Buses, bn)
 228     {
 229         BOOL stop = CALLHOOKPKT(msg->callback, bn->busObject, msg->hookMsg);
 230
 231         if (stop)
 232             break;
 233     }
 234
 235     ReleaseSemaphore(&data->scd_BusLock);
 236 }
 237
 238
 239 /*****************************************************************************************
 240
 241     NAME
 242         moHidd_StorageController_SetUpBus
 243
 244     SYNOPSIS
 245         void OOP_DoMethod(OOP_Object *obj, struct pHidd_StorageController_SetUpBus *Msg);
 246
 247         void Hidd_StorageController_SetUpBus(OOP_Object *obj, OOP_Object *busObject);
 248
 249     LOCATION
 250         CLID_HW
 251
 252     FUNCTION
 253         Performs subsystem-specific setup after driver object creation.
 254         This method is intended to be used only by subclasses of CLID_HW.
 255
 256     INPUTS
 257         obj          - A subsystem object.
 258         busObject - Device driver object.
 259
 260     RESULT
 261         TRUE if setup completed successfully and FALSE in case of error.
 262         If this method returns error, the driver object will be disposed
 263         and moHidd_StorageController_AddBus method will fail.
 264
 265     NOTES
 266         In base class this method does nothing and always returns TRUE.
 267
 268     EXAMPLE
 269
 270     BUGS
 271
 272     SEE ALSO
 273         moHidd_StorageController_CleanUpBus
 274
 275     INTERNALS
 276
 277 *****************************************************************************************/
 278
 279 BOOL StorageController__Hidd_StorageController__SetUpBus(OOP_Class *cl, OOP_Object *o, struct pHidd_StorageController_SetUpBus *Msg)
 280 {
 281     D(bug ("[Storage:Controller] Hidd_StorageController__SetUpBus(0x%p)\n", o);)
 282
 283     /* By default we have nothing to do here */
 284
 285     return TRUE;
 286 }
 287
 288 /*****************************************************************************************
 289
 290     NAME
 291         moHidd_StorageController_CleanUpBus
 292
 293     SYNOPSIS
 294         void OOP_DoMethod(OOP_Object *obj, struct pHidd_StorageController_CleanUpBus *Msg);
 295
 296         void Hidd_StorageController_CleanUpBus(OOP_Object *obj, OOP_Object *busObject);
 297
 298     LOCATION
 299         CLID_HW
 300
 301     FUNCTION
 302         Performs subsystem-specific cleanup before driver object disposal.
 303         This method is intended to be used only by subclasses of CLID_HW.
 304
 305     INPUTS
 306         obj          - A subsystem object.
 307         busObject - Device driver object.
 308
 309     RESULT
 310         None.
 311
 312     NOTES
 313         In base class this method does nothing.
 314
 315     EXAMPLE
 316
 317     BUGS
 318
 319     SEE ALSO
 320         moHidd_StorageController_SetUpBus
 321
 322     INTERNALS
 323
 324 *****************************************************************************************/
 325
 326 void StorageController__Hidd_StorageController__CleanUpBus(OOP_Class *cl, OOP_Object *o, struct pHidd_StorageController_CleanUpBus *msg)
 327 {
 328     D(bug ("[Storage:Controller] Hidd_StorageController__CleanUpBus(0x%p)\n", o);)
 329     /* By default we have nothing to do here */
 330 }