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 /*****************************************************************************/ |