usb_drv.h

Ir a la documentación de este archivo.

#ifndef _USB_DRV_H_
#define _USB_DRV_H_

//_____ I N C L U D E S ____________________________________________________


typedef enum endpoint_parameter{ep_num, ep_type, ep_direction, ep_size, ep_bank, nyet_status} t_endpoint_parameter;


//_____ M A C R O S ________________________________________________________

#define MAX_EP_NB             7

#define EP_CONTROL            0


// USB EndPoint
#define MSK_EP_DIR            0x7F
#define MSK_UADD              0x7F
#define MSK_EPTYPE            0xC0
#define MSK_EPSIZE            0x70
#define MSK_EPBK              0x0C
#define MSK_DTSEQ             0x0C
#define MSK_NBUSYBK           0x03
#define MSK_CURRBK            0x03
#define MSK_DAT               0xFF  // UEDATX
#define MSK_BYCTH             0x07  // UEBCHX
#define MSK_BYCTL             0xFF  // UEBCLX
#define MSK_EPINT             0x7F  // UEINT
#define MSK_HADDR             0xFF  // UHADDR


// Parameters for endpoint configuration
// These define are the values used to enable and configure an endpoint.
#define TYPE_CONTROL             0
#define TYPE_ISOCHRONOUS         1
#define TYPE_BULK                2
#define TYPE_INTERRUPT           3
 //typedef enum ep_type {TYPE_CONTROL, TYPE_BULK, TYPE_ISOCHRONOUS, TYPE_INTERRUPT} e_ep_type;

#define DIRECTION_OUT            0
#define DIRECTION_IN             1
 //typedef enum ep_dir {DIRECTION_OUT, DIRECTION_IN} e_ep_dir;

#define SIZE_8                   0
#define SIZE_16                  1
#define SIZE_32                  2
#define SIZE_64                  3
#define SIZE_128                 4
#define SIZE_256                 5
#define SIZE_512                 6
#define SIZE_1024                7
 //typedef enum ep_size {SIZE_8,   SIZE_16,  SIZE_32,  SIZE_64,
 //                      SIZE_128, SIZE_256, SIZE_512, SIZE_1024} e_ep_size;

#define ONE_BANK                 0
#define TWO_BANKS                1
 //typedef enum ep_bank {ONE_BANK, TWO_BANKS} e_ep_bank;

#define NYET_ENABLED             0
#define NYET_DISABLED            1
 //typedef enum ep_nyet {NYET_DISABLED, NYET_ENABLED} e_ep_nyet;


#define Usb_build_ep_config0(type, dir, nyet)     ((type<<6) | (nyet<<1) | (dir))
#define Usb_build_ep_config1(size, bank     )     ((size<<4) | (bank<<2)        )
#define usb_configure_endpoint(num, type, dir, size, bank, nyet)             \
                                    ( Usb_select_endpoint(num),              \
                                      usb_config_ep(Usb_build_ep_config0(type, dir, nyet),\
                                                    Usb_build_ep_config1(size, bank)    ))

#define Usb_enable_regulator()          (UHWCON |= (1<<UVREGE))

#define Usb_disable_uid_pin()           (UHWCON &= ~(1<<UIDE))
#define Usb_force_device_mode()         (Usb_disable_uid_pin(), UHWCON |= (1<<UIMOD))

#define Usb_enable()                  (USBCON |= ((1<<USBE) | (1<<OTGPADE)))
#define Usb_disable()                 (USBCON &= ~((1<<USBE) | (1<<OTGPADE)))

#define Usb_select_device()           (USBCON  &= ~(1<<HOST))

#define Usb_freeze_clock()            (USBCON  |=  (1<<FRZCLK))
#define Usb_unfreeze_clock()          (USBCON  &= ~(1<<FRZCLK))

#define Is_usb_id_device()            ((USBSTA &   (1<<ID))      ? TRUE : FALSE)

