KernelLand/Modules/Interfaces/UDI/udi_lib/core/cb.c

   1 /**
   2  * \file cb.c
   3  * \author John Hodge (thePowersGang)
   4  * \brief Control block code
   5  */
   6 #define DEBUG   1
   7 #include <udi.h>
   8 #include <acess.h>
   9 #include <udi_internal.h>
  10 #include <udi_internal_ma.h>    // for cUDI_MgmtCbInitList
  11
  12 typedef struct sUDI_CBHeader
  13 {
  14         tUDI_MetaLang   *Metalang;
  15         udi_index_t     MetaCBNum;
  16         udi_cb_t        cb;
  17 } tUDI_CBHeader;
  18
  19 // === CODE ===
  20 tUDI_MetaLang *UDI_int_GetCbType(udi_cb_t *cb, udi_index_t *meta_cb_num)
  21 {
  22         tUDI_CBHeader   *hdr = (void*)cb - offsetof(tUDI_CBHeader, cb);
  23         if(meta_cb_num)
  24                 *meta_cb_num = hdr->MetaCBNum;
  25         return hdr->Metalang;
  26 }
  27
  28 udi_cb_t *udi_cb_alloc_internal_v(tUDI_MetaLang *Meta, udi_index_t MetaCBNum,
  29         size_t inline_size, size_t scratch_size, udi_channel_t channel)
  30 {
  31         ASSERTC(MetaCBNum, <, Meta->nCbTypes);
  32         size_t  base = Meta->CbTypes[MetaCBNum].Size;
  33         ASSERTC(base, >=, sizeof(udi_cb_t));
  34         base -= sizeof(udi_cb_t);
  35         LOG("(%s) udi_cb_t + %i + %i + %i",
  36                 Meta->Name, base, inline_size, scratch_size);
  37         tUDI_CBHeader   *cbhdr = NEW(tUDI_CBHeader, + base + inline_size + scratch_size);
  38         cbhdr->Metalang = Meta;
  39         cbhdr->MetaCBNum = MetaCBNum;
  40         udi_cb_t *ret = &cbhdr->cb;
  41         ret->channel = channel;
  42         ret->scratch = (void*)(ret + 1) + base + inline_size;
  43         return ret;
  44 }
  45 void *udi_cb_alloc_internal(tUDI_DriverInstance *Inst, udi_ubit8_t bind_cb_idx, udi_channel_t channel)
  46 {
  47         const udi_cb_init_t     *cb_init;
  48         ASSERT(Inst);
  49         ASSERT(Inst->Module);
  50         LOG("Inst=%p(%s), bind_cb_idx=%i, channel=%p",
  51                 Inst, Inst->Module->ModuleName, bind_cb_idx, channel);
  52         ASSERT(Inst->Module->InitInfo);
  53         ASSERT(Inst->Module->InitInfo->cb_init_list);
  54
  55         for( cb_init = Inst->Module->InitInfo->cb_init_list; cb_init->cb_idx; cb_init ++ )
  56         {
  57                 if( cb_init->cb_idx == bind_cb_idx )
  58                 {
  59                         // TODO: Get base size using meta/cbnum
  60                         tUDI_MetaLang *metalang = UDI_int_GetMetaLang(Inst->Module, cb_init->meta_idx);
  61                         if( !metalang ) {
  62                                 Log_Warning("UDI", "Metalang referenced in %s CB %i is invalid (%i)",
  63                                         Inst->Module->ModuleName, bind_cb_idx, cb_init->meta_idx);
  64                                 return NULL;
  65                         }
  66                         return udi_cb_alloc_internal_v(metalang, cb_init->meta_cb_num,
  67                                 cb_init->inline_size, cb_init->scratch_requirement, channel);
  68                 }
  69         }
  70         Log_Warning("UDI", "Cannot find CB init def %i for '%s'",
  71                 bind_cb_idx, Inst->Module->ModuleName);
  72         return NULL;
  73 }
  74
  75 void udi_cb_alloc (
  76         udi_cb_alloc_call_t     *callback,      //!< Function to be called when the CB is allocated
  77         udi_cb_t        *gcb,   //!< Parent Control Block
  78         udi_index_t     cb_idx,
  79         udi_channel_t   default_channel
  80         )
  81 {
  82         tUDI_DriverInstance *inst = UDI_int_ChannelGetInstance(gcb, false, NULL);
  83         void *ret = udi_cb_alloc_internal(inst, cb_idx, default_channel);
  84         callback(gcb, ret);
  85 }
  86
  87 void udi_cb_alloc_dynamic(
  88         udi_cb_alloc_call_t     *callback,
  89         udi_cb_t        *gcb,
  90         udi_index_t     cb_idx,
  91         udi_channel_t   default_channel,
  92         udi_size_t      inline_size,
  93         udi_layout_t    *inline_layout
  94         )
  95 {
  96         UNIMPLEMENTED();
  97 }
  98
  99 void udi_cb_alloc_batch(
 100         udi_cb_alloc_batch_call_t       *callback,      //!<
 101         udi_cb_t        *gcb,   //!<
 102         udi_index_t     cb_idx,
 103         udi_index_t     count,
 104         udi_boolean_t   with_buf,
 105         udi_size_t      buf_size,
 106         udi_buf_path_t  path_handle
 107         )
 108 {
 109         UNIMPLEMENTED();
 110 }
 111
 112 void udi_cb_free(udi_cb_t *cb)
 113 {
 114         tUDI_CBHeader   *hdr = (void*)cb - offsetof(tUDI_CBHeader, cb);
 115         // TODO: Ensure that cb is inactive
 116         free(hdr);
 117 }
 118
 119 void udi_cancel(udi_cancel_call_t *callback, udi_cb_t *gcb)
 120 {
 121         UNIMPLEMENTED();
 122 }
 123
 124 // === EXPORTS ===
 125 EXPORT(udi_cb_alloc);
 126 EXPORT(udi_cb_alloc_dynamic);
 127 EXPORT(udi_cb_alloc_batch);
 128 EXPORT(udi_cb_free);
 129 EXPORT(udi_cancel);