Mercurial Mercurial > etherlabmaster / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
master/slave.c
branchstable-1.5
changeset 2498 9cdd7669dc0b
parent 2467 74ede087bc85
child 2522 ec403cf308eb
equal deleted inserted replaced
2497:505cf41488a4 2498:9cdd7669dc0b 
    66         uint16_t ring_position, /**< ring position */
 
    66         uint16_t ring_position, /**< ring position */
 
    67         uint16_t station_address /**< station address to configure */
 
    67         uint16_t station_address /**< station address to configure */
 
    68         )
 
    68         )
 
    69 {
 
    69 {
 
    70     unsigned int i;
 
    70     unsigned int i;
 
    71     int ret;
 
       
    72 
    71 
    73     slave->master = master;
 
    72     slave->master = master;
 
    74     slave->device_index = dev_idx;
 
    73     slave->device_index = dev_idx;
 
    75     slave->ring_position = ring_position;
 
    74     slave->ring_position = ring_position;
 
    76     slave->station_address = station_address;
 
    75     slave->station_address = station_address;
 
   155     INIT_LIST_HEAD(&slave->sdo_requests);
 
   154     INIT_LIST_HEAD(&slave->sdo_requests);
 
   156     INIT_LIST_HEAD(&slave->reg_requests);
 
   155     INIT_LIST_HEAD(&slave->reg_requests);
 
   157     INIT_LIST_HEAD(&slave->foe_requests);
 
   156     INIT_LIST_HEAD(&slave->foe_requests);
 
   158     INIT_LIST_HEAD(&slave->soe_requests);
 
   157     INIT_LIST_HEAD(&slave->soe_requests);
 
   159 
   158 
   160     // init state machine datagram
 
       
   161     ec_datagram_init(&slave->fsm_datagram);
 
       
   162     snprintf(slave->fsm_datagram.name, EC_DATAGRAM_NAME_SIZE,
 
       
   163             "slave%u-fsm", slave->ring_position);
 
       
   164     ret = ec_datagram_prealloc(&slave->fsm_datagram, EC_MAX_DATA_SIZE);
 
       
   165     if (ret < 0) {
 
       
   166         ec_datagram_clear(&slave->fsm_datagram);
 
       
   167         EC_SLAVE_ERR(slave, "Failed to allocate FSM datagram.\n");
 
       
   168         return;
 
       
   169     }
 
       
   170 
       
   171     // create state machine object
 
   159     // create state machine object
 
   172     ec_fsm_slave_init(&slave->fsm, slave, &slave->fsm_datagram);
 
   160     ec_fsm_slave_init(&slave->fsm, slave);
 
   173 }
 
   161 }
 
   174 
   162 
   175 /*****************************************************************************/
 
   163 /*****************************************************************************/
 
   176 
   164 
   177 /**
 
   165 /**
 
   192             list_entry(slave->sdo_requests.next, ec_sdo_request_t, list);
 
   180             list_entry(slave->sdo_requests.next, ec_sdo_request_t, list);
 
   193         list_del_init(&request->list); // dequeue
 
   181         list_del_init(&request->list); // dequeue
 
   194         EC_SLAVE_WARN(slave, "Discarding SDO request,"
 
   182         EC_SLAVE_WARN(slave, "Discarding SDO request,"
 
   195                 " slave about to be deleted.\n");
 
   183                 " slave about to be deleted.\n");
 
   196         request->state = EC_INT_REQUEST_FAILURE;
 
   184         request->state = EC_INT_REQUEST_FAILURE;
 
   197         wake_up(&slave->master->request_queue);
 
       
   198     }
 
   185     }
 
   199 
   186 
   200     while (!list_empty(&slave->reg_requests)) {
 
   187     while (!list_empty(&slave->reg_requests)) {
 
   201         ec_reg_request_t *reg =
 
   188         ec_reg_request_t *reg =
 
   202             list_entry(slave->reg_requests.next, ec_reg_request_t, list);
 
   189             list_entry(slave->reg_requests.next, ec_reg_request_t, list);
 
   203         list_del_init(&reg->list); // dequeue
 
   190         list_del_init(&reg->list); // dequeue
 
   204         EC_SLAVE_WARN(slave, "Discarding register request,"
 
   191         EC_SLAVE_WARN(slave, "Discarding register request,"
 
   205                 " slave about to be deleted.\n");
 
   192                 " slave about to be deleted.\n");
 
   206         reg->state = EC_INT_REQUEST_FAILURE;
 
   193         reg->state = EC_INT_REQUEST_FAILURE;
 
   207         wake_up(&slave->master->request_queue);
 
       
   208     }
 
   194     }
 
   209 
   195 
   210     while (!list_empty(&slave->foe_requests)) {
 
   196     while (!list_empty(&slave->foe_requests)) {
 
   211         ec_foe_request_t *request =
 
   197         ec_foe_request_t *request =
 
   212             list_entry(slave->foe_requests.next, ec_foe_request_t, list);
 
   198             list_entry(slave->foe_requests.next, ec_foe_request_t, list);
 
   213         list_del_init(&request->list); // dequeue
 
   199         list_del_init(&request->list); // dequeue
 
   214         EC_SLAVE_WARN(slave, "Discarding FoE request,"
 
   200         EC_SLAVE_WARN(slave, "Discarding FoE request,"
 
   215                 " slave about to be deleted.\n");
 
   201                 " slave about to be deleted.\n");
 
   216         request->state = EC_INT_REQUEST_FAILURE;
 
   202         request->state = EC_INT_REQUEST_FAILURE;
 
   217         wake_up(&slave->master->request_queue);
 
       
   218     }
 
   203     }
 
   219 
   204 
   220     while (!list_empty(&slave->soe_requests)) {
 
   205     while (!list_empty(&slave->soe_requests)) {
 
   221         ec_soe_request_t *request =
 
   206         ec_soe_request_t *request =
 
   222             list_entry(slave->soe_requests.next, ec_soe_request_t, list);
 
   207             list_entry(slave->soe_requests.next, ec_soe_request_t, list);
 
   223         list_del_init(&request->list); // dequeue
 
   208         list_del_init(&request->list); // dequeue
 
   224         EC_SLAVE_WARN(slave, "Discarding SoE request,"
 
   209         EC_SLAVE_WARN(slave, "Discarding SoE request,"
 
   225                 " slave about to be deleted.\n");
 
   210                 " slave about to be deleted.\n");
 
   226         request->state = EC_INT_REQUEST_FAILURE;
 
   211         request->state = EC_INT_REQUEST_FAILURE;
 
   227         wake_up(&slave->master->request_queue);
 
   212     }
 
   228     }
 
   213 
       
   214     wake_up_all(&slave->master->request_queue);
 
   229 
   215 
   230     if (slave->config) {
 
   216     if (slave->config) {
 
   231         ec_slave_config_detach(slave->config);
 
   217         ec_slave_config_detach(slave->config);
 
   232     }
 
   218     }
 
   233 
   219 
   258     if (slave->sii_words) {
 
   244     if (slave->sii_words) {
 
   259         kfree(slave->sii_words);
 
   245         kfree(slave->sii_words);
 
   260     }
 
   246     }
 
   261 
   247 
   262     ec_fsm_slave_clear(&slave->fsm);
 
   248     ec_fsm_slave_clear(&slave->fsm);
 
   263     ec_datagram_clear(&slave->fsm_datagram);
 
       
   264 }
 
   249 }
 
   265 
   250 
   266 /*****************************************************************************/
 
   251 /*****************************************************************************/
 
   267 
   252 
   268 /** Clear the sync manager array.
 
   253 /** Clear the sync manager array.
etherlabmaster