cy7c67200_300_lcd.c

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

        outw (chip_addr, HPI_ADDR_ADDR + cy_private_data->cy_addr);
        value = inw(HPI_DATA_ADDR + cy_private_data->cy_addr);
    spin_unlock_irqrestore(&lock, int_flags);

    cy_dbg("read_word: addr=0x%04x, value=0x%04x", chip_addr, value);
//    printk("read_word: addr=0x%04x, value=0x%04x", chip_addr, value);

    return(value);
}


/*
 *  FUNCTION: lcd_hpi_write_words
 *
 *  PARAMETERS:
 *    chip_addr       - Offset Address of the ASIC
 *    data            - data pointer
 *    num_words       - Length
 *    cy_private_data - Private data structure pointer
 *
 *  DESCRIPTION:
 *    This function writes words to hpi
 *
 *  RETURNS: 
 *    SUCCESS         - Success
 *    Error           - Failure
 */
void lcd_hpi_write_words(unsigned short chip_addr,
                         unsigned short *data,
                         int num_words,
                         cy_priv_t * cy_private_data)
{
    int i;
    spinlock_t lock;
    unsigned long int_flags;


    /* Hardware Specific Code to Write to Lyberty via HPI Port */
    cy_dbg("write_words: addr=0x%04x, num_words=%d", chip_addr, num_words);

    spin_lock_irqsave(&lock, int_flags);
        outw (chip_addr, HPI_ADDR_ADDR + cy_private_data->cy_addr);

        for (i=0; i<num_words; i++) {
            cy_dbg("  value=0x%04x", *data);
            outw (*data++, HPI_DATA_ADDR + cy_private_data->cy_addr);
        }
    spin_unlock_irqrestore(&lock, int_flags);
}

/*
 *  FUNCTION: lcd_hpi_read_words
 *
 *  PARAMETERS:
 *    chip_addr       - Offset Address of the ASIC
 *    data            - data pointer
 *    num_words       - Length
 *    cy_private_data - Private data structure pointer
 *
 *  DESCRIPTION:
 *    This function reads words from hpi
 *
 *  RETURNS: 
 *    SUCCESS         - Success
 *    Error           - Failure
 */
void lcd_hpi_read_words(unsigned short chip_addr,
                        unsigned short *data,
                        int num_words,
                        cy_priv_t * cy_private_data)
{
    int i;
    spinlock_t lock;
    unsigned long int_flags;


    /* Hardware Specific Code to Read From Lyberty via HPI Port */
    cy_dbg("read_words: addr=0x%04x", chip_addr);

    spin_lock_irqsave(&lock, int_flags);
        outw (chip_addr, HPI_ADDR_ADDR + cy_private_data->cy_addr);

        for (i=0; i<num_words; i++) {
            *data++ = inw (HPI_DATA_ADDR + cy_private_data->cy_addr);
            cy_dbg("  value=0x%04x", *(data-1));
        }
    spin_unlock_irqrestore(&lock, int_flags);
}

/** private functions **/


/*
 *  FUNCTION: lcd_get_ushort
 *
 *  PARAMETERS:
 *    data            - Data
 *    start_address   - Start address in data to convert
 *
 *  DESCRIPTION:
 *    This function builds an unsigned short from the data
 *    provided.
 *
 *  RETURNS: 
 *    An unsigned short.
 */

unsigned short lcd_get_ushort(char * data, int start_address)
{
    unsigned short value = 0;

    value = (((unsigned short) *(data + start_address + 1) << 8) |
             ((unsigned short) *(data + start_address)));

    return value;
}



/*
 *  FUNCTION: lcd_writeable_region
 *
 *  PARAMETERS:
 *    chip_addr       - Offset Address of the ASIC
 *    byte_length     - Length
 *
 *  DESCRIPTION:
 *    This function determines if the address and length falls within
 *    a valid "writeable" region.
 *
 *  RETURNS: 
 *    SUCCESS         - Success
 *    Error           - Failure
 */
int lcd_writeable_region(unsigned short chip_addr,
                         int byte_length)
{
    int response = ERROR;

    /* Check that address is in a valid writable range */
    if (((int) chip_addr + byte_length) <= 0xFFFF)
        response = SUCCESS;

    return response;
}


/*
 *  FUNCTION: lcd_start_lcp
 *
 *  PARAMETERS:
 *    lcp             - LCP entry pointer
 *    cy_private_data - Private data structure pointer
 *
 *  DESCRIPTION:
 *    This function submits the (first queued) LCP entry to the ASIC
 *    for processing with the correct arguments.
 *
 *  RETURNS: 
 *    SUCCESS         - Success
 *    Error           - Failure
 */
