master/sdo_request.c
changeset 854 f4f53be425ac
parent 852 ab439cbc7a81
child 858 69122084d066
equal deleted inserted replaced
853:726326d0aef4 854:f4f53be425ac
    53 void ec_sdo_request_init(
    53 void ec_sdo_request_init(
    54         ec_sdo_request_t *req /**< Sdo request. */
    54         ec_sdo_request_t *req /**< Sdo request. */
    55         )
    55         )
    56 {
    56 {
    57     req->data = NULL;
    57     req->data = NULL;
    58     req->size = 0;
    58     req->mem_size = 0;
       
    59     req->data_size = 0;
    59     req->state = EC_REQUEST_COMPLETE;
    60     req->state = EC_REQUEST_COMPLETE;
    60 }
    61 }
    61 
    62 
    62 /*****************************************************************************/
    63 /*****************************************************************************/
    63 
    64 
    81     if (req->data) {
    82     if (req->data) {
    82         kfree(req->data);
    83         kfree(req->data);
    83         req->data = NULL;
    84         req->data = NULL;
    84     }
    85     }
    85 
    86 
    86     req->size = 0;
    87     req->mem_size = 0;
       
    88     req->data_size = 0;
    87 }
    89 }
    88 
    90 
    89 /*****************************************************************************/
    91 /*****************************************************************************/
    90 
    92 
    91 /** Start an Sdo read operation (download).
    93 /** Set the Sdo address.
    92  */
    94  */
    93 void ec_sdo_request_read(
    95 void ec_sdo_request_address(
    94         ec_sdo_request_t *req, /**< Sdo request. */
    96         ec_sdo_request_t *req, /**< Sdo request. */
    95         uint16_t index, /**< Sdo index. */
    97         uint16_t index, /**< Sdo index. */
    96         uint8_t subindex /**< Sdo subindex. */
    98         uint8_t subindex /**< Sdo subindex. */
    97         )
    99         )
    98 {
   100 {
    99     req->index = index;
   101     req->index = index;
   100     req->subindex = subindex;
   102     req->subindex = subindex;
   101     req->state = EC_REQUEST_QUEUED;
       
   102 
       
   103     ec_sdo_request_clear_data(req);
       
   104 }
   103 }
   105 
   104 
   106 /*****************************************************************************/
   105 /*****************************************************************************/
       
   106 
       
   107 /** Pre-allocates the data memory.
       
   108  *
       
   109  * If the \a mem_size is already bigger than \a size, nothing is done.
       
   110  */
       
   111 int ec_sdo_request_alloc(
       
   112         ec_sdo_request_t *req, /**< Sdo request. */
       
   113         size_t size /**< Data size to allocate. */
       
   114         )
       
   115 {
       
   116     if (size <= req->mem_size)
       
   117         return 0;
       
   118 
       
   119     ec_sdo_request_clear_data(req);
       
   120 
       
   121     if (!(req->data = (uint8_t *) kmalloc(size, GFP_KERNEL))) {
       
   122         EC_ERR("Failed to allocate %u bytes of Sdo memory.\n", size);
       
   123         return -1;
       
   124     }
       
   125 
       
   126     req->mem_size = size;
       
   127     req->data_size = 0;
       
   128     return 0;
       
   129 }
       
   130 
       
   131 /*****************************************************************************/
       
   132 
       
   133 /** Copies Sdo data from an external source.
       
   134  *
       
   135  * If the \a mem_size is to small, new memory is allocated.
       
   136  */
       
   137 int ec_sdo_request_copy_data(
       
   138         ec_sdo_request_t *req, /**< Sdo request. */
       
   139         const uint8_t *source, /**< Source data. */
       
   140         size_t size /**< Number of bytes in \a source. */
       
   141         )
       
   142 {
       
   143     if (ec_sdo_request_alloc(req, size))
       
   144         return -1;
       
   145 
       
   146     memcpy(req->data, source, size);
       
   147     req->data_size = size;
       
   148     return 0;
       
   149 }
       
   150 
       
   151 /*****************************************************************************/
       
   152 
       
   153 /** Start an Sdo read operation (Sdo upload).
       
   154  */
       
   155 void ec_sdo_request_read(
       
   156         ec_sdo_request_t *req /**< Sdo request. */
       
   157         )
       
   158 {
       
   159     req->state = EC_REQUEST_QUEUED;
       
   160 }
       
   161 
       
   162 /*****************************************************************************/
       
   163 
       
   164 /** Start an Sdo write operation (Sdo download).
       
   165  */
       
   166 void ec_sdo_request_write(
       
   167         ec_sdo_request_t *req /**< Sdo request. */
       
   168         )
       
   169 {
       
   170     req->state = EC_REQUEST_QUEUED;
       
   171 }
       
   172 
       
   173 /*****************************************************************************/