#define Is_usb_vbus_high()            ((USBSTA &   (1<<VBUS))    ? TRUE : FALSE)
#define Is_usb_vbus_low()             ((USBSTA &   (1<<VBUS))    ? FALSE : TRUE)



   #define Usb_initiate_remote_wake_up()             (UDCON   |=  (1<<RMWKUP))
   #define Usb_detach()                              (UDCON   |=  (1<<DETACH))
   #define Usb_attach()                              (UDCON   &= ~(1<<DETACH))
   #define Is_usb_pending_remote_wake_up()           ((UDCON & (1<<RMWKUP)) ? TRUE : FALSE)
   #define Is_usb_detached()                         ((UDCON & (1<<DETACH)) ? TRUE : FALSE)

   #define Usb_get_device_interrupt()                (UDINT   &   (1<<UDIEN))
   #define Usb_ack_all_device_interrupt()            (UDINT   =  ~(1<<UDIEN))

   #define Usb_enable_remote_wake_up_interrupt()     (UDIEN   |=  (1<<UPRSME))
   #define Usb_disable_remote_wake_up_interrupt()    (UDIEN   &= ~(1<<UPRSME))
#define Is_remote_wake_up_interrupt_enabled()     ((UDIEN &  (1<<UPRSME))   ? TRUE : FALSE)
#define Usb_ack_remote_wake_up_start()            (UDINT   = ~(1<<UPRSMI))
#define Is_usb_remote_wake_up_start()             ((UDINT &   (1<<UPRSMI))  ? TRUE : FALSE)

#define Usb_enable_resume_interrupt()             (UDIEN   |=  (1<<EORSME))
#define Usb_disable_resume_interrupt()            (UDIEN   &= ~(1<<EORSME))
#define Is_resume_interrupt_enabled()             ((UDIEN &  (1<<EORSME))   ? TRUE : FALSE)
#define Usb_ack_resume()                          (UDINT   = ~(1<<EORSMI))
#define Is_usb_resume()                           ((UDINT &   (1<<EORSMI))  ? TRUE : FALSE)

#define Usb_enable_wake_up_interrupt()            (UDIEN   |=  (1<<WAKEUPE))
#define Usb_disable_wake_up_interrupt()           (UDIEN   &= ~(1<<WAKEUPE))
#define Is_wake_up_interrupt_enabled()            ((UDIEN &  (1<<WAKEUPE))   ? TRUE : FALSE)
#define Usb_ack_wake_up()                         (UDINT   = ~(1<<WAKEUPI))
#define Is_usb_wake_up()                          ((UDINT &   (1<<WAKEUPI)) ? TRUE : FALSE)

#define Usb_enable_reset_interrupt()              (UDIEN   |=  (1<<EORSTE))
#define Usb_disable_reset_interrupt()             (UDIEN   &= ~(1<<EORSTE))
#define Is_reset_interrupt_enabled()              ((UDIEN &  (1<<EORSTE))   ? TRUE : FALSE)
#define Usb_ack_reset()                           (UDINT   = ~(1<<EORSTI))
#define Is_usb_reset()                            ((UDINT &   (1<<EORSTI))  ? TRUE : FALSE)

#define Usb_enable_sof_interrupt()                (UDIEN   |=  (1<<SOFE))
#define Usb_disable_sof_interrupt()               (UDIEN   &= ~(1<<SOFE))
#define Is_sof_interrupt_enabled()                ((UDIEN &  (1<<SOFE))   ? TRUE : FALSE)
#define Usb_ack_sof()                             (UDINT   = ~(1<<SOFI))
#define Is_usb_sof()                              ((UDINT &   (1<<SOFI))    ? TRUE : FALSE)

#define Usb_enable_suspend_interrupt()            (UDIEN   |=  (1<<SUSPE))
#define Usb_disable_suspend_interrupt()           (UDIEN   &= ~(1<<SUSPE))
#define Is_suspend_interrupt_enabled()            ((UDIEN &  (1<<SUSPE))   ? TRUE : FALSE)
#define Usb_ack_suspend()                         (UDINT   = ~(1<<SUSPI))
#define Is_usb_suspend()                          ((UDINT &   (1<<SUSPI))   ? TRUE : FALSE)

