c_can.c

HMS30C7202下的CAN驱动

                pmsgobj->hostchip->write_register( dataA1, pmsgobj->hostchip, CCIF2DA1);
                pmsgobj->hostchip->write_register( dataA2, pmsgobj->hostchip, CCIF2DA2);
                pmsgobj->hostchip->write_register( dataB1, pmsgobj->hostchip, CCIF2DB1);
                pmsgobj->hostchip->write_register( dataB2, pmsgobj->hostchip, CCIF2DB2);
        }

        pmsgobj->hostchip->write_register(writeSendMskCM, pmsgobj->hostchip, CCIF2CM);
        pmsgobj->hostchip->write_register(pmsgobj->object+1, pmsgobj->hostchip, CCIF2CR);

        spin_unlock( &pmsgobj->hostchip->if2lock );

        DEBUGMSG(" -> ok");
#ifdef REGDUMP
        c_can_registerdump(pmsgobj->hostchip);
#endif

        return 0;
}

//////////////////////////////////////////////////////////////////////
/**
 * Sends a Remote Frame through the specified message object.
 */
int c_can_remote_request( struct msgobj_t *pmsgobj )
{
        unsigned short readMaskCM = IFXCM_CNTRL;// | IFXCM_ARB;
        //unsigned short writeMaskCM = IFXCM_CNTRL | IFXCM_ARB | IFXCM_WRRD;
        unsigned short mcreg = 0;

        DEBUGMSG("(c%dm%d)calling c_can_remote_request(...)",
                 pmsgobj->hostchip->chip_nr, pmsgobj->object);

        //Remote request is only available when the message object is in receiving mode
        if (!(pmsgobj->flags & CHANNEL_RECEIVE)) {
                return 1;
        }

        spin_lock( &pmsgobj->hostchip->if1lock );

        //loading Message Object in IF1
        if (c_can_if1_busycheck(pmsgobj->hostchip)) return -ENODEV;
        pmsgobj->hostchip->write_register(readMaskCM, pmsgobj->hostchip, CCIF1CM);
        pmsgobj->hostchip->write_register(pmsgobj->object+1, pmsgobj->hostchip, CCIF1CR);
        //setting Transmit-Request-Bit
        if (c_can_if1_busycheck(pmsgobj->hostchip)) return -ENODEV;
        mcreg = pmsgobj->hostchip->read_register( pmsgobj->hostchip, CCIF1DMC);
        pmsgobj->hostchip->write_register(mcreg | IFXMC_TXRQST, pmsgobj->hostchip, CCIF1DMC);

        pmsgobj->hostchip->write_register(pmsgobj->object+1, pmsgobj->hostchip, CCIF1CR);

        spin_unlock( &pmsgobj->hostchip->if1lock );

        DEBUGMSG(" -> Sent remote request through message object %d", pmsgobj->object+1);
#ifdef REGDUMP
        c_can_registerdump(pmsgobj->hostchip);
#endif

        return 0;
}

///////////////////////////////////////////////////////////////////////
/**
 * Allows to write values directly to the bittiming register
 */
int c_can_set_btregs(struct chip_t *pchip,
                     u16 btr0,
                     u16 btr1)
{
        unsigned short tempCR = 0;

        DEBUGMSG("(c%d)calling c_can_set_btregs(...)", pchip->chip_nr);

        // Validate pointer
        if ( NULL == pchip ) return -1;

        if (c_can_enable_configuration(pchip))
                return -ENODEV;

        //read Control Register
        tempCR = pchip->read_register(pchip, CCCR);
        //Configuration Change Enable
        pchip->write_register( tempCR | CR_CCE, pchip, CCCR);
        pchip->write_register(btr0 | (btr1<<8), pchip, CCBT);

        if (c_can_disable_configuration(pchip))
                return -ENODEV;

        DEBUGMSG(" -> ok");
        return 0;
}

///////////////////////////////////////////////////////////////////////
/**
 * Starts the Chip, by setting the CAN Enable Bit
 */
