Mercurial Mercurial > etherlabmaster / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
master/ethernet.c
changeset 2045 ff2a13a4603c
parent 2044 1ae0491b2f6b
child 2094 83e9160319ec
equal deleted inserted replaced
2044:1ae0491b2f6b 2045:ff2a13a4603c 
   109     char name[EC_DATAGRAM_NAME_SIZE];
 
   109     char name[EC_DATAGRAM_NAME_SIZE];
 
   110 
   110 
   111     eoe->slave = slave;
 
   111     eoe->slave = slave;
 
   112 
   112 
   113     ec_datagram_init(&eoe->datagram);
 
   113     ec_datagram_init(&eoe->datagram);
 
       
   114     ec_mbox_init(&eoe->mbox,&eoe->datagram);
 
   114     eoe->queue_datagram = 0;
 
   115     eoe->queue_datagram = 0;
 
   115     eoe->state = ec_eoe_state_rx_start;
 
   116     eoe->state = ec_eoe_state_rx_start;
 
   116     eoe->opened = 0;
 
   117     eoe->opened = 0;
 
   117     eoe->rx_skb = NULL;
 
   118     eoe->rx_skb = NULL;
 
   118     eoe->rx_expected_fragment = 0;
 
   119     eoe->rx_expected_fragment = 0;
 
   218     if (eoe->rx_skb)
 
   219     if (eoe->rx_skb)
 
   219         dev_kfree_skb(eoe->rx_skb);
 
   220         dev_kfree_skb(eoe->rx_skb);
 
   220 
   221 
   221     free_netdev(eoe->dev);
 
   222     free_netdev(eoe->dev);
 
   222 
   223 
       
   224     ec_mbox_clear(&eoe->mbox);
 
   223     ec_datagram_clear(&eoe->datagram);
 
   225     ec_datagram_clear(&eoe->datagram);
 
   224 }
 
   226 }
 
   225 
   227 
   226 /*****************************************************************************/
 
   228 /*****************************************************************************/
 
   227 
   229 
   292         }
 
   294         }
 
   293     }
 
   295     }
 
   294     printk("\n");
 
   296     printk("\n");
 
   295 #endif
 
   297 #endif
 
   296 
   298 
   297     data = ec_slave_mbox_prepare_send(eoe->slave, &eoe->datagram,
 
   299     data = ec_slave_mbox_prepare_send(eoe->slave, &eoe->mbox,
 
   298             0x02, current_size + 4);
 
   300             0x02, current_size + 4);
 
   299     if (IS_ERR(data))
 
   301     if (IS_ERR(data))
 
   300         return PTR_ERR(data);
 
   302         return PTR_ERR(data);
 
   301 
   303 
   302     EC_WRITE_U8 (data,     0x00); // eoe fragment req.
 
   304     EC_WRITE_U8 (data,     0x00); // eoe fragment req.
 
   322     if (!eoe->opened)
 
   324     if (!eoe->opened)
 
   323         return;
 
   325         return;
 
   324 
   326 
   325     // if the datagram was not sent, or is not yet received, skip this cycle
 
   327     // if the datagram was not sent, or is not yet received, skip this cycle
 
   326     if (eoe->queue_datagram ||
 
   328     if (eoe->queue_datagram ||
 
   327         eoe->datagram.state == EC_DATAGRAM_QUEUED || eoe->datagram.state == EC_DATAGRAM_SENT)
 
   329         ec_mbox_is_datagram_state(&eoe->mbox,EC_DATAGRAM_QUEUED) ||
 
       
   330         ec_mbox_is_datagram_state(&eoe->mbox,EC_DATAGRAM_SENT))
 
   328         return;
 
   331         return;
 
   329 
   332 
   330     // call state function
 
   333     // call state function
 
   331     eoe->state(eoe);
 
   334     eoe->state(eoe);
 
   332 
   335 
   347 /** Queues the datagram, if necessary.
 
   350 /** Queues the datagram, if necessary.
 
   348  */
 
   351  */
 
   349 void ec_eoe_queue(ec_eoe_t *eoe /**< EoE handler */)
 
   352 void ec_eoe_queue(ec_eoe_t *eoe /**< EoE handler */)
 
   350 {
 
   353 {
 
   351    if (eoe->queue_datagram) {
 
   354    if (eoe->queue_datagram) {
 
   352        ec_master_queue_fsm_datagram(eoe->slave->master, &eoe->datagram);
 
   355        ec_master_mbox_queue_datagrams(eoe->slave->master, &eoe->mbox);
 
   353        eoe->queue_datagram = 0;
 
   356        eoe->queue_datagram = 0;
 
   354    }
 
   357    }
 
   355 }
 
   358 }
 
   356 
   359 
   357 /*****************************************************************************/
 
   360 /*****************************************************************************/
 
   393         eoe->rx_idle = 1;
 
   396         eoe->rx_idle = 1;
 
   394         eoe->tx_idle = 1;
 
   397         eoe->tx_idle = 1;
 
   395         return;
 
   398         return;
 
   396     }
 
   399     }
 
   397 
   400 
   398     ec_slave_mbox_prepare_check(eoe->slave, &eoe->datagram);
 
   401     ec_slave_mbox_prepare_check(eoe->slave, &eoe->mbox);
 
   399     eoe->queue_datagram = 1;
 
   402     eoe->queue_datagram = 1;
 
   400     eoe->state = ec_eoe_state_rx_check;
 
   403     eoe->state = ec_eoe_state_rx_check;
 
   401 }
 
   404 }
 
   402 
   405 
   403 /*****************************************************************************/
 
   406 /*****************************************************************************/
 
   407  * Processes the checking datagram sent in RX_START and issues a receive
 
   410  * Processes the checking datagram sent in RX_START and issues a receive
 
   408  * datagram, if new data is available.
 
   411  * datagram, if new data is available.
 
   409  */
 
   412  */
 
   410 void ec_eoe_state_rx_check(ec_eoe_t *eoe /**< EoE handler */)
 
   413 void ec_eoe_state_rx_check(ec_eoe_t *eoe /**< EoE handler */)
 
   411 {
 
   414 {
 
   412     if (eoe->datagram.state != EC_DATAGRAM_RECEIVED) {
 
   415     if (!ec_mbox_is_datagram_state(&eoe->mbox,EC_DATAGRAM_RECEIVED)) {
 
   413         eoe->stats.rx_errors++;
 
   416         eoe->stats.rx_errors++;
 
   414 #if EOE_DEBUG_LEVEL >= 1
 
   417 #if EOE_DEBUG_LEVEL >= 1
 
   415         EC_SLAVE_WARN(eoe->slave, "Failed to receive mbox"
 
   418         EC_SLAVE_WARN(eoe->slave, "Failed to receive mbox"
 
   416                 " check datagram for %s.\n", eoe->dev->name);
 
   419                 " check datagram for %s.\n", eoe->dev->name);
 
   417 #endif
 
   420 #endif
 
   418         eoe->state = ec_eoe_state_tx_start;
 
   421         eoe->state = ec_eoe_state_tx_start;
 
   419         return;
 
   422         return;
 
   420     }
 
   423     }
 
   421 
   424 
   422     if (!ec_slave_mbox_check(&eoe->datagram)) {
 
   425     if (!ec_slave_mbox_check(&eoe->mbox)) {
 
   423         eoe->rx_idle = 1;
 
   426         eoe->rx_idle = 1;
 
   424         eoe->state = ec_eoe_state_tx_start;
 
   427         eoe->state = ec_eoe_state_tx_start;
 
   425         return;
 
   428         return;
 
   426     }
 
   429     }
 
   427 
   430 
   428     eoe->rx_idle = 0;
 
   431     eoe->rx_idle = 0;
 
   429     ec_slave_mbox_prepare_fetch(eoe->slave, &eoe->datagram);
 
   432     ec_slave_mbox_prepare_fetch(eoe->slave, &eoe->mbox);
 
   430     eoe->queue_datagram = 1;
 
   433     eoe->queue_datagram = 1;
 
   431     eoe->state = ec_eoe_state_rx_fetch;
 
   434     eoe->state = ec_eoe_state_rx_fetch;
 
   432 }
 
   435 }
 
   433 
   436 
   434 /*****************************************************************************/
 
   437 /*****************************************************************************/
 
   446     off_t offset;
 
   449     off_t offset;
 
   447 #if EOE_DEBUG_LEVEL >= 3
 
   450 #if EOE_DEBUG_LEVEL >= 3
 
   448     unsigned int i;
 
   451     unsigned int i;
 
   449 #endif
 
   452 #endif
 
   450 
   453 
   451     if (eoe->datagram.state != EC_DATAGRAM_RECEIVED) {
 
   454     if (!ec_mbox_is_datagram_state(&eoe->mbox,EC_DATAGRAM_RECEIVED)) {
 
   452         eoe->stats.rx_errors++;
 
   455         eoe->stats.rx_errors++;
 
   453 #if EOE_DEBUG_LEVEL >= 1
 
   456 #if EOE_DEBUG_LEVEL >= 1
 
   454         EC_SLAVE_WARN(eoe->slave, "Failed to receive mbox"
 
   457         EC_SLAVE_WARN(eoe->slave, "Failed to receive mbox"
 
   455                 " fetch datagram for %s.\n", eoe->dev->name);
 
   458                 " fetch datagram for %s.\n", eoe->dev->name);
 
   456 #endif
 
   459 #endif
 
   457         eoe->state = ec_eoe_state_tx_start;
 
   460         eoe->state = ec_eoe_state_tx_start;
 
   458         return;
 
   461         return;
 
   459     }
 
   462     }
 
   460 
   463 
   461     data = ec_slave_mbox_fetch(eoe->slave, &eoe->datagram,
 
   464     data = ec_slave_mbox_fetch(eoe->slave, &eoe->mbox,
 
   462             &mbox_prot, &rec_size);
 
   465             &mbox_prot, &rec_size);
 
   463     if (IS_ERR(data)) {
 
   466     if (IS_ERR(data)) {
 
   464         eoe->stats.rx_errors++;
 
   467         eoe->stats.rx_errors++;
 
   465 #if EOE_DEBUG_LEVEL >= 1
 
   468 #if EOE_DEBUG_LEVEL >= 1
 
   466         EC_SLAVE_WARN(eoe->slave, "Invalid mailbox response for %s.\n",
 
   469         EC_SLAVE_WARN(eoe->slave, "Invalid mailbox response for %s.\n",
 
   683  * Checks is the previous transmit datagram succeded and sends the next
 
   686  * Checks is the previous transmit datagram succeded and sends the next
 
   684  * fragment, if necessary.
 
   687  * fragment, if necessary.
 
   685  */
 
   688  */
 
   686 void ec_eoe_state_tx_sent(ec_eoe_t *eoe /**< EoE handler */)
 
   689 void ec_eoe_state_tx_sent(ec_eoe_t *eoe /**< EoE handler */)
 
   687 {
 
   690 {
 
   688     if (eoe->datagram.state != EC_DATAGRAM_RECEIVED) {
 
   691     if (!ec_mbox_is_datagram_state(&eoe->mbox,EC_DATAGRAM_RECEIVED)) {
 
   689         if (eoe->tries) {
 
   692         if (eoe->tries) {
 
   690             eoe->tries--; // try again
 
   693             eoe->tries--; // try again
 
   691             eoe->queue_datagram = 1;
 
   694             eoe->queue_datagram = 1;
 
   692         } else {
 
   695         } else {
 
   693             eoe->stats.tx_errors++;
 
   696             eoe->stats.tx_errors++;
 
   699             eoe->state = ec_eoe_state_rx_start;
 
   702             eoe->state = ec_eoe_state_rx_start;
 
   700         }
 
   703         }
 
   701         return;
 
   704         return;
 
   702     }
 
   705     }
 
   703 
   706 
   704     if (eoe->datagram.working_counter != 1) {
 
   707     if (!ec_mbox_is_datagram_wc(&eoe->mbox,1)) {
 
   705         if (eoe->tries) {
 
   708         if (eoe->tries) {
 
   706             eoe->tries--; // try again
 
   709             eoe->tries--; // try again
 
   707             eoe->queue_datagram = 1;
 
   710             eoe->queue_datagram = 1;
 
   708         } else {
 
   711         } else {
 
   709             eoe->stats.tx_errors++;
 
   712             eoe->stats.tx_errors++;
etherlabmaster