cy7c67200_300_lcd.c

来自「linux嵌入式课程实践中的一个关于声卡驱动程序 。」· C语言 代码 · 共 2,069 行 · 第 1/5 页

            }

            break;          

        case LCD_REMOTE_WAKEUP:
            /* Determine correct SIE number */
            if ((port_number == PORT0) || (port_number == PORT1))
                reg_value = 1;
            else
                reg_value = 2;

            /* Initiate Remote Wakeup LCP for specified SIE */
            lcp = lcd_create_lcp_entry(COMM_EXEC_INT,
                                       REMOTE_WAKEUP_INT,reg_value,0,0,0,
                                       0,0,0,0,0,
                                       0,0,0,0,0,
                                       0,0,funcptr,
                                       opt_arg,
                                       cy_private_data);

            /* Add lcp Entry */
            if (lcp != NULL)
                response = lcd_add_lcp_entry(lcp, cy_private_data);

            break;

        default:
            /* Unknown command */
            cy_err("lcd_command: error unsupported command %d\n", command);
    }

    return(response);
}


/*
 *  FUNCTION: lcd_send_data
 *
 *  PARAMETERS:
 *    chip_addr       - Offset Address of the ASIC
 *    port_number     - ASIC Port number
 *    endpoint        - USB Endpoint number
 *    byte_length     - Length of Control data to send
 *    data            - Control Data to send pointer
 *    funcptr         - Function (Callback) to call when the send completes
 *    opt_arg         - Optional argument to pass to the Callback Function
 *    cy_private_data - Private data structure pointer
 *
 *  DESCRIPTION:
 *    This function sends data to the specified Port and Endpoint.
 *
 *  RETURNS: 
 *    SUCCESS         - Success
 *    Error           - Failure
 */
int lcd_send_data(unsigned short chip_addr, 
                  unsigned short port_number,
                  unsigned short endpoint,
                  int byte_length,
                  char * data,
                  lcd_callback_t funcptr,
                  int opt_arg,
                  cy_priv_t * cy_private_data)

{
    int response = ERROR;
    lcd_lcp_entry_t * lcp;
    unsigned short int_num;

    /* Write control structure to Lyberty Memory */
    if (lcd_write_memory(chip_addr, byte_length, 
                         data, cy_private_data) == SUCCESS) {

        /* Determine correct SIE ptr address */
        if ((port_number == PORT0) || (port_number == PORT1))
            int_num = SUSB1_SEND_INT;
        else
            int_num = SUSB2_SEND_INT;

        lcp = lcd_create_lcp_entry(COMM_EXEC_INT,
                                   int_num,0,endpoint,0,0,
                                   0,0,0,0,chip_addr,
                                   0,0,0,0,0,
                                   0,0,funcptr,
                                   opt_arg,
                                   cy_private_data);

        /* Add lcp Entry */
        if (lcp != NULL)
            response = lcd_add_lcp_entry(lcp, cy_private_data);
    }

    return response;
}


/*
 *  FUNCTION: lcd_recv_data
 *
 *  PARAMETERS:
 *    chip_addr       - Offset Address of the ASIC
 *    port_number     - ASIC Port number
 *    endpoint        - USB Endpoint number
 *    byte_length     - Length of data to receive
 *    data            - Control Data to receive pointer (if any)
 *    funcptr         - Function (Callback) to call when the receive completes
 *    opt_arg         - Optional argument to pass to the Callback Function
 *    cy_private_data - Private data structure pointer
 *
 *  DESCRIPTION:
 *    This function receives data from the specified Port and Endpoint.
 *
 *  RETURNS: 
 *    SUCCESS         - Success
 *    Error           - Failure
 */