#define Usb_enable_address()                      (UDADDR  |=  (1<<ADDEN))
#define Usb_disable_address()                     (UDADDR  &= ~(1<<ADDEN))
#define Usb_configure_address(addr)               (UDADDR  =   (UDADDR & (1<<ADDEN)) | ((U8)addr & MSK_UADD))

#define Usb_frame_number()                        ((U16)((((U16)UDFNUMH) << 8) | ((U16)UDFNUML)))
#define Is_usb_frame_number_crc_error()           ((UDMFN & (1<<FNCERR)) ? TRUE : FALSE)




#define Usb_select_endpoint(ep)                   (UENUM = (U8)ep )

#define Usb_get_selected_endpoint()               (UENUM )

#define Usb_reset_endpoint(ep)                    (UERST   =   1 << (U8)ep, UERST  =  0)

#define Usb_enable_endpoint()                     (UECONX  |=  (1<<EPEN))
#define Usb_enable_stall_handshake()              (UECONX  |=  (1<<STALLRQ))
#define Usb_reset_data_toggle()                   (UECONX  |=  (1<<RSTDT))
#define Usb_disable_endpoint()                    (UECONX  &= ~(1<<EPEN))
#define Usb_disable_stall_handshake()             (UECONX  |=  (1<<STALLRQC))
#define Usb_select_epnum_for_cpu()                (UECONX  &= ~(1<<EPNUMS))
#define Is_usb_endpoint_enabled()                 ((UECONX & (1<<EPEN))    ? TRUE : FALSE)
#define Is_usb_endpoint_stall_requested()         ((UECONX & (1<<STALLRQ)) ? TRUE : FALSE)

#define Usb_configure_endpoint_type(type)         (UECFG0X =   (UECFG0X & ~(MSK_EPTYPE)) | ((U8)type << 6))
#define Usb_configure_endpoint_direction(dir)     (UECFG0X =   (UECFG0X & ~(1<<EPDIR))  | ((U8)dir))

#define Usb_configure_endpoint_size(size)         (UECFG1X =   (UECFG1X & ~MSK_EPSIZE) | ((U8)size << 4))
#define Usb_configure_endpoint_bank(bank)         (UECFG1X =   (UECFG1X & ~MSK_EPBK)   | ((U8)bank << 2))
#define Usb_allocate_memory()                     (UECFG1X |=  (1<<ALLOC))
#define Usb_unallocate_memory()                   (UECFG1X &= ~(1<<ALLOC))

#define Usb_ack_overflow_interrupt()              (UESTA0X &= ~(1<<OVERFI))
#define Usb_ack_underflow_interrupt()             (UESTA0X &= ~(1<<UNDERFI))
#define Usb_ack_zlp()                             (UESTA0X &= ~(1<<ZLPSEEN))
#define Usb_data_toggle()                         ((UESTA0X&MSK_DTSEQ) >> 2)
#define Usb_nb_busy_bank()                        (UESTA0X &   MSK_NBUSYBK)
#define Is_usb_one_bank_busy()                    ((UESTA0X &  MSK_NBUSYBK) == 0 ? FALSE : TRUE)
#define Is_endpoint_configured()                  ((UESTA0X &  (1<<CFGOK))   ? TRUE : FALSE)
#define Is_usb_overflow()                         ((UESTA0X &  (1<<OVERFI))  ? TRUE : FALSE)
#define Is_usb_underflow()                        ((UESTA0X &  (1<<UNDERFI)) ? TRUE : FALSE)
#define Is_usb_zlp()                              ((UESTA0X &  (1<<ZLPSEEN)) ? TRUE : FALSE)

#define Usb_control_direction()                   ((UESTA1X &  (1<<CTRLDIR)) >> 2)
#define Usb_current_bank()                        ( UESTA1X & MSK_CURRBK)

