master/fsm_master.c
changeset 2031 7a025a9e192d
parent 2030 2bd8ad8bf41f
child 2032 57c618557912
equal deleted inserted replaced
2030:2bd8ad8bf41f 2031:7a025a9e192d
   389         if (request->length > fsm->datagram->mem_size) {
   389         if (request->length > fsm->datagram->mem_size) {
   390             EC_MASTER_ERR(master, "Request length (%zu) exceeds maximum "
   390             EC_MASTER_ERR(master, "Request length (%zu) exceeds maximum "
   391                     "datagram size (%zu)!\n", request->length,
   391                     "datagram size (%zu)!\n", request->length,
   392                     fsm->datagram->mem_size);
   392                     fsm->datagram->mem_size);
   393             request->state = EC_INT_REQUEST_FAILURE;
   393             request->state = EC_INT_REQUEST_FAILURE;
       
   394             kref_put(&request->refcount,ec_master_reg_request_release);
   394             wake_up(&master->reg_queue);
   395             wake_up(&master->reg_queue);
   395             continue;
   396             continue;
   396         }
   397         }
   397 
   398 
   398         fsm->reg_request = request;
   399         fsm->reg_request = request;
  1189     if (datagram->state != EC_DATAGRAM_RECEIVED) {
  1190     if (datagram->state != EC_DATAGRAM_RECEIVED) {
  1190         EC_MASTER_ERR(master, "Failed to receive register"
  1191         EC_MASTER_ERR(master, "Failed to receive register"
  1191                 " request datagram: ");
  1192                 " request datagram: ");
  1192         ec_datagram_print_state(datagram);
  1193         ec_datagram_print_state(datagram);
  1193         request->state = EC_INT_REQUEST_FAILURE;
  1194         request->state = EC_INT_REQUEST_FAILURE;
       
  1195         kref_put(&request->refcount,ec_master_reg_request_release);
  1194         wake_up(&master->reg_queue);
  1196         wake_up(&master->reg_queue);
  1195         ec_fsm_master_restart(fsm);
  1197         ec_fsm_master_restart(fsm);
  1196         return;
  1198         return;
  1197     }
  1199     }
  1198 
  1200 
  1203             request->data = kmalloc(request->length, GFP_KERNEL);
  1205             request->data = kmalloc(request->length, GFP_KERNEL);
  1204             if (!request->data) {
  1206             if (!request->data) {
  1205                 EC_MASTER_ERR(master, "Failed to allocate %zu bytes"
  1207                 EC_MASTER_ERR(master, "Failed to allocate %zu bytes"
  1206                         " of memory for register data.\n", request->length);
  1208                         " of memory for register data.\n", request->length);
  1207                 request->state = EC_INT_REQUEST_FAILURE;
  1209                 request->state = EC_INT_REQUEST_FAILURE;
       
  1210                 kref_put(&request->refcount,ec_master_reg_request_release);
  1208                 wake_up(&master->reg_queue);
  1211                 wake_up(&master->reg_queue);
  1209                 ec_fsm_master_restart(fsm);
  1212                 ec_fsm_master_restart(fsm);
  1210                 return;
  1213                 return;
  1211             }
  1214             }
  1212             memcpy(request->data, datagram->data, request->length);
  1215             memcpy(request->data, datagram->data, request->length);
  1217     } else {
  1220     } else {
  1218         request->state = EC_INT_REQUEST_FAILURE;
  1221         request->state = EC_INT_REQUEST_FAILURE;
  1219         EC_MASTER_ERR(master, "Register request failed.\n");
  1222         EC_MASTER_ERR(master, "Register request failed.\n");
  1220     }
  1223     }
  1221 
  1224 
       
  1225     kref_put(&request->refcount,ec_master_reg_request_release);
  1222     wake_up(&master->reg_queue);
  1226     wake_up(&master->reg_queue);
  1223 
  1227 
  1224     // check for another register request
  1228     // check for another register request
  1225     if (ec_fsm_master_action_process_register(fsm))
  1229     if (ec_fsm_master_action_process_register(fsm))
  1226         return; // processing another request
  1230         return; // processing another request
  1241     kfree(request);
  1245     kfree(request);
  1242 }
  1246 }
  1243 
  1247 
  1244 /*****************************************************************************/
  1248 /*****************************************************************************/
  1245 
  1249 
       
  1250 /** called by kref_put if the reg request's refcount becomes zero.
       
  1251  *
       
  1252  */
       
  1253 void ec_master_reg_request_release(struct kref *ref)
       
  1254 {
       
  1255     ec_reg_request_t *request = container_of(ref, ec_reg_request_t, refcount);
       
  1256     EC_SLAVE_DBG(request->slave, 1, "Releasing reg request %p.\n",request);
       
  1257     if (request->data)
       
  1258         kfree(request->data);
       
  1259     kfree(request);
       
  1260 }
       
  1261 
       
  1262 /*****************************************************************************/
       
  1263 
  1246 /** called by kref_put if the SDO request's refcount becomes zero.
  1264 /** called by kref_put if the SDO request's refcount becomes zero.
  1247  *
  1265  *
  1248  */
  1266  */
  1249 void ec_master_sdo_request_release(struct kref *ref)
  1267 void ec_master_sdo_request_release(struct kref *ref)
  1250 {
  1268 {