master/canopen.c
changeset 646 fbbd4e54e031
parent 484 9fde4a17b820
child 649 a4d3fffdaed7
equal deleted inserted replaced
645:473ec2246ec1 646:fbbd4e54e031
   318     }
   318     }
   319     else if (entry->data_type == 0x0009) { // string
   319     else if (entry->data_type == 0x0009) { // string
   320         off += sprintf(buffer + off, "%s\n", request->data);
   320         off += sprintf(buffer + off, "%s\n", request->data);
   321     }
   321     }
   322     else {
   322     else {
       
   323         off += sprintf(buffer + off,
       
   324                 "Unknown data type %04X, bit size %u. Data:\n",
       
   325                 entry->data_type, entry->bit_length);
   323         for (i = 0; i < request->size; i++)
   326         for (i = 0; i < request->size; i++)
   324             off += sprintf(buffer + off, "%02X (%c)\n",
   327             off += sprintf(buffer + off, "%02X (%c)\n",
   325                            request->data[i], request->data[i]);
   328                            request->data[i], request->data[i]);
   326     }
   329     }
   327 
   330 
   337     ec_sdo_t *sdo = entry->sdo;
   340     ec_sdo_t *sdo = entry->sdo;
   338     ec_master_t *master = sdo->slave->master;
   341     ec_master_t *master = sdo->slave->master;
   339     off_t off = 0;
   342     off_t off = 0;
   340     ec_sdo_request_t request;
   343     ec_sdo_request_t request;
   341 
   344 
   342     if (down_interruptible(&master->sdo_sem)) {
   345     ec_sdo_request_init_read(&request, sdo, entry);
       
   346 
       
   347     // schedule request.
       
   348     down(&master->sdo_sem);
       
   349     list_add_tail(&request.list, &master->sdo_requests);
       
   350     up(&master->sdo_sem);
       
   351 
       
   352     // wait for processing through FSM
       
   353     if (wait_event_interruptible(master->sdo_queue,
       
   354                 request.state != EC_REQ_QUEUED)) {
   343         // interrupted by signal
   355         // interrupted by signal
   344         return -ERESTARTSYS;
   356         down(&master->sdo_sem);
   345     }
   357         if (request.state == EC_REQ_QUEUED) {
   346 
   358             list_del(&request.list);
   347     ec_sdo_request_init_read(&request, sdo, entry);
   359             up(&master->sdo_sem);
   348 
   360             return -EINTR;
   349     // this is necessary, because the completion object
   361         }
   350     // is completed by the ec_master_flush_sdo_requests() function.
   362         // request already processing: interrupt not possible.
   351     INIT_COMPLETION(master->sdo_complete);
   363         up(&master->sdo_sem);
   352 
   364     }
   353     master->sdo_request = &request;
   365 
   354     master->sdo_seq_user++;
   366     // wait until master FSM has finished processing
   355     master->sdo_timer.expires = jiffies + 10;
   367     wait_event(master->sdo_queue, request.state != EC_REQ_BUSY);
   356     add_timer(&master->sdo_timer);
   368 
   357 
   369     if (request.state != EC_REQ_COMPLETED)
   358     wait_for_completion(&master->sdo_complete);
   370         return -EIO;
   359 
   371 
   360     master->sdo_request = NULL;
   372     off += ec_sdo_entry_format_data(entry, &request, buffer);
   361     up(&master->sdo_sem);
       
   362 
       
   363     if (request.return_code == 1 && request.data) {
       
   364         off += ec_sdo_entry_format_data(entry, &request, buffer);
       
   365     }
       
   366     else {
       
   367         off = -EINVAL;
       
   368     }
       
   369 
   373 
   370     ec_sdo_request_clear(&request);
   374     ec_sdo_request_clear(&request);
   371     return off;
   375     return off;
   372 }
   376 }
   373 
   377 
   403 {
   407 {
   404     req->sdo = sdo;
   408     req->sdo = sdo;
   405     req->entry = entry;
   409     req->entry = entry;
   406     req->data = NULL;
   410     req->data = NULL;
   407     req->size = 0;
   411     req->size = 0;
   408     req->return_code = 0;
   412     req->state = EC_REQ_QUEUED;
   409 }
   413 }
   410 
   414 
   411 /*****************************************************************************/
   415 /*****************************************************************************/
   412 
   416 
   413 /**
   417 /**