int lcd_start_lcp(lcd_lcp_entry_t * lcp,
                  cy_priv_t * cy_private_data)
{
    int response = SUCCESS;

    cy_dbg("lcd_start_lcp enter");
    
    /* Handle command */
    switch (lcp->command) {
        case COMM_RESET:
            /* Send CMD */
            lcd_hpi_write_mbx(COMM_RESET, cy_private_data);
            break;

        case COMM_JUMP2CODE:
            /* Set Jump Address */
            lcd_hpi_write_word(COMM_CODE_ADDR, lcp->arg[0], cy_private_data);

            /* Send CMD */
            lcd_hpi_write_mbx(COMM_JUMP2CODE, cy_private_data);
            break;

        case COMM_CALL_CODE:
            /* Set Call Address */
            lcd_hpi_write_word(COMM_CODE_ADDR, lcp->arg[0], cy_private_data);

            /* Send CMD */
            lcd_hpi_write_mbx(COMM_CALL_CODE, cy_private_data);
            break;

        case COMM_WRITE_CTRL_REG:
            /* Set Control Reg Address */
            lcd_hpi_write_word(COMM_CTRL_REG_ADDR, lcp->arg[0], cy_private_data);

            /* Set Value */
            lcd_hpi_write_word(COMM_CTRL_REG_DATA, lcp->arg[1], cy_private_data);

            /* Send CMD */
            lcd_hpi_write_mbx(COMM_WRITE_CTRL_REG, cy_private_data);
            break;

        case COMM_READ_CTRL_REG:
            /* Set Control Reg Address */
            lcd_hpi_write_word(COMM_CTRL_REG_ADDR, lcp->arg[0], cy_private_data);

            /* Send CMD */
            lcd_hpi_write_mbx(COMM_READ_CTRL_REG, cy_private_data);
            break;

        case COMM_EXEC_INT:
            /* Set Int Number */
            lcd_hpi_write_word(COMM_INT_NUM, lcp->arg[0], cy_private_data);
            HWTrace(0x7878);
            HWData(lcp->arg[0]);
            HWData(lcp->arg[2]);
            HWData(lcp->arg[9]);

            /* Set Register values */
            lcd_hpi_write_word(COMM_R0, lcp->arg[1], cy_private_data);
            lcd_hpi_write_word(COMM_R1, lcp->arg[2], cy_private_data);
            lcd_hpi_write_word(COMM_R2, lcp->arg[3], cy_private_data);
            lcd_hpi_write_word(COMM_R3, lcp->arg[4], cy_private_data);
            lcd_hpi_write_word(COMM_R4, lcp->arg[5], cy_private_data);
            lcd_hpi_write_word(COMM_R5, lcp->arg[6], cy_private_data);
            lcd_hpi_write_word(COMM_R6, lcp->arg[7], cy_private_data);
            lcd_hpi_write_word(COMM_R7, lcp->arg[8], cy_private_data);
            lcd_hpi_write_word(COMM_R8, lcp->arg[9], cy_private_data);
            lcd_hpi_write_word(COMM_R9, lcp->arg[10], cy_private_data);
            lcd_hpi_write_word(COMM_R10, lcp->arg[11], cy_private_data);
            lcd_hpi_write_word(COMM_R11, lcp->arg[12], cy_private_data);
            lcd_hpi_write_word(COMM_R12, lcp->arg[13], cy_private_data);
            lcd_hpi_write_word(COMM_R13, lcp->arg[14], cy_private_data);
    
            /* Send CMD */
            lcd_hpi_write_mbx(COMM_EXEC_INT, cy_private_data);
            break;

        case COMM_READ_XMEM:
            /* Send CMD */
            lcd_hpi_write_mbx(COMM_READ_XMEM, cy_private_data);
            break;

        case COMM_WRITE_XMEM:
            /* Send CMD */
            lcd_hpi_write_mbx(COMM_WRITE_XMEM, cy_private_data);
            break;

        case COMM_READ_MEM:
        case COMM_WRITE_MEM:
            /* NOP for HPI */
            break;
        
        default:
            /* Indicate error */
            response = ERROR;

            cy_err("lcd_start_lcp: error unknown LCP command %d\n", 
                   lcp->command);
    }

    return(response);
}