#define Usb_ack_fifocon()                         (UEINTX &= ~(1<<FIFOCON))
#define Usb_ack_nak_in()                          (UEINTX &= ~(1<<NAKINI))
#define Usb_ack_nak_out()                         (UEINTX &= ~(1<<NAKOUTI))
#define Usb_ack_receive_setup()                   (UEINTX &= ~(1<<RXSTPI))
#define Usb_ack_receive_out()                     (UEINTX &= ~(1<<RXOUTI), Usb_ack_fifocon())
#define Usb_ack_stalled()                         (MSK_STALLEDI=   0)
#define Usb_ack_in_ready()                        (UEINTX &= ~(1<<TXINI), Usb_ack_fifocon())
#define Usb_kill_last_in_bank()                   (UENTTX |= (1<<RXOUTI))
#define Is_usb_read_enabled()                     (UEINTX&(1<<RWAL))
#define Is_usb_write_enabled()                    (UEINTX&(1<<RWAL))
#define Is_usb_read_control_enabled()             (UEINTX&(1<<TXINI))
#define Is_usb_nak_in_sent()                      (UEINTX&(1<<NAKINI))
#define Is_usb_nak_out_sent()                     (UEINTX&(1<<NAKOUTI))
#define Is_usb_receive_setup()                    (UEINTX&(1<<RXSTPI))
#define Is_usb_receive_out()                      (UEINTX&(1<<RXOUTI))
#define Is_usb_in_ready()                         (UEINTX&(1<<TXINI))
#define Usb_send_in()                             (UEINTX &= ~(1<<FIFOCON))
#define Usb_send_control_in()                     (UEINTX &= ~(1<<TXINI))
#define Usb_free_out_bank()                       (UEINTX &= ~(1<<FIFOCON))
#define Usb_ack_control_out()                     (UEINTX &= ~(1<<RXOUTI))

#define Usb_enable_flow_error_interrupt()         (UEIENX  |=  (1<<FLERRE))
#define Usb_enable_nak_in_interrupt()             (UEIENX  |=  (1<<NAKINE))
#define Usb_enable_nak_out_interrupt()            (UEIENX  |=  (1<<NAKOUTE))
#define Usb_enable_receive_setup_interrupt()      (UEIENX  |=  (1<<RXSTPE))
#define Usb_enable_receive_out_interrupt()        (UEIENX  |=  (1<<RXOUTE))
#define Usb_enable_stalled_interrupt()            (UEIENX  |=  (1<<STALLEDE))
#define Usb_enable_in_ready_interrupt()           (UEIENX  |=  (1<<TXIN))
#define Usb_disable_flow_error_interrupt()        (UEIENX  &= ~(1<<FLERRE))
#define Usb_disable_nak_in_interrupt()            (UEIENX  &= ~(1<<NAKINE))
#define Usb_disable_nak_out_interrupt()           (UEIENX  &= ~(1<<NAKOUTE))
#define Usb_disable_receive_setup_interrupt()     (UEIENX  &= ~(1<<RXSTPE))
#define Usb_disable_receive_out_interrupt()       (UEIENX  &= ~(1<<RXOUTE))
#define Usb_disable_stalled_interrupt()           (UEIENX  &= ~(1<<STALLEDE))
#define Usb_disable_in_ready_interrupt()          (UEIENX  &= ~(1<<TXIN))

#define Usb_read_byte()                           (UEDATX)
#define Usb_write_byte(byte)                      (UEDATX  =   (U8)byte)

#define Usb_byte_counter()                        ((((U16)UEBCHX) << 8) | (UEBCLX))
#define Usb_byte_counter_8()                      ((U8)UEBCLX)

#define Usb_interrupt_flags()                     (UEINT)
#define Is_usb_endpoint_event()                   (Usb_interrupt_flags() != 0x00)




#if !defined(BIG_ENDIAN) && !defined(LITTLE_ENDIAN)
   #error YOU MUST Define the Endian Type of target: LITTLE_ENDIAN or BIG_ENDIAN
#endif
#ifdef LITTLE_ENDIAN
   #define Usb_write_word_enum_struc(x)   (x)
#else //BIG_ENDIAN
   #define Usb_write_word_enum_struc(x)   (wSWAP(x))
#endif



//_____ D E C L A R A T I O N ______________________________________________

U8      usb_config_ep                (U8, U8);

U8      usb_init_device              (void);


#endif  // _USB_DRV_H_

---