Re: [EMBEDDED] prima versione driver finita e domandina

[Paolo Palana < >]

Ciao Lorenzo, io eseguo l'Hreset (che corrisponde a scrivere 1 su slv_reg6(1) e successivamente 0) solo all'inizio. Di seguito, per maggio chiarezza, trovi il codice del driver che scrive i dati sulla periferica.

C'e' pero' una cosa che mi sono scordato di scrivere nella precedente mail. Nella vostra implementazione usavate come buffer di input una ram, mentre io l'ho sostituita con una FIFO. Inoltre ho sostituito la CustomFifo sempre con una FIFO. Entrambe sono megafunction e sono sicuro al 100% che funzionano. Tuttavia pensi che potrebbe il problema potrebbe risiedere in queste sostituzioni?

Buona giornata

Paolo

static ssize_t n2sha1_write(struct file *filp, const char __user *buf,
             size_t count, loff_t *f_pos)
{
    struct n2sha1_dev *dev = filp->private_data;
    u32 rfu_size;   //Numero di bytes da trasferire dallo user space
    u32 rfu_blocks; //Numero di blocchi da 16 word
    u32 curr_block;
    u32 curr_word;

    iowrite32(0x1, dev->baddr+RST_CMD_REG_OFFT);
    iowrite32(0x0, dev->baddr+RST_CMD_REG_OFFT);

    iowrite32(0x0, dev->baddr+CTRL_REG_OFFT); //Scrivo tutti 0 sul slv_reg6
    iowrite32(0x2, dev->baddr+CTRL_REG_OFFT); //Scrivo tutti 1 sul slv_reg6(1)
    iowrite32(0x0, dev->baddr+CTRL_REG_OFFT); //Scrivo tutti 0 sul slv_reg6(1)



    printk(KERN_INFO "[%s] Received %d bytes\n", __func__, count);

    while(count)
    {
        rfu_size = (count>INPUT_BUFF_SIZE) ? INPUT_BUFF_SIZE : count;
        rfu_blocks = (rfu_size%64==0) ? rfu_size>>6 : (rfu_size>>6)+1;
        printk(KERN_INFO "[%s] Reading back %d bytes from user space\n",
                __func__, rfu_size);
        printk(KERN_INFO "[%s] Handling %d 512-bit blocks\n",
                __func__, rfu_blocks);

        memset(dev->wrbuf, 0x00, INPUT_BUFF_SIZE);
        if(copy_from_user(dev->wrbuf, buf, rfu_size))
        {
            printk(KERN_ERR "Copy from user error\n");
            return -EFAULT;
        }
        for(curr_block=0; curr_block<rfu_blocks; curr_block++)
        {
            printk(KERN_INFO "[%s] Sending block %d", __func__, curr_block);
            for(curr_word=0; curr_word<WORDS; curr_word++)
            {
                iowrite32(dev->wrbuf[(curr_block*WORDS)+curr_word],
                        dev->baddr+FIFO_IN_OFFT);
            }
            iowrite32(0x1, dev->baddr+CTRL_REG_OFFT);
            //polling con kernel timer
            dev->new_blk =  ioread32(dev->baddr+STATUS_REG_OFFT);
            dev->new_blk &= 0x1;
            printk(KERN_INFO "[%s] Polling b it is %d\n", __func__,
                    dev->new_blk);
            if(!(dev->new_blk)) //Se il bit di polling e' 0
            {
                //registro il timer
                if(!timer_pending(&dev->wrt))
                {
                    dev->wrt.expires = jiffies + MSEC_WAIT(5);
                    add_timer(&dev->wrt);
                }
                wait_event_interruptible(dev->q, dev->new_blk);
 }
            del_timer(&dev->wrt);
            printk("[%s] Ready for a new block\n", __func__);
            iowrite32(0x0, dev->baddr+CTRL_REG_OFFT);
        }
        count -= rfu_size;
    }
    printk("[%s] DONE\n", __func__);
    return count;
}

2011/5/26 Lorenzo Iafolla < "> >

Ciao Paolo,

forse potrebbe aver creato confusione la procedura che ti avevo scritto in una delle ultime mail: esegui l'Hreset prima di ogni blocco o solo all'inizio? Devi eseguirlo solo all'inizio. Se non č questo il problema credo ci sia un bug di cui non ci eravamo accorti!

Per l'incontro va bene quando volete.

Ciao!

 

       Lorenzo

--- Mer 25/5/11, Paolo Palana < " target="_blank"> > ha scritto:

Da: Paolo Palana < " target="_blank"> >
Oggetto: [EMBEDDED] prima versione driver finita e domandina
A: " target="_blank">
Data: Mercoledė 25 maggio 2011, 16:50

Salve a tutti,
volevo comunicarvi che finalmente ho finito di modificare il codice vhdl per la scheda a mia disposizione (sono state necessarie solo 2 piccolissime modifiche) e di scrivere la prima versione del driver per linux.
Quest'ultimo l'ho testato e sembra funzionare correttamente.

Ho pero' un quesito da porvi. Quando applico sha1 ad un singolo blocco di dati il risultato mi torna con il risultato del software che mi ha indicato Claudio, al momento non effettuo il padding. Quando pero' applico lo sha1 a due diversi blocchi i risultati ottenuti dal software e dall'hardware differiscono. Qualcuno ha idea del perche'?

Direi anche che potrebbe essere il caso di fissare un primo incontro, cosa ne dite?

--
Paolo Palana, PhD Student
< " rel="nofollow" target="_blank"> >
Dept. of Computer Science, Systems, and Industrial Engineering
University of Rome "Tor Vergata", Via del Politecnico, 1 - 00133 Rome
office: D1 - 21
phone : +39 06 7259 7714

-- 
Paolo Palana, PhD Student 
<
 
 ">
 >
Dept. of Computer Science, Systems, and Industrial Engineering
University of Rome "Tor Vergata", Via del Politecnico, 1 - 00133 Rome
office: D1 - 21
phone : +39 06 7259 7714