/*
 *  FUNCTION: lcd_create_lcp_entry
 *
 *  PARAMETERS:
 *    command         - LCP command
 *    arg1            - Argument 1
 *      .                   .
 *      .                   .
 *    arg15           - Argument 15
 *    buf             - Data buffer pointer
 *    len             - Buffer length
 *    funcptr         - Function (Callback) to call when the LCP command
 *                      completes
 *    opt_arg         - Optional argument to pass to the Callback Function
 *    cy_private_data - Private data structure pointer
 *
 *  DESCRIPTION:
 *    This function creates an new LCP entry structure and fills it.
 *
 *  RETURNS: 
 *    Pointer to a new lcd_lcp_entry_t entry or NULL
 */
lcd_lcp_entry_t * lcd_create_lcp_entry(unsigned short command,
                                       unsigned short arg1,
                                       unsigned short arg2,
                                       unsigned short arg3,
                                       unsigned short arg4,
                                       unsigned short arg5,
                                       unsigned short arg6,
                                       unsigned short arg7,
                                       unsigned short arg8,
                                       unsigned short arg9,
                                       unsigned short arg10,
                                       unsigned short arg11,
                                       unsigned short arg12,
                                       unsigned short arg13,
                                       unsigned short arg14,
                                       unsigned short arg15,
                                       char * buf,
                                       int len,
                                       lcd_callback_t funcptr,
                                       int opt_arg,
                                       cy_priv_t * cy_private_data)
{
    lcd_lcp_entry_t * lcp;

    HWTrace(0x7e7e);

    /* Allocate memory for lcp entry */
    lcp = (lcd_lcp_entry_t *) kmalloc(sizeof(lcd_lcp_entry_t), 0);

    if (lcp != NULL) {
        lcp->command = command;
        lcp->arg[0] = arg1;
        lcp->arg[1] = arg2;
        lcp->arg[2] = arg3;
        lcp->arg[3] = arg4;
        lcp->arg[4] = arg5;
        lcp->arg[5] = arg6;
        lcp->arg[6] = arg7;
        lcp->arg[7] = arg8;
        lcp->arg[8] = arg9;
        lcp->arg[9] = arg10;
        lcp->arg[10] = arg11;
        lcp->arg[11] = arg12;
        lcp->arg[12] = arg13;
        lcp->arg[13] = arg14;
        lcp->arg[14] = arg15;
        lcp->buf = buf;
        lcp->len = len;
        lcp->funcptr = funcptr;
        lcp->opt_arg = opt_arg;
        lcp->cy_priv_data = cy_private_data;
    }
    else
        cy_err("lcd_create_lcp_entry: kmalloc error\n");

    return lcp;
}


/*
 *  FUNCTION: lcd_add_lcp_entry
 *
 *  PARAMETERS:
 *    lcp             - LCP entry pointer
 *    cy_private_data - Private data structure pointer
 *
 *  DESCRIPTION:
 *    This function adds the LCP entry to the LCP Queue (FIFO).
 *
 *  RETURNS: 
 *    SUCCESS         - Success
 *    Error           - Failure
 */
int lcd_add_lcp_entry(lcd_lcp_entry_t * lcp,
                      cy_priv_t * cy_private_data)
{
    lcd_priv_data_t * lcd_private_data = 
        (lcd_priv_data_t *) cy_private_data->lcd_priv;

    int response = ERROR;
    int startLCP = FALSE;
    int lock_flags;

    if ((lcp != NULL) && (lcd_private_data != NULL)) {

        /* Do not allow Lyberty interrupts and etc. */
        spin_lock_irqsave(&lcd_private_data->lcd_lock, lock_flags);

        /* If list is empty we neet to start up the LCP entry */
        if (list_empty(&lcd_private_data->lcd_lcp_list))
            startLCP = TRUE;

        /* Add LCP entry to list */
        list_add_tail(&lcp->list, &lcd_private_data->lcd_lcp_list);

        /* Start up LCP if necessary */
        /* TODO add entry test start LCP, on error release */
        if (startLCP == TRUE)
            response = lcd_start_lcp(lcp, cy_private_data);
        else
            {
            HWTrace(0x7f7f);
            HWData(lcp->command);
            response = SUCCESS;
            }

        /* allow interrupts and etc. */
        spin_unlock_irqrestore(&lcd_private_data->lcd_lock, lock_flags);
    }

    return(response);
}


/*****************************************************************
 *
 * Function Name: cy67x00_int_handler
 *
 * Interrupt service routine. 
 *
 * Main interrupt entry for both host and peripheral controllers.
 *
 * Input:  irq = interrupt line associated with the controller 
 *         cy_priv = private data structure for controllers
 *         r = holds the sna