int lcd_recv_data(unsigned short chip_addr, 
                  unsigned short port_number,
                  unsigned short endpoint,
                  int byte_length,
                  char * data,
                  lcd_callback_t funcptr,
                  int opt_arg,
                  cy_priv_t * cy_private_data)
{
    int response = ERROR;
    lcd_lcp_entry_t * lcp;
    unsigned short int_num;

    /* Write control structure to Lyberty Memory */
    if (lcd_write_memory(chip_addr, byte_length, data, 
                         cy_private_data) == SUCCESS) {
        /* Determine correct SIE ptr address */
        if ((port_number == PORT0) || (port_number == PORT1))
            int_num = SUSB1_RECEIVE_INT;
        else
            int_num = SUSB2_RECEIVE_INT;

        lcp = lcd_create_lcp_entry(COMM_EXEC_INT,
                                   int_num,0,endpoint,0,0,
                                   0,0,0,0,chip_addr,
                                   0,0,0,0,0,
                                   0,0,funcptr,
                                   opt_arg,
                                   cy_private_data);

        /* Add lcp Entry */
        if (lcp != NULL)
            response = lcd_add_lcp_entry(lcp, cy_private_data);
    }

    return response;
}


/*
 *  FUNCTION: lcd_send_tdlist
 *
 *  PARAMETERS:
 *    chip_addr       - Offset Address of the ASIC
 *    port_number     - ASIC Port number
 *    byte_length     - Length of data to send
 *    data            - Data to send pointer (TD List)
 *    cy_private_data - Private data structure pointer
 *
 *  DESCRIPTION:
 *    This function sends the TD list to the specified port.
 *
 *  RETURNS: 
 *    SUCCESS         - Success
 *    Error           - Failure
 */
int lcd_send_tdlist(unsigned short chip_addr, 
                    int port_number,
                    int byte_length,
                    char * data,
                    cy_priv_t * cy_private_data)
{
    int response = ERROR;
    char * ptr = (char *) &chip_addr;
    unsigned short addr;

    /* Write TD to Lyberty Memory */
    if (lcd_write_memory(chip_addr, byte_length, data, 
                         cy_private_data) == SUCCESS) {
        /* Determine correct SIE ptr address */
        if ((port_number == PORT0) || (port_number == PORT1))
            addr = HUSB_SIE1_pCurrentTDPtr;
        else
            addr = HUSB_SIE2_pCurrentTDPtr;

        /* Write address to Lyberty SIEx TD pointer */
        response = lcd_write_memory(addr, 2, ptr, cy_private_data);
    }

    return response;
}

/*
 *  FUNCTION: lcd_get_tdstatus
 *
 *  PARAMETERS:
 *    chip_addr       - Offset Address of the ASIC
 *    byte_length     - Length of data to receive
 *    data            - Data to read pointer (TD Status)
 *    cy_private_data - Private data structure pointer
 *
 *  DESCRIPTION:
 *    This function retrieves the TD Status from the specified address.
 *
 *  RETURNS: 
 *    SUCCESS         - Success
 *    Error           - Failure
 */
int lcd_get_tdstatus(unsigned short chip_addr, 
                     int byte_length,
                     char * data,
                     cy_priv_t * cy_private_data)
{
    int response = ERROR;

    /* Read TD from Lyberty Memory */
    if (byte_length > 0)
        response = lcd_read_memory(chip_addr, byte_length, data, 
                                   cy_private_data);

    return response;
}



/*
 *  FUNCTION: lcd_read_memory
 *
 *  PARAMETERS:
 *    chip_addr       - Offset Address of the ASIC
 *    byte_length     - Length of data to read
 *    data            - Data to receive pointer
 *    cy_private_data - Private data structure pointer
 *
 *  DESCRIPTION:
 *    This function reads data from the specified address and length on the ASIC.
 *
 *  RETURNS: 
 *    SUCCESS         - Success
 *    Error           - Failure
 */