int c_can_start_chip(struct chip_t *pchip)
{
        u16 flags = 0;

        DEBUGMSG("(c%d)calling c_can_start_chip(...)", pchip->chip_nr);

        // Validate pointer
        if ( pchip == NULL ) {
                DEBUGMSG(" -> Error Chip not available.");
                return -1;
        }

//        flags = pchip->read_register(pchip, CCCE) | CE_EN;
//        pchip->write_register(flags, pchip, CCCE);

        flags = pchip->read_register( pchip, CCCE );
        pchip->write_register( flags | CE_EN, pchip, CCCE );

        pchip->chip_status = 0;
        DEBUGMSG(" -> ok");
#ifdef REGDUMP
        c_can_registerdump(pchip);
#endif

        return 0;
}

///////////////////////////////////////////////////////////////////////
/**
 * Stops the Chip, by deleting the CAN Enable Bit
 */
int c_can_stop_chip(struct chip_t *pchip)
{
        u16 flags = 0;

        DEBUGMSG("(c%d)calling c_can_stop_chip(...)", pchip->chip_nr);

        // Validate pointer
        if ( NULL == pchip ) {
                DEBUGMSG(" -> Error Chip not available.");
                return -1;
        }

        flags = pchip->read_register(pchip, CCCE) & ~CE_EN;
        pchip->write_register(flags, pchip, CCCE);

        DEBUGMSG(" -> ok\n");
        return 0;
}

///////////////////////////////////////////////////////////////////////
/**
 * Check the TxOK bit of the Status Register and resets it afterwards.
 */
int c_can_check_tx_stat(struct chip_t *pchip)
{
        unsigned long tempstat = 0;

        DEBUGMSG("(c%d)calling c_can_check_tx_stat(...)", pchip->chip_nr);

        // Validate pointer
        if ( NULL == pchip ) return -1;

        tempstat = pchip->read_register(pchip, CCSR);

        if (tempstat & SR_TXOK) {
                pchip->write_register(tempstat & ~SR_TXOK, pchip, CCSR);
                return 0;
        } else {
                return 1;
        }
}

///////////////////////////////////////////////////////////////////////
/**
 * Writes the values of all C_CAN registers to the logfile.
 */
