USB_main.c

Go to the documentation of this file.

/*****************************************************************************
                           C   M O D U L E   F I L E

    Copyright (c) 2003 Neuros Audio LLC, All rights reserved.

******************************************************************************/


/*-- HEADER FILE INCLUDES ---------------------------------------------------*/
#include "../SYSTEM/sys_hardware.h"
#include "../SYSTEM/sys_main.h"
#include "../SYSTEM/sys_clock.h"
#include "../MESSAGE/message.h"
#include "../GENERIC/generic.h"
#include "usb.h"
#include "usb_assert.h"


/*-- LOCAL DEFINITIONS ------------------------------------------------------*/
#define STK_USB         1024
#define STK_USBCTL      2048    
#define STK_USBEP2      4096    
#define STK_USBTRAFFIC  512
//#define STK_USB           512
//#define STK_USBCTL        1024    
//#define STK_USBEP2        2048    
//#define STK_USBTRAFFIC    512
    
/*-- STATIC DATA ------------------------------------------------------------*/

/*-- GLOBAL DATA ------------------------------------------------------------*/
st_LU_GLOBALS LogicUnit;
 
USB_EpHandle  hEpObjArray[] = { &usb_EpObjOut0, 
                                &usb_EpObjIn0, 
                                &usb_EpObjOut2, 
                                &usb_EpObjIn2, NULL};

// This semaphore will be used by interrupt, it has to be 
// resident all the time.
#pragma DATA_SECTION(SEM_usb, ".idata_resident")
TSK_Handle TSK_usb;
TSK_Handle TSK_usbCtl;
TSK_Handle TSK_usbEp2;
TSK_Handle TSK_usbTraffic;
SEM_Handle SEM_usb;
SEM_Handle SEM_usbCtl;
SEM_Handle SEM_usbEp2;

int STK_usb[STK_USB];
int STK_usbCtl[STK_USBCTL];
int STK_usbEp2[STK_USBEP2];
int STK_usbTraffic[STK_USBTRAFFIC];

extern void USB_task(void);
/*-- FUNCTIONS --------------------------------------------------------------*/

#pragma CODE_SECTION(USB_main, ".usb_code")
void USB_main( void )
{
    IFR |= 0x0002;
    IMR |= 0x0002;
    
    //SYS_clockSetup(CLOCK_USB);
    SYS_clockSetup((CLOCK_MODE)0x90CF);
    
    D12_initClock();

    LogicUnit.NumOfActiveLU = 1;
    LogicUnit.luStatus[0].bMedia_installed = TRUE;
    LogicUnit.luStatus[0].bMedia_ready = TRUE;
    LogicUnit.luStatus[0].bMedia_write_enable = TRUE;
    if(SYS_isHDDpresent())
    {
        // This has to be 1.0 HDD backpack.     
        //LogicUnit.readSec[0] = DiskC.readSec;
        //LogicUnit.writeSec[0] = DiskC.writeSec;
        LogicUnit.readSec[0]  = HDD__rdSec;
        LogicUnit.writeSec[0] = HDD__wrSec;
        LogicUnit.totalSec[0] = DiskC.totalSec16_32;
    }
    else
    {
        // This has to be NAND backpack.
        //LogicUnit.readSec[0] = DiskD.readSec;
        //LogicUnit.writeSec[0] = DiskD.writeSec;
        LogicUnit.readSec[0]  = NAND__rdSec;
        LogicUnit.writeSec[0] = NAND__wrSec;
        LogicUnit.totalSec[0] = DiskD.totalSec16_32;
    }
    
    // USB_maxLUN[1] = 0, meaning device has one logical unit
    // USB_maxLUN[1] = 1, meaning device has two logical units
    // and so on
    USB_maxLUN[1] = LogicUnit.NumOfActiveLU - 1;

    // initializes the USB module
    if ( USB_init() == USB_FALSE ) 
    {
        SYS_die(USB_MAIN);
    }

    USB_ctl_config();   
    USB_msc_config();


    // Connect USB device.  
    USB_connectDev(USB0);
}

#pragma CODE_SECTION(USB_connect, ".usb_code")
void USB_connect(void) 
{
    USB_connectDev(USB0);
}

#pragma CODE_SECTION(USB_disconnect, ".usb_code")
void USB_disconnect(void) 
{
    USB_disconnectDev(USB0);
    
    // Disable USB interrupt.   
    //IMR |= 0x0002;
    IMR &= 0xFFFD;  
}

#pragma CODE_SECTION(USB_createTask, ".usb_code")
void USB_createTask( void )
{
    TSK_Attrs tskAttr = TSK_ATTRS;

    SEM_usb    = SEM_create(0, &SEM_ATTRS);
    SEM_usbCtl = SEM_create(0, &SEM_ATTRS);
    SEM_usbEp2 = SEM_create(0, &SEM_ATTRS);
    
    tskAttr.environ   = &ENV_idata;
    
    tskAttr.priority  = 7;
    tskAttr.stack     = STK_usb;
    tskAttr.stacksize = STK_USB;    
    TSK_usb = TSK_create((Fxn)USB_isr_handler, &tskAttr);
    USB_assert((UINT)TSK_usb, USB_CREATETASK);
    
    tskAttr.priority  = 8;
    tskAttr.stack     = STK_usbCtl;
    tskAttr.stacksize = STK_USBCTL;
    TSK_usbCtl = TSK_create((Fxn)USB_ctl_handler, &tskAttr);
    USB_assert((UINT)TSK_usbCtl, USB_CREATETASK1);
    
    tskAttr.priority  = 9;
    tskAttr.stack     = STK_usbEp2;
    tskAttr.stacksize = STK_USBEP2;
    TSK_usbEp2 = TSK_create((Fxn)USB_msc_handler, &tskAttr);
    USB_assert((UINT)TSK_usbEp2, USB_CREATETASK2);
    
    tskAttr.priority  = 6;
    tskAttr.stack     = STK_usbTraffic;
    tskAttr.stacksize = STK_USBTRAFFIC;
    TSK_usbTraffic = TSK_create((Fxn)USB_traffic_handler, &tskAttr);
    USB_assert((UINT)TSK_usbTraffic, USB_CREATETASK3);
    
    USB_main();
}

#pragma CODE_SECTION(USB_deleteTask, ".usb_code")
void USB_deleteTask( void )
{
    USB_disconnect();
    TSK_delete(TSK_usb);
    TSK_delete(TSK_usbCtl);
    TSK_delete(TSK_usbEp2);
    TSK_delete(TSK_usbTraffic);
    SEM_delete(SEM_usb);
    SEM_delete(SEM_usbCtl);
    SEM_delete(SEM_usbEp2);
}

/*****************************************************************************
                Neuros Audio LLC. Confidential Proprietary
 *****************************************************************************/

---