int lcd_read_memory(unsigned short chip_addr,
                    int byte_length,
                    char * data,
                    cy_priv_t * cy_private_data)
{
    int num_words = 0;
    unsigned short short_int;
    //lcd_lcp_entry_t * lcp;    

    /* Check for unaligned address */
    if ((chip_addr & 0x1) == 0x1) {

        /* Read Word */
        short_int = lcd_hpi_read_word((chip_addr - 1), cy_private_data);

        /* Save upper byte */
        *data++ = (char) ((unsigned short) short_int >> 0x8);

        /* Update address */
        chip_addr = chip_addr + 1;

        /* Update length */
        byte_length--;
    }

    /* Determine number of words to read */
    num_words = byte_length >> 1;

    /* Check for words to read */
    if (num_words > 0) {

        lcd_hpi_read_words(chip_addr, (unsigned short *) data, num_words, 
                           cy_private_data);

        byte_length -= (2 * num_words);

        chip_addr += (2 * num_words);
    }

    /* Check for a remaining byte to read*/
    if (byte_length > 0) {

        /* Read Word */
        short_int = lcd_hpi_read_word(chip_addr, cy_private_data);

        /* Save lower byte */
        *(data + 2*num_words) = (char) ((unsigned short) short_int >> 0x0);

        /* Update length */
        byte_length--;
    }

    /* Consistancy check */
    if (byte_length != 0) {
        cy_err("lcd_read_memory: Internal error\n");
    }

    return(SUCCESS);
}

/*
 *  FUNCTION: lcd_write_memory
 *
 *  PARAMETERS:
 *    chip_addr       - Offset Address of the ASIC
 *    byte_length     - Length of data to write
 *    data            - Data to write pointer
 *    cy_private_data - Private data structure pointer
 *
 *  DESCRIPTION:
 *    This function writes data to the specfied address and length on the ASIC.
 *
 *  RETURNS: 
 *    SUCCESS         - Success
 *    Error           - Failure
 */
int lcd_write_memory(unsigned short chip_addr, 
                     int byte_length,
                     char * data,
                     cy_priv_t * cy_private_data)
{
    int response = ERROR;
    int num_words = 0;
    unsigned short short_int;
    unsigned short tmp_short_int;
    //lcd_lcp_entry_t * lcp;

    /* Check if the memory region is writable or not */

    if (lcd_writeable_region(chip_addr, byte_length) == SUCCESS) {

        /* Check for unaligned address */
        if ((chip_addr & 0x1) == 0x1) {

            /* Read Word */
            short_int = lcd_hpi_read_word((chip_addr - 1), cy_private_data);

            /* Modify upper byte */
            tmp_short_int = (unsigned short) (0x00FF & *data++);
            short_int = ((0x00FF & short_int) | (tmp_short_int << 8));

            /* Write Word */
            lcd_hpi_write_word((chip_addr - 1), short_int, cy_private_data);

            /* Update address */
            chip_addr = chip_addr + 1;

            /* Update length */
            byte_length--;
        }

        /* Determine number of words to write */
        num_words = (int) byte_length/2;

        /* Check for words to write */
        if (num_words > 0) {
            lcd_hpi_write_words(chip_addr, (unsigned short *) data, num_words, 
                                cy_private_data);

            byte_length -= (2 * num_words);

            chip_addr += (2 * num_words);

            data += (2 * num_words);
        }

        /* Check for a remaining byte to read*/
        if (byte_length > 0) {

            /* Read Word */
            short_int = lcd_hpi_read_word(chip_addr, cy_private_data); 

            /* Modify lower byte */
            tmp_short_int = (unsigned short) (0x00FF & *data++);
            short_int = ((0xFF00 & short_int) | tmp_short_int);

            /* Write Word */
            lcd_hpi_write_word(chip_addr, short_int, cy_private_data);

            /* Update length */
            byte_length--;
        }

        /* Consistancy check */
        if (byte_length != 0) {
            cy_err("lcd_write_memory: Internal error\n");
        }

        response = SUCCESS;
    }
    else
        cy_err ("lcd_write_memory: this memory region is not writable\n");

    return(response);
}



/*
 *  FUNCTION: lcd_read_xmemory
 *
 *  PARAMETERS:
 *    xmen_addr       - Offset Address of the external memory on the ASIC
 *    byte_length     - Length of data to read
 *    data            - Data to read pointer
 *    funcptr         - Function (Callback) to call when the read completes
 *    opt_arg         - Optional argument to pass to the Callback Function