void c_can_registerdump(struct chip_t *pchip)
{
        CANMSG("------------------------------------");
        CANMSG("---------C-CAN Register Dump--------");
        CANMSG("------------at 0x%.8lx-----------",
                (unsigned long)pchip->base_addr);
        CANMSG("Control Register:             0x%.4lx",
                (long)(pchip->read_register( pchip, CCCR)));
        CANMSG("Status Register:              0x%.4lx",
                (long)(pchip->read_register( pchip, CCSR)));
        CANMSG("Error Counting Register:      0x%.4lx",
                (long)(pchip->read_register( pchip, CCEC)));
        CANMSG("Bit Timing Register:          0x%.4lx",
                (long)(pchip->read_register( pchip, CCBT)));
        CANMSG("Interrupt Register:           0x%.4lx",
                (long)(pchip->read_register( pchip, CCINTR)));
        CANMSG("Test Register:                0x%.4lx",
                (long)(pchip->read_register( pchip, CCTR)));
        CANMSG("Baud Rate Presc. Register:    0x%.4lx",
                (long)(pchip->read_register( pchip, CCBRPE)));
        CANMSG("CAN Enable Register:          0x%.4lx",
                (long)(pchip->read_register( pchip, CCCE)));
        CANMSG("Transm. Req. 1 Register:      0x%.4lx",
                (long)(pchip->read_register( pchip, CCTREQ1)));
        CANMSG("Transm. Req. 2 Register:      0x%.4lx",
                (long)(pchip->read_register( pchip, CCTREQ2)));
        CANMSG("New Data 1 Register:          0x%.4lx",
                (long)(pchip->read_register( pchip, CCND1)));
        CANMSG("New Data 2 Register:          0x%.4lx",
                (long)(pchip->read_register( pchip, CCND2)));
        CANMSG("Interrupt Pend. 1 Register:   0x%.4lx",
                (long)(pchip->read_register( pchip, CCINTP1)));
        CANMSG("Interrupt Pend. 2 Register:   0x%.4lx",
                (long)(pchip->read_register( pchip, CCINTP2)));
        CANMSG("------------------------------------");
        CANMSG("IF1 Command Req. Register:    0x%.4lx",
                (long)(pchip->read_register( pchip, CCIF1CR)));
        CANMSG("IF1 Command Mask Register:    0x%.4lx",
                (long)(pchip->read_register( pchip, CCIF1CM)));
        CANMSG("IF1 Mask 1 Register:          0x%.4lx",
                (long)(pchip->read_register( pchip, CCIF1M1)));
        CANMSG("IF1 Mask 2 Register:          0x%.4lx",
                (long)(pchip->read_register( pchip, CCIF1M2)));
        CANMSG("IF1 Arbitration 1 Register:   0x%.4lx",
                (long)(pchip->read_register( pchip, CCIF1A1)));
        CANMSG("IF1 Arbitration 2 Register:   0x%.4lx",
                (long)(pchip->read_register( pchip, CCIF1A2)));
        CANMSG("IF1 Message Control Register: 0x%.4lx",
                (long)(pchip->read_register( pchip, CCIF1DMC)));
        CANMSG("IF1 Data A1 Register:         0x%.4lx",
                (long)(pchip->read_register( pchip, CCIF1DA1)));
        CANMSG("IF1 Data A2 Register:         0x%.4lx",
                (long)(pchip->read_register( pchip, CCIF1DA2)));
        CANMSG("IF1 Data B1 Register:         0x%.4lx",
                (long)(pchip->read_register( pchip, CCIF1DB1)));
        CANMSG("IF1 Data B2 Register:         0x%.4lx",
                (long)(pchip->read_register( pchip, CCIF1DB2)));
        CANMSG("------------------------------------");
        CANMSG("IF2 Command Req. Register:    0x%.4lx",
                (long)(pchip->read_register( pchip, CCIF2CR)));
        CANMSG("IF2 Command Mask Register:    0x%.4lx",
                (long)(pchip->read_register( pchip, CCIF2CM)));
        CANMSG("IF2 Mask 1 Register:          0x%.4lx",
                (long)(pchip->read_register( pchip, CCIF2M1)));
        CANMSG("IF2 Mask 2 Register:          0x%.4lx",
                (long)(pchip->read_register( pchip, CCIF2M2)));
        CANMSG("IF2 Arbitration 1 Register:   0x%.4lx",
                (long)(pchip->read_register( pchip, CCIF2A1)));
        CANMSG("IF2 Arbitration 2 Register:   0x%.4lx",
                (long)(pchip->read_register( pchip, CCIF2A2)));
        CANMSG("IF2 Message Control Register: 0x%.4lx",
                (long)(pchip->read_register( pchip, CCIF2DMC)));
        CANMSG("IF2 Data A1 Register:         0x%.4lx",
                (long)(pchip->read_register( pchip, CCIF2DA1)));
        CANMSG("IF2 Data A2 Register:         0x%.4lx",
                (long)(pchip->read_register( pchip, CCIF2DA2)));
        CANMSG("IF2 Data B1 Register:         0x%.4lx",
                (long)(pchip->read_register( pchip, CCIF2DB1)));
        CANMSG("IF2 Data B2 Register:         0x%.4lx",
                (long)(pchip->read_register( pchip, CCIF2DB2)));
        CANMSG("------------------------------------");
        CANMSG("------------------------------------");
}

///////////////////////////////////////////////////////////////////////
/**
 * Sets the chip specific functions pointers of the chip structure
 */
int c_can_register(struct chip_t *pchip)
{
        DEBUGMSG("(c%d)call c_can_register", pchip->chip_nr);

        // Validate pointer
        if ( NULL == pchip ) return -1;

        pchip->chip_config = c_can_chip_config;
        pchip->set_baud_rate = c_can_baud_rate;
        pchip->set_mask = c_can_mask;
        pchip->set_use_mask = c_can_use_mask;
        pchip->clear_objects = c_can_clear_objects;
        pchip->config_irqs = c_can_config_irqs;
        pchip->pre_read_config = c_can_pre_read_config;
        pchip->send_msg = c_can_send_msg;
        pchip->check_tx_stat = c_can_check_tx_stat;
        pchip->remote_request = c_can_remote_request;
        pchip->enable_configuration = c_can_enable_configuration;
        pchip->disable_configuration = c_can_disable_configuration;
        pchip->set_btregs = c_can_set_btregs;
        pchip->start_chip = c_can_start_chip;
        pchip->stop_chip = c_can_stop_chip;
        pchip->register_dump = c_can_registerdump;

        DEBUGMSG(" -> ok");
        return 0;
}