workbench/tools/SysExplorer/Modules/Storage/storage_enum.c

   1 /*
   2     Copyright (C) 2015-2019, The AROS Development Team.
   3     $Id$
   4 */
   5
   6 #include <aros/debug.h>
   7
   8 #define __STORAGE_NOLIBBASE__
   9
  10 #include <proto/sysexp.h>
  11 #include <proto/storage.h>
  12
  13 #include <proto/alib.h>
  14 #include <proto/dos.h>
  15 #include <proto/exec.h>
  16 #include <proto/muimaster.h>
  17 #include <proto/oop.h>
  18 #include <proto/utility.h>
  19 #include <proto/intuition.h>
  20
  21 #include <mui/NListtree_mcc.h>
  22 #include <utility/tagitem.h>
  23 #include <utility/hooks.h>
  24
  25 #include <devices/newstyle.h>
  26 #include <devices/ata.h>
  27
  28 #include "locale.h"
  29 #include "enums.h"
  30
  31 #include "storage_classes.h"
  32 #include "storage_intern.h"
  33
  34 #if (1) // TODO : Move into libbase
  35 extern OOP_AttrBase HiddAttrBase;
  36 extern OOP_AttrBase HWAttrBase;
  37 extern OOP_AttrBase HiddStorageUnitAB;
  38
  39 extern OOP_MethodID HWBase;
  40 extern OOP_MethodID HiddStorageControllerBase;
  41 extern OOP_MethodID HiddStorageBusBase;
  42 extern OOP_MethodID HiddStorageUnitBase;
  43 #endif
  44
  45 CONST_STRPTR storagebuswindowclass_name = "StorageBusWindow.Class";
  46 CONST_STRPTR storageunitwindowclass_name = "StorageUnitWindow.Class";
  47
  48 AROS_UFH3S(BOOL, storageenumFunc,
  49     AROS_UFHA(struct Hook *, h,  A0),
  50     AROS_UFHA(OOP_Object*, obj, A2),
  51     AROS_UFHA(void *, parent, A1))
  52 {
  53     AROS_USERFUNC_INIT
  54
  55     BOOL objValid = TRUE;
  56     CONST_STRPTR name = NULL;
  57     struct MUI_NListtree_TreeNode *tn;
  58     ULONG flags = 0;
  59     struct SysexpEnum_data *edata = (struct SysexpEnum_data *)h->h_Data;
  60     struct InsertObjectMsg msg =
  61     {
  62         .obj = obj,
  63         .winClass = NULL
  64     };
  65     struct ClassHandlerNode *clHandlers;
  66     struct SysexpBase *SysexpBase;
  67
  68     D(bug("[storage.sysexp] %s()\n", __func__));
  69
  70     if (!edata)
  71         return TRUE;
  72
  73     SysexpBase = edata->ed_sysexpbase;
  74     clHandlers = FindObjectHandler(obj, edata->ed_list);
  75
  76     D(bug("[storage.sysexp] %s: list @ 0x%p\n", __func__, edata->ed_list));
  77     D(bug("[storage.sysexp] %s: handler @ 0x%p\n", __func__, clHandlers));
  78
  79     if (clHandlers)
  80     {
  81         if (clHandlers->muiClass)
  82             msg.winClass = clHandlers->muiClass;
  83         if (clHandlers->enumFunc)
  84             flags = TNF_LIST|TNF_OPEN;
  85         if (clHandlers->validFunc)
  86             objValid = clHandlers->validFunc(obj, &flags);
  87     }
  88
  89     if (objValid)
  90     {
  91         int objnum;
  92
  93         /* This is either HW or HIDD subclass */
  94         OOP_GetAttr(obj, aHW_ClassName, (IPTR *)&name);
  95         if (!name)
  96             OOP_GetAttr(obj, aHidd_HardwareName, (IPTR *)&name);
  97
  98         D(bug("[storage.sysexp] %s: name = '%s'\n", __func__, name));
  99
 100         objnum = ++SysexpBase->GlobalCount;
 101
 102         tn = (APTR)DoMethod(SysexpBase->sesb_Tree, MUIM_NListtree_Insert, name, &msg,
 103                             parent, MUIV_NListtree_Insert_PrevNode_Tail, flags);
 104         D(bug("[storage.sysexp] %s: Inserted TreeNode 0x%p <%s> UserData 0x%p\n", __func__, tn, tn->tn_Name, tn->tn_User));
 105
 106         /* If we have enumerator for this class, call it now */
 107         if (clHandlers && clHandlers->enumFunc && (flags & TNF_LIST))
 108             clHandlers->enumFunc(obj, tn);
 109
 110         if (objnum == SysexpBase->GlobalCount)
 111         {
 112            tn->tn_Flags &= ~flags;
 113         }
 114     }
 115     return FALSE; /* Continue enumeration */
 116
 117     AROS_USERFUNC_EXIT
 118 }
 119
 120
 121 AROS_UFH3S(BOOL, storageunitenumFunc,
 122     AROS_UFHA(struct Hook *, h,  A0),
 123     AROS_UFHA(OOP_Object*, unit, A2),
 124     AROS_UFHA(void *, parent, A1))
 125 {
 126     AROS_USERFUNC_INIT
 127
 128     struct SysexpEnum_data *edata = (struct SysexpEnum_data *)h->h_Data;
 129     struct InsertObjectMsg msg =
 130     {
 131         .obj            = unit,
 132         .winClass       = StorageUnitWindow_CLASS
 133     };
 134     CONST_STRPTR name;
 135     struct SysexpBase *SysexpBase;
 136
 137     D(bug("[storage.sysexp] %s()\n", __func__));
 138
 139     if (!edata)
 140         return TRUE;
 141
 142     SysexpBase = edata->ed_sysexpbase;
 143
 144     D(bug("[storage.sysexp] %s: StorageUnit @ %p\n", __func__, unit));
 145     if (!unit)
 146         return TRUE;
 147
 148     SysexpBase->GlobalCount++;
 149
 150     OOP_GetAttr(unit, aHidd_StorageUnit_Model, (IPTR *)&name);
 151     DoMethod(SysexpBase->sesb_Tree, MUIM_NListtree_Insert, name, &msg,
 152              parent, MUIV_NListtree_Insert_PrevNode_Tail, 0);
 153
 154     return FALSE; /* Continue enumeration */
 155
 156     AROS_USERFUNC_EXIT
 157 }
 158
 159
 160 static struct SysexpEnum_data privatehookdata =
 161 {
 162     NULL,
 163     NULL
 164 };
 165
 166 struct Hook storageenum_hook =
 167 {
 168     .h_Entry = storageenumFunc,
 169     .h_Data = &privatehookdata
 170 };
 171
 172 struct Hook storageunitenum_hook =
 173 {
 174     .h_Entry = storageunitenumFunc,
 175     .h_Data = &privatehookdata
 176 };
 177
 178 static void storageHWEnum(OOP_Object *obj, struct MUI_NListtree_TreeNode *tn)
 179 {
 180     D(bug("[storage.sysexp] HWEnum: enumerating..\n"));
 181     D(bug("[storage.sysexp] HWEnum: storage class list @ 0x%p\n", storageenum_hook.h_Data));
 182     HW_EnumDrivers(obj, &storageenum_hook, tn);
 183 }
 184
 185 static void storageControllerEnum(OOP_Object *obj, struct MUI_NListtree_TreeNode *tn)
 186 {
 187     D(bug("[storage.sysexp] ControllerEnum: enumerating..\n"));
 188     D(bug("[storage.sysexp] ControllerEnum: storage class list @ 0x%p\n", storageenum_hook.h_Data));
 189     HIDD_StorageController_EnumBuses(obj, &storageenum_hook, tn);
 190 }
 191
 192 void storageBusEnum(OOP_Object *obj, struct MUI_NListtree_TreeNode *parent)
 193 {
 194     D(bug("[storage.sysexp] BusEnum: enumerating..\n"));
 195     D(bug("[storage.sysexp] BusEnum: storage class list @ 0x%p\n", storageenum_hook.h_Data));
 196     HIDD_StorageBus_EnumUnits(obj, &storageunitenum_hook, parent);
 197 }
 198
 199 AROS_LH4(void, EnumBusUnits,
 200          AROS_LHA(OOP_Object *, obj, A0),
 201          AROS_LHA(struct MUI_NListtree_TreeNode *, parent, A1),
 202          AROS_LHA(APTR, hookFunc, A2),
 203          AROS_LHA(APTR, hookData, A3),
 204          struct SysexpStorageBase *, StorageBase, 15, Storage)
 205 {
 206     AROS_LIBFUNC_INIT
 207
 208     struct Hook busunitenum_hook;
 209     D(bug("[storage.sysexp] %s: StorageBus @ %p\n", __func__, obj));
 210
 211     busunitenum_hook.h_Entry = hookFunc;
 212     busunitenum_hook.h_Data = hookData;
 213
 214     HIDD_StorageBus_EnumUnits(obj, &busunitenum_hook, parent);
 215
 216     AROS_LIBFUNC_EXIT
 217 }
 218
 219 /*
 220     Query a units device to see if it supports ATA device features, and if they are enebaled
 221     for the unit.
 222     Add objects to the passed in colgroup(2) if supported features are found.
 223 */
 224 AROS_LH3(void, QueryATAStorageFeatures,
 225          AROS_LHA(Object *, obj, A0),
 226          AROS_LHA(char *, devName, A1),
 227          AROS_LHA(int, devUnit, D0),
 228          struct SysexpStorageBase *, StorageBase, 16, Storage)
 229 {
 230     AROS_LIBFUNC_INIT
 231 #if (0)
 232     struct IOStdReq *io;
 233     struct MsgPort * ioReplyPort;
 234     struct NSDeviceQueryResult nsdqr;
 235     LONG error;
 236
 237     ioReplyPort = CreateMsgPort();
 238     if (!ioReplyPort)
 239         return;
 240
 241     io = CreateIORequest(ioReplyPort, sizeof(struct IOStdReq));
 242     if (!io)
 243     {
 244         DeleteMsgPort(ioReplyPort);
 245         return;
 246     }
 247
 248     if (!OpenDevice(devName, devUnit,(struct IORequest *)io,0))
 249     {
 250         io->io_Command = NSCMD_DEVICEQUERY;
 251         io->io_Length  = sizeof(nsdqr);
 252         io->io_Data    = (APTR)&nsdqr;
 253
 254         error = DoIO((struct IORequest *)io);
 255
 256         if((!error) &&
 257            (io->io_Actual >= 16) &&
 258            (io->io_Actual <= sizeof(nsdqr)) &&
 259            (nsdqr.SizeAvailable == io->io_Actual))
 260         {
 261             UWORD *cmdcheck;
 262             for(cmdcheck = nsdqr.SupportedCommands;
 263                 *cmdcheck;
 264                 cmdcheck++)
 265             {
 266                 ULONG queryres = 0;
 267
 268                 // Does the device understand the SMART Cmd?
 269                 if(*cmdcheck == HD_SMARTCMD)
 270                 {
 271                     // Check if the unit Supports SMART
 272                     io->io_Command = HD_SMARTCMD;
 273                     io->io_Reserved1 = io->io_Reserved2 = ATAFEATURE_TEST_AVAIL;
 274                     io->io_Length  = sizeof(queryres);
 275                     io->io_Data    = (APTR)&queryres;
 276                     error = DoIO((struct IORequest *)io);
 277                     if ((!error) && (io->io_Actual >= 4) && (queryres == SMART_MAGIC_ID))
 278                     {
 279                         IPTR smartSpacer = (IPTR)HVSpace;
 280                         IPTR smartLabel = (IPTR)Label("SMART Supported");
 281                         if (DoMethod(obj, MUIM_Group_InitChange))
 282                         {
 283                             DoMethod(obj, OM_ADDMEMBER, smartSpacer);
 284                             DoMethod(obj, OM_ADDMEMBER, smartLabel);
 285                             DoMethod(obj, MUIM_Group_ExitChange);
 286                         }
 287                     }
 288                 }
 289
 290                 // Does the device understand the TRIM Cmd?
 291                 if(*cmdcheck == HD_TRIMCMD)
 292                 {
 293                     // Check if the unit Supports TRIM
 294                     io->io_Command = HD_TRIMCMD;
 295                     io->io_Reserved1 = io->io_Reserved2 = ATAFEATURE_TEST_AVAIL;
 296                     io->io_Length  = sizeof(queryres);
 297                     io->io_Data    = (APTR)&queryres;
 298                     error = DoIO((struct IORequest *)io);
 299                     if ((!error) && (io->io_Actual >= 4) && (queryres == TRIM_MAGIC_ID))
 300                     {
 301                         IPTR trimSpacer = (IPTR)HVSpace;
 302                         IPTR trimLabel = (IPTR)Label("TRIM Supported");
 303                         if (DoMethod(obj, MUIM_Group_InitChange))
 304                         {
 305                             DoMethod(obj, OM_ADDMEMBER, trimSpacer);
 306                             DoMethod(obj, OM_ADDMEMBER, trimLabel);
 307                             DoMethod(obj, MUIM_Group_ExitChange);
 308                         }
 309                     }
 310                 }
 311             }
 312         }
 313         CloseDevice((struct IORequest *)io);
 314     }
 315     DeleteIORequest((struct IORequest *)io);
 316     DeleteMsgPort(ioReplyPort);
 317 #endif
 318     AROS_LIBFUNC_EXIT
 319 }
 320
 321 AROS_LH5(BOOL, RegisterStorageClassHandler,
 322          AROS_LHA(CONST_STRPTR, classid, A0),
 323          AROS_LHA(BYTE, pri, D0),
 324          AROS_LHA(struct MUI_CustomClass *, customwinclass, A1),
 325          AROS_LHA(CLASS_ENUMFUNC, enumfunc, A2),
 326          AROS_LHA(CLASS_VALIDFUNC, validfunc, A3),
 327          struct SysexpStorageBase *, StorageBase, 9, Storage)
 328 {
 329     AROS_LIBFUNC_INIT
 330
 331     struct SysexpBase *SysexpBase = StorageBase->sesb_SysexpBase;
 332     struct ClassHandlerNode *newClass;
 333     BOOL add = TRUE;
 334
 335     if ((newClass = FindClassHandler(classid, &StorageBase->sesb_HandlerList)))
 336     {
 337         if (newClass->enumFunc != GetBase("HWEnum.Func"))
 338             return FALSE;
 339
 340         D(bug("[storage.sysexp] %s: Updating '%s'..\n", __func__, classid));
 341         add = FALSE;
 342     }
 343
 344     if (add)
 345     {
 346         D(bug("[storage.sysexp] %s: Registering '%s'..\n", __func__, classid));
 347         newClass = AllocMem(sizeof(struct ClassHandlerNode), MEMF_CLEAR);
 348     }
 349
 350     if (newClass)
 351     {
 352         newClass->ch_Node.ln_Name = (char *)classid;
 353         newClass->ch_Node.ln_Pri = pri;
 354         newClass->muiClass = customwinclass;
 355         newClass->enumFunc = enumfunc;
 356         newClass->validFunc = validfunc;
 357
 358         if (add)
 359         {
 360             RegisterClassHandler(classid, pri, NULL, newClass->enumFunc, newClass->validFunc);
 361             Enqueue(&StorageBase->sesb_HandlerList, &newClass->ch_Node);
 362         }
 363
 364         return TRUE;
 365     }
 366     return FALSE;
 367
 368     AROS_LIBFUNC_EXIT
 369 }
 370
 371
 372 AROS_LH5(BOOL, RegisterStorageControllerHandler,
 373          AROS_LHA(CONST_STRPTR, classid, A0),
 374          AROS_LHA(BYTE, pri, D0),
 375          AROS_LHA(struct MUI_CustomClass *, customwinclass, A1),
 376          AROS_LHA(CLASS_ENUMFUNC, enumfunc, A2),
 377          AROS_LHA(CLASS_VALIDFUNC, validfunc, A3),
 378          struct SysexpStorageBase *, StorageBase, 10, Storage)
 379 {
 380     AROS_LIBFUNC_INIT
 381
 382     CLASS_ENUMFUNC enumFunc;
 383
 384     if (enumfunc)
 385         enumFunc = enumfunc;
 386     else
 387         enumFunc = storageControllerEnum;
 388
 389     return RegisterStorageClassHandler(classid, pri, customwinclass, enumFunc, validfunc);
 390
 391     AROS_LIBFUNC_EXIT
 392 }
 393
 394 AROS_LH5(BOOL, RegisterStorageBusHandler,
 395          AROS_LHA(CONST_STRPTR, classid, A0),
 396          AROS_LHA(BYTE, pri, D0),
 397          AROS_LHA(struct MUI_CustomClass *, customwinclass, A1),
 398          AROS_LHA(CLASS_ENUMFUNC, enumfunc, A2),
 399          AROS_LHA(CLASS_VALIDFUNC, validfunc, A3),
 400          struct SysexpStorageBase *, StorageBase, 11, Storage)
 401 {
 402     AROS_LIBFUNC_INIT
 403
 404      CLASS_ENUMFUNC enumFunc;
 405
 406     if (enumfunc)
 407         enumFunc = enumfunc;
 408     else
 409         enumFunc = storageBusEnum;
 410
 411     return RegisterStorageClassHandler(classid, pri, customwinclass, enumFunc, validfunc);
 412
 413     AROS_LIBFUNC_EXIT
 414 }
 415
 416 void StorageStartup(struct SysexpBase *SysexpBase)
 417 {
 418     struct SysexpStorageBase *StorageBase;
 419
 420     D(bug("[storage.sysexp] %s(%p)\n", __func__, SysexpBase));
 421
 422     StorageBase = GetBase("Storage.Module");
 423
 424     D(bug("[storage.sysexp] %s: StorageBase @ %p\n", __func__, StorageBase));
 425
 426     privatehookdata.ed_sysexpbase = SysexpBase;
 427     privatehookdata.ed_list = &StorageBase->sesb_HandlerList;
 428
 429     StorageBase->sesb_DevicePageCLASS = GetBase("DevicePage.Class");
 430     StorageBusWindow_CLASS->mcc_Class->cl_UserData = (IPTR)StorageBase;
 431
 432     RegisterBase(storagebuswindowclass_name, StorageBusWindow_CLASS);
 433     RegisterBase(storageunitwindowclass_name, StorageUnitWindow_CLASS);
 434
 435     RegisterClassHandler(CLID_Hidd_Storage, 90, NULL, storageHWEnum, NULL);
 436     RegisterStorageBusHandler(CLID_Hidd_StorageBus, 0, StorageBusWindow_CLASS, NULL, NULL);
 437 }