/* * ======== mkSPipe ======== */ Static SPipeObj *mkSPipe(DEV_Handle dev) { SPipeObj *sPipe = MEM_alloc(0, sizeof (SPipeObj), 0); if (sPipe != MEM_ILLEGAL) { sPipe->dataSem = SEM_create(0, NULL); if (sPipe->dataSem == NULL) { rmSPipe(sPipe); return (MEM_ILLEGAL); } sPipe->freeSem = SEM_create(0, NULL); if (sPipe->freeSem == NULL) { rmSPipe(sPipe); return(MEM_ILLEGAL); } sPipe->readySem[DEV_INPUT] = NULL; sPipe->readySem[DEV_OUTPUT] = NULL; sPipe->device[DEV_INPUT] = NULL; sPipe->device[DEV_OUTPUT] = NULL; sPipe->id = dev->devid; return (sPipe); } else { return (MEM_ILLEGAL); } }
/* ARGSUSED */ Int smain(Int argc, Char * argv[]) { TSK_Handle tsk; TSK_Attrs attrs = TSK_ATTRS; Int i; GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_ENTER, "_smain> Enter \n"); done = SEM_create(0, NULL); mutex = SEM_create(1, NULL); if ((done == NULL) || (mutex == NULL)) { SYS_abort("Sem create failed \n"); } /* * Do I care about this ? */ attrs.stackseg = EXTMEM_HEAP; /* * Use a bigger stack size when printing out trace */ attrs.stacksize = 0x1000; for (i = 0; i < NUMTASKS; i++) { attrs.priority = attrsTable[i].priority; tsk = TSK_create((Fxn)rmanTask, &attrs, (Arg)(attrsTable[i].scratchId), (Arg)(&(attrsTable[i].id)), (Arg)(attrsTable[i].priority), (Arg)(i +1), (Arg)(attrsTable[i].yieldFlag)); if (tsk == NULL) { GT_1trace(ti_sdo_fc_rman_examples_hdvicp, GT_7CLASS, "_rman> " "Task #%d create failed \n",i); SYS_abort("TSK_create() of task %d failed\n",i+1); } } for (i=0; i < NUMTASKS; i++) { SEM_pend(done, SYS_FOREVER); } GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_4CLASS, "_smain> " "TEST PASSED \n"); SEM_delete(mutex); SEM_delete(done); GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_ENTER, "_smain> Exit \n"); return 0; }
/** * \brief EDMA3 OS Semaphore Create * * This function creates a counting semaphore with specified * attributes and initial value. It should be used to create a semaphore * with initial value as '1'. The semaphore is then passed by the user * to the EDMA3 driver/RM for proper sharing of resources. * \param initVal [IN] is initial value for semaphore * \param attrs [IN] is the semaphore attributes ex: Fifo type * \param hSem [OUT] is location to recieve the handle to just created * semaphore * \return EDMA3_DRV_SOK if succesful, else a suitable error code. */ EDMA3_DRV_Result edma3OsSemCreate(int initVal, const EDMA3_OS_SemAttrs *attrs, EDMA3_OS_Sem_Handle *hSem) { #if 0 //wj EDMA3_DRV_Result semCreateResult = EDMA3_DRV_SOK; if(NULL == hSem) { semCreateResult = EDMA3_DRV_E_INVALID_PARAM; } else { *hSem = (EDMA3_OS_Sem_Handle)SEM_create(initVal, (SEM_Attrs*)attrs); if ( (*hSem) == NULL ) { semCreateResult = EDMA3_DRV_E_SEMAPHORE; } } return semCreateResult; #else *hSem = (EDMA3_OS_Sem_Handle)1; return 0; #endif }
/* * ======== tskMkPort ======== * Creates a DIO object and binds the controller. */ static DIO_Handle tskMkPort(DEV_Handle device, String name) { DIO_Params *params = (DIO_Params *)device->params; DIO_Handle dio; DEV_Device *entry; Uns mode; Int status; /* params should contain name of mini-driver */ if (params == NULL) { return (NULL); } /* * check to see that name of mini-driver matches one in the device table * and its type is of DEV_IOMTYPE. */ (void)DEV_match(params->name, &entry); if (entry == NULL || entry->type != DEV_IOMTYPE) { return (NULL); } /* allocate 0-initialized dio object */ if ((dio = MEM_calloc(0, sizeof(DIO_Obj), 0)) == MEM_ILLEGAL) { return (NULL); } /* * Tasks will pend on dio->complete if there are no available frames on * the fromdevice queue. */ dio->context.sems.complete = SEM_create(0, NULL); /* make sure SEM_create() succeeded ... */ if (dio->context.sems.complete == NULL) { MEM_free(0, dio, sizeof(DIO_Obj)); /* free dio object */ return (NULL); } dio->fxns = (IOM_Fxns *)entry->fxns; mode = (device->mode == DEV_INPUT) ? IOM_INPUT : IOM_OUTPUT; /* create a channel from the mini-driver */ status = dio->fxns->mdCreateChan(&dio->chanp, entry->devp, name, mode, params->chanParams, DIO_tskCallback, device); if (status != IOM_COMPLETED) { tskRmPort(dio); return (NULL); } return (dio); }
Void main(Int argc, Char *argv[]) { // create the semaphore dprint_sema = SEM_create (0, NULL); // connect with gpp: DSPLINK_init (); // register callback from the gpp side: NOTIFY_register (ID_GPP, 0, 6, dprint_callback, 0); // start task: TSK_create(TaskMain, NULL, &0); // task will start as soon as main ends! // don't call dprintf from here! }
/* * ======== Sem_create ======== */ Sem_Handle Sem_create(Int key, Int count) { SEM_Handle sem; GT_1trace(curTrace, GT_ENTER, "Sem_create> count %d\n", count); if ((sem = SEM_create(count, NULL)) == NULL) { GT_0trace(curTrace, GT_7CLASS, "Sem_create> SEM_create failed\n"); } GT_1trace(curTrace, GT_ENTER, "Sem_create> sem: 0x%lx\n", sem); return ((Sem_Handle)sem); }
/* * ======== DPI_init ======== */ Void DPI_init(Void) { /* Make sure the initialization happens only once for the DPI driver.*/ static __FAR__ Bool curInit = FALSE; if ( curInit ) { return; } curInit = TRUE; mutex = SEM_create(1, NULL); sPipeList = QUE_create(NULL); if (mutex == NULL || sPipeList == NULL) { SYS_abort("DPI"); } }