102 /*****************************************************************************/

   103 

   104 /** Get master information.

   105  */

   106 int ec_cdev_ioctl_master(

   107         ec_master_t *master, /**< EtherCAT master. */

   108         unsigned long arg /**< Userspace address to store the results. */

   109         )

   110 {

   111     ec_ioctl_master_t data;

   112 

   113     down(&master->master_sem);

   114     data.slave_count = master->slave_count;

   115     data.config_count = ec_master_config_count(master);

   116     data.domain_count = ec_master_domain_count(master);

   117     data.phase = (uint8_t) master->phase;

   118     up(&master->master_sem);

   119 

   120     down(&master->device_sem);

   121     memcpy(data.devices[0].address, master->main_mac, ETH_ALEN); 

   122     data.devices[0].attached = master->main_device.dev ? 1 : 0;

   123     data.devices[0].tx_count = master->main_device.tx_count;

   124     data.devices[0].rx_count = master->main_device.rx_count;

   125     memcpy(data.devices[1].address, master->backup_mac, ETH_ALEN); 

   126     data.devices[1].attached = master->backup_device.dev ? 1 : 0;

   127     data.devices[1].tx_count = master->backup_device.tx_count;

   128     data.devices[1].rx_count = master->backup_device.rx_count;

   129     up(&master->device_sem);

   130 

   131     if (copy_to_user((void __user *) arg, &data, sizeof(data)))

   132         return -EFAULT;

   133 

   134     return 0;

   135 }

   136 

   137 /*****************************************************************************/

   138 

   139 /** Get slave information.

   140  */

   141 int ec_cdev_ioctl_slave(

   142         ec_master_t *master, /**< EtherCAT master. */

   143         unsigned long arg /**< Userspace address to store the results. */

   144         )

   145 {

   146     ec_ioctl_slave_t data;

   147     const ec_slave_t *slave;

   148 

   149     if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {

   150         return -EFAULT;

   151     }

   152 

   153     down(&master->master_sem);

   154 

   155     if (!(slave = ec_master_find_slave_const(

   156                     master, 0, data.position))) {

   157         up(&master->master_sem);

   158         EC_ERR("Slave %u does not exist!\n", data.position);

   159         return -EINVAL;

   160     }

   161 

   162     data.vendor_id = slave->sii.vendor_id;

   163     data.product_code = slave->sii.product_code;

   164     data.revision_number = slave->sii.revision_number;

   165     data.serial_number = slave->sii.serial_number;

   166     data.alias = slave->sii.alias;

   167     data.rx_mailbox_offset = slave->sii.rx_mailbox_offset;

   168     data.rx_mailbox_size = slave->sii.rx_mailbox_size;

   169     data.tx_mailbox_offset = slave->sii.tx_mailbox_offset;

   170     data.tx_mailbox_size = slave->sii.tx_mailbox_size;

   171     data.mailbox_protocols = slave->sii.mailbox_protocols;

   172     data.has_general_category = slave->sii.has_general;

   173     data.coe_details = slave->sii.coe_details;

   174     data.general_flags = slave->sii.general_flags;

   175     data.current_on_ebus = slave->sii.current_on_ebus;

   176     data.state = slave->current_state;

   177     data.error_flag = slave->error_flag;

   178 

   179     data.sync_count = slave->sii.sync_count;

   180     data.sdo_count = ec_slave_sdo_count(slave);

   181     data.sii_nwords = slave->sii_nwords;

   182 

   183     if (slave->sii.name) {

   184         strncpy(data.name, slave->sii.name,

   185                 EC_IOCTL_STRING_SIZE);

   186         data.name[EC_IOCTL_STRING_SIZE - 1] = 0;

   187     } else {

   188         data.name[0] = 0;

   189     }

   190 

   191     up(&master->master_sem);

   192 

   193     if (copy_to_user((void __user *) arg, &data, sizeof(data)))

   194         return -EFAULT;

   195 

   196     return 0;

   197 }

   198 

   199 /*****************************************************************************/

   200 

   201 /** Get slave sync manager information.

   202  */

   203 int ec_cdev_ioctl_slave_sync(

   204         ec_master_t *master, /**< EtherCAT master. */

   205         unsigned long arg /**< Userspace address to store the results. */

   206         )

   207 {

   208     ec_ioctl_slave_sync_t data;

   209     const ec_slave_t *slave;

   210     const ec_sync_t *sync;

   211 

   212     if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {

   213         return -EFAULT;

   214     }

   215 

   216     down(&master->master_sem);

   217 

   218     if (!(slave = ec_master_find_slave_const(

   219                     master, 0, data.slave_position))) {

   220         up(&master->master_sem);

   221         EC_ERR("Slave %u does not exist!\n", data.slave_position);

   222         return -EINVAL;

   223     }

   224 

   225     if (data.sync_index >= slave->sii.sync_count) {

   226         up(&master->master_sem);

   227         EC_ERR("Sync manager %u does not exist in slave %u!\n",

   228                 data.sync_index, data.slave_position);

   229         return -EINVAL;

   230     }

   231 

   232     sync = &slave->sii.syncs[data.sync_index];

   233 

   234     data.physical_start_address = sync->physical_start_address;

   235     data.default_size = sync->default_length;

   236     data.control_register = sync->control_register;

   237     data.enable = sync->enable;

   238     data.assign_source = sync->assign_source;

   239     data.pdo_count = ec_pdo_list_count(&sync->pdos);

   240 

   241     up(&master->master_sem);

   242 

   243     if (copy_to_user((void __user *) arg, &data, sizeof(data)))

   244         return -EFAULT;

   245 

   246     return 0;

   247 }

   248 

   249 /*****************************************************************************/

   250 

   251 /** Get slave sync manager Pdo information.

   252  */

   253 int ec_cdev_ioctl_slave_sync_pdo(

   254         ec_master_t *master, /**< EtherCAT master. */

   255         unsigned long arg /**< Userspace address to store the results. */

   256         )

   257 {

   258     ec_ioctl_slave_sync_pdo_t data;

   259     const ec_slave_t *slave;

   260     const ec_sync_t *sync;

   261     const ec_pdo_t *pdo;

   262 

   263     if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {

   264         return -EFAULT;

   265     }

   266 

   267     down(&master->master_sem);

   268 

   269     if (!(slave = ec_master_find_slave_const(

   270                     master, 0, data.slave_position))) {

   271         up(&master->master_sem);

   272         EC_ERR("Slave %u does not exist!\n", data.slave_position);

   273         return -EINVAL;

   274     }

   275 

   276     if (data.sync_index >= slave->sii.sync_count) {

   277         up(&master->master_sem);

   278         EC_ERR("Sync manager %u does not exist in slave %u!\n",

   279                 data.sync_index, data.slave_position);

   280         return -EINVAL;

   281     }

   282 

   283     sync = &slave->sii.syncs[data.sync_index];

   284     if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   285                     &sync->pdos, data.pdo_pos))) {

   286         up(&master->master_sem);

   287         EC_ERR("Sync manager %u does not contain a Pdo with "

   288                 "position %u in slave %u!\n", data.sync_index,

   289                 data.pdo_pos, data.slave_position);

   290         return -EINVAL;

   291     }

   292 

   293     data.index = pdo->index;

   294     data.entry_count = ec_pdo_entry_count(pdo);

   295 

   296     if (pdo->name) {

   297         strncpy(data.name, pdo->name, EC_IOCTL_STRING_SIZE);

   298         data.name[EC_IOCTL_STRING_SIZE - 1] = 0;

   299     } else {

   300         data.name[0] = 0;

   301     }

   302 

   303     up(&master->master_sem);

   304 

   305     if (copy_to_user((void __user *) arg, &data, sizeof(data)))

   306         return -EFAULT;

   307 

   308     return 0;

   309 }

   310 

   311 /*****************************************************************************/

   312 

   313 /** Get slave sync manager Pdo entry information.

   314  */

   315 int ec_cdev_ioctl_slave_sync_pdo_entry(

   316         ec_master_t *master, /**< EtherCAT master. */

   317         unsigned long arg /**< Userspace address to store the results. */

   318         )

   319 {

   320     ec_ioctl_slave_sync_pdo_entry_t data;

   321     const ec_slave_t *slave;

   322     const ec_sync_t *sync;

   323     const ec_pdo_t *pdo;

   324     const ec_pdo_entry_t *entry;

   325 

   326     if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {

   327         return -EFAULT;

   328     }

   329 

   330     down(&master->master_sem);

   331 

   332     if (!(slave = ec_master_find_slave_const(

   333                     master, 0, data.slave_position))) {

   334         up(&master->master_sem);

   335         EC_ERR("Slave %u does not exist!\n", data.slave_position);

   336         return -EINVAL;

   337     }

   338 

   339     if (data.sync_index >= slave->sii.sync_count) {

   340         up(&master->master_sem);

   341         EC_ERR("Sync manager %u does not exist in slave %u!\n",

   342                 data.sync_index, data.slave_position);

   343         return -EINVAL;

   344     }

   345 

   346     sync = &slave->sii.syncs[data.sync_index];

   347     if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   348                     &sync->pdos, data.pdo_pos))) {

   349         up(&master->master_sem);

   350         EC_ERR("Sync manager %u does not contain a Pdo with "

   351                 "position %u in slave %u!\n", data.sync_index,

   352                 data.pdo_pos, data.slave_position);

   353         return -EINVAL;

   354     }

   355 

   356     if (!(entry = ec_pdo_find_entry_by_pos_const(

   357                     pdo, data.entry_pos))) {

   358         up(&master->master_sem);

   359         EC_ERR("Pdo 0x%04X does not contain an entry with "

   360                 "position %u in slave %u!\n", data.pdo_pos,

   361                 data.entry_pos, data.slave_position);

   362         return -EINVAL;

   363     }

   364 

   365     data.index = entry->index;

   366     data.subindex = entry->subindex;

   367     data.bit_length = entry->bit_length;

   368     if (entry->name) {

   369         strncpy(data.name, entry->name, EC_IOCTL_STRING_SIZE);

   370         data.name[EC_IOCTL_STRING_SIZE - 1] = 0;

   371     } else {

   372         data.name[0] = 0;

   373     }

   374 

   375     up(&master->master_sem);

   376 

   377     if (copy_to_user((void __user *) arg, &data, sizeof(data)))

   378         return -EFAULT;

   379 

   380     return 0;

   381 }

   382 

   383 /*****************************************************************************/

   384 

   385 /** Get domain information.

   386  */

   387 int ec_cdev_ioctl_domain(

   388         ec_master_t *master, /**< EtherCAT master. */

   389         unsigned long arg /**< Userspace address to store the results. */

   390         )

   391 {

   392     ec_ioctl_domain_t data;

   393     const ec_domain_t *domain;

   394 

   395     if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {

   396         return -EFAULT;

   397     }

   398 

   399     down(&master->master_sem);

   400 

   401     if (!(domain = ec_master_find_domain_const(master, data.index))) {

   402         up(&master->master_sem);

   403         EC_ERR("Domain %u does not exist!\n", data.index);

   404         return -EINVAL;

   405     }

   406 

   407     data.data_size = domain->data_size;

   408     data.logical_base_address = domain->logical_base_address;

   409     data.working_counter = domain->working_counter;

   410     data.expected_working_counter = domain->expected_working_counter;

   411     data.fmmu_count = ec_domain_fmmu_count(domain);

   412 

   413     up(&master->master_sem);

   414 

   415     if (copy_to_user((void __user *) arg, &data, sizeof(data)))

   416         return -EFAULT;

   417 

   418     return 0;

   419 }

   420 

   421 /*****************************************************************************/

   422 

   423 /** Get domain FMMU information.

   424  */

   425 int ec_cdev_ioctl_domain_fmmu(

   426         ec_master_t *master, /**< EtherCAT master. */

   427         unsigned long arg /**< Userspace address to store the results. */

   428         )

   429 {

   430     ec_ioctl_domain_fmmu_t data;

   431     const ec_domain_t *domain;

   432     const ec_fmmu_config_t *fmmu;

   433 

   434     if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {

   435         return -EFAULT;

   436     }

   437 

   438     down(&master->master_sem);

   439 

   440     if (!(domain = ec_master_find_domain_const(master, data.domain_index))) {

   441         up(&master->master_sem);

   442         EC_ERR("Domain %u does not exist!\n", data.domain_index);

   443         return -EINVAL;

   444     }

   445 

   446     if (!(fmmu = ec_domain_find_fmmu(domain, data.fmmu_index))) {

   447         up(&master->master_sem);

   448         EC_ERR("Domain %u has less than %u fmmu configurations.\n",

   449                 data.domain_index, data.fmmu_index + 1);

   450         return -EINVAL;

   451     }

   452 

   453     data.slave_config_alias = fmmu->sc->alias;

   454     data.slave_config_position = fmmu->sc->position;

   455     data.sync_index = fmmu->sync_index;

   456     data.dir = fmmu->dir;

   457     data.logical_address = fmmu->logical_start_address;

   458     data.data_size = fmmu->data_size;

   459 

   460     up(&master->master_sem);

   461 

   462     if (copy_to_user((void __user *) arg, &data, sizeof(data)))

   463         return -EFAULT;

   464 

   465     return 0;

   466 }

   467 

   468 /*****************************************************************************/

   469 

   470 /** Get domain data.

   471  */

   472 int ec_cdev_ioctl_domain_data(

   473         ec_master_t *master, /**< EtherCAT master. */

   474         unsigned long arg /**< Userspace address to store the results. */

   475         )

   476 {

   477     ec_ioctl_domain_data_t data;

   478     const ec_domain_t *domain;

   479 

   480     if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {

   481         return -EFAULT;

   482     }

   483 

   484     down(&master->master_sem);

   485 

   486     if (!(domain = ec_master_find_domain_const(master, data.domain_index))) {

   487         up(&master->master_sem);

   488         EC_ERR("Domain %u does not exist!\n", data.domain_index);

   489         return -EINVAL;

   490     }

   491 

   492     if (domain->data_size != data.data_size) {

   493         up(&master->master_sem);

   494         EC_ERR("Data size mismatch %u/%u!\n",

   495                 data.data_size, domain->data_size);

   496         return -EFAULT;

   497     }

   498 

   499     if (copy_to_user((void __user *) data.target, domain->data,

   500                 domain->data_size))

   501         return -EFAULT;

   502 

   503     up(&master->master_sem);

   504     return 0;

   505 }

   506 

   507 /*****************************************************************************/

   508 

   509 /** Set master debug level.

   510  */

   511 int ec_cdev_ioctl_master_debug(

   512         ec_master_t *master, /**< EtherCAT master. */

   513         unsigned long arg /**< ioctl() argument. */

   514         )

   515 {

   516     if (ec_master_debug_level(master, (unsigned int) arg))

   517         return -EINVAL;

   518 

   519     return 0;

   520 }

   521 

   522 /*****************************************************************************/

   523 

   524 /** Set slave state.

   525  */

   526 int ec_cdev_ioctl_slave_state(

   527         ec_master_t *master, /**< EtherCAT master. */

   528         unsigned long arg /**< ioctl() argument. */

   529         )

   530 {

   531     ec_ioctl_slave_state_t data;

   532     ec_slave_t *slave;

   533 

   534     if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {

   535         return -EFAULT;

   536     }

   537 

   538     down(&master->master_sem);

   539 

   540     if (!(slave = ec_master_find_slave(

   541                     master, 0, data.slave_position))) {

   542         EC_ERR("Slave %u does not exist!\n", data.slave_position);

   543         return -EINVAL;

   544     }

   545 

   546     ec_slave_request_state(slave, data.requested_state);

   547 

   548     up(&master->master_sem);

   549     return 0;

   550 }

   551 

   552 /*****************************************************************************/

   553 

   554 /** Get slave Sdo information.

   555  */

   556 int ec_cdev_ioctl_slave_sdo(

   557         ec_master_t *master, /**< EtherCAT master. */

   558         unsigned long arg /**< ioctl() argument. */

   559         )

   560 {

   561     ec_ioctl_slave_sdo_t data;

   562     const ec_slave_t *slave;

   563     const ec_sdo_t *sdo;

   564 

   565     if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {

   566         return -EFAULT;

   567     }

   568 

   569     down(&master->master_sem);

   570 

   571     if (!(slave = ec_master_find_slave_const(

   572                     master, 0, data.slave_position))) {

   573         up(&master->master_sem);

   574         EC_ERR("Slave %u does not exist!\n", data.slave_position);

   575         return -EINVAL;

   576     }

   577 

   578     if (!(sdo = ec_slave_get_sdo_by_pos_const(

   579                     slave, data.sdo_position))) {

   580         up(&master->master_sem);

   581         EC_ERR("Sdo %u does not exist in slave %u!\n",

   582                 data.sdo_position, data.slave_position);

   583         return -EINVAL;

   584     }

   585 

   586     data.sdo_index = sdo->index;

   587     data.max_subindex = sdo->max_subindex;

   588 

   589     if (sdo->name) {

   590         strncpy(data.name, sdo->name, EC_IOCTL_STRING_SIZE);

   591         data.name[EC_IOCTL_STRING_SIZE - 1] = 0;

   592     } else {

   593         data.name[0] = 0;

   594     }

   595 

   596     up(&master->master_sem);

   597 

   598     if (copy_to_user((void __user *) arg, &data, sizeof(data)))

   599         return -EFAULT;

   600 

   601     return 0;

   602 }

   603 

   604 /*****************************************************************************/

   605 

   606 /** Get slave Sdo entry information.

   607  */

   608 int ec_cdev_ioctl_slave_sdo_entry(

   609         ec_master_t *master, /**< EtherCAT master. */

   610         unsigned long arg /**< ioctl() argument. */

   611         )

   612 {

   613     ec_ioctl_slave_sdo_entry_t data;

   614     const ec_slave_t *slave;

   615     const ec_sdo_t *sdo;

   616     const ec_sdo_entry_t *entry;

   617 

   618     if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {

   619         return -EFAULT;

   620     }

   621 

   622     down(&master->master_sem);

   623 

   624     if (!(slave = ec_master_find_slave_const(

   625                     master, 0, data.slave_position))) {

   626         up(&master->master_sem);

   627         EC_ERR("Slave %u does not exist!\n", data.slave_position);

   628         return -EINVAL;

   629     }

   630 

   631     if (data.sdo_spec <= 0) {

   632         if (!(sdo = ec_slave_get_sdo_by_pos_const(

   633                         slave, -data.sdo_spec))) {

   634             up(&master->master_sem);

   635             EC_ERR("Sdo %u does not exist in slave %u!\n",

   636                     -data.sdo_spec, data.slave_position);

   637             return -EINVAL;

   638         }

   639     } else {

   640         if (!(sdo = ec_slave_get_sdo_const(

   641                         slave, data.sdo_spec))) {

   642             up(&master->master_sem);

   643             EC_ERR("Sdo 0x%04X does not exist in slave %u!\n",

   644                     data.sdo_spec, data.slave_position);

   645             return -EINVAL;

   646         }

   647     }

   648 

   649     if (!(entry = ec_sdo_get_entry_const(

   650                     sdo, data.sdo_entry_subindex))) {

   651         up(&master->master_sem);

   652         EC_ERR("Sdo entry 0x%04X:%02X does not exist "

   653                 "in slave %u!\n", sdo->index,

   654                 data.sdo_entry_subindex, data.slave_position);

   655         return -EINVAL;

   656     }

   657 

   658     data.data_type = entry->data_type;

   659     data.bit_length = entry->bit_length;

   660 

   661     if (entry->description) {

   662         strncpy(data.description, entry->description,

   663                 EC_IOCTL_STRING_SIZE);

   664         data.description[EC_IOCTL_STRING_SIZE - 1]

   665             = 0;

   666     } else {

   667         data.description[0] = 0;

   668     }

   669 

   670     up(&master->master_sem);

   671 

   672     if (copy_to_user((void __user *) arg, &data, sizeof(data)))

   673         return -EFAULT;

   674 

   675     return 0;

   676 }

   677 

   678 /*****************************************************************************/

   679 

   680 /** Upload Sdo.

   681  */

   682 int ec_cdev_ioctl_slave_sdo_upload(

   683         ec_master_t *master, /**< EtherCAT master. */

   684         unsigned long arg /**< ioctl() argument. */

   685         )

   686 {

   687     ec_ioctl_slave_sdo_upload_t data;

   688     ec_master_sdo_request_t request;

   689     int retval;

   690 

   691     if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {

   692         return -EFAULT;

   693     }

   694 

   695     ec_sdo_request_init(&request.req);

   696     ec_sdo_request_address(&request.req,

   697             data.sdo_index, data.sdo_entry_subindex);

   698     ecrt_sdo_request_read(&request.req);

   699 

   700     down(&master->master_sem);

   701 

   702     if (!(request.slave = ec_master_find_slave(

   703                     master, 0, data.slave_position))) {

   704         up(&master->master_sem);

   705         ec_sdo_request_clear(&request.req);

   706         EC_ERR("Slave %u does not exist!\n", data.slave_position);

   707         return -EINVAL;

   708     }

   709 

   710     // schedule request.

   711     list_add_tail(&request.list, &master->slave_sdo_requests);

   712 

   713     up(&master->master_sem);

   714 

   715     // wait for processing through FSM

   716     if (wait_event_interruptible(master->sdo_queue,

   717                 request.req.state != EC_REQUEST_QUEUED)) {

   718         // interrupted by signal

   719         down(&master->master_sem);

   720         if (request.req.state == EC_REQUEST_QUEUED) {

   721             list_del(&request.req.list);

   722             up(&master->master_sem);

   723             ec_sdo_request_clear(&request.req);

   724             return -EINTR;

   725         }

   726         // request already processing: interrupt not possible.

   727         up(&master->master_sem);

   728     }

   729 

   730     // wait until master FSM has finished processing

   731     wait_event(master->sdo_queue, request.req.state != EC_REQUEST_BUSY);

   732 

   733     data.abort_code = request.req.abort_code;

   734 

   735     if (request.req.state != EC_REQUEST_SUCCESS) {

   736         data.data_size = 0;

   737         retval = -EIO;

   738     } else {

   739         if (request.req.data_size > data.target_size) {

   740             EC_ERR("Buffer too small.\n");

   741             ec_sdo_request_clear(&request.req);

   742             return -EOVERFLOW;

   743         }

   744         data.data_size = request.req.data_size;

   745 

   746         if (copy_to_user((void __user *) data.target,

   747                     request.req.data, data.data_size)) {

   748             ec_sdo_request_clear(&request.req);

   749             return -EFAULT;

   750         }

   751         retval = 0;

   752     }

   753 

   754     if (__copy_to_user((void __user *) arg, &data, sizeof(data))) {

   755         retval = -EFAULT;

   756     }

   757 

   758     ec_sdo_request_clear(&request.req);

   759     return retval;

   760 }

   761 

   762 /*****************************************************************************/

   763 

   764 /** Download Sdo.

   765  */

   766 int ec_cdev_ioctl_slave_sdo_download(

   767         ec_master_t *master, /**< EtherCAT master. */

   768         unsigned long arg /**< ioctl() argument. */

   769         )

   770 {

   771     ec_ioctl_slave_sdo_download_t data;

   772     ec_master_sdo_request_t request;

   773     int retval;

   774 

   775     if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {

   776         return -EFAULT;

   777     }

   778 

   779     // copy data to download

   780     if (!data.data_size) {

   781         EC_ERR("Zero data size!\n");

   782         return -EINVAL;

   783     }

   784 

   785     ec_sdo_request_init(&request.req);

   786     ec_sdo_request_address(&request.req,

   787             data.sdo_index, data.sdo_entry_subindex);

   788     if (ec_sdo_request_alloc(&request.req, data.data_size)) {

   789         ec_sdo_request_clear(&request.req);

   790         return -ENOMEM;

   791     }

   792     if (copy_from_user(request.req.data,

   793                 (void __user *) data.data, data.data_size)) {

   794         ec_sdo_request_clear(&request.req);

   795         return -EFAULT;

   796     }

   797     request.req.data_size = data.data_size;

   798     ecrt_sdo_request_write(&request.req);

   799 

   800 

   801     down(&master->master_sem);

   802 

   803     if (!(request.slave = ec_master_find_slave(

   804                     master, 0, data.slave_position))) {

   805         up(&master->master_sem);

   806         EC_ERR("Slave %u does not exist!\n", data.slave_position);

   807         ec_sdo_request_clear(&request.req);

   808         return -EINVAL;

   809     }

   810     

   811     // schedule request.

   812     list_add_tail(&request.list, &master->slave_sdo_requests);

   813 

   814     up(&master->master_sem);

   815 

   816     // wait for processing through FSM

   817     if (wait_event_interruptible(master->sdo_queue,

   818                 request.req.state != EC_REQUEST_QUEUED)) {

   819         // interrupted by signal

   820         down(&master->master_sem);

   821         if (request.req.state == EC_REQUEST_QUEUED) {

   822             list_del(&request.req.list);

   823             up(&master->master_sem);

   824             ec_sdo_request_clear(&request.req);

   825             return -EINTR;

   826         }

   827         // request already processing: interrupt not possible.

   828         up(&master->master_sem);

   829     }

   830 

   831     // wait until master FSM has finished processing

   832     wait_event(master->sdo_queue, request.req.state != EC_REQUEST_BUSY);

   833 

   834     data.abort_code = request.req.abort_code;

   835 

   836     retval = request.req.state == EC_REQUEST_SUCCESS ? 0 : -EIO;

   837 

   838     if (__copy_to_user((void __user *) arg, &data, sizeof(data))) {

   839         retval = -EFAULT;

   840     }

   841 

   842     ec_sdo_request_clear(&request.req);

   843     return retval;

   844 }

   845 

   846 /*****************************************************************************/

   847 

   848 /** Read a slave's SII.

   849  */

   850 int ec_cdev_ioctl_slave_sii_read(

   851         ec_master_t *master, /**< EtherCAT master. */

   852         unsigned long arg /**< ioctl() argument. */

   853         )

   854 {

   855     ec_ioctl_slave_sii_t data;

   856     const ec_slave_t *slave;

   857     int retval;

   858 

   859     if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {

   860         return -EFAULT;

   861     }

   862 

   863     down(&master->master_sem);

   864 

   865     if (!(slave = ec_master_find_slave_const(

   866                     master, 0, data.slave_position))) {

   867         up(&master->master_sem);

   868         EC_ERR("Slave %u does not exist!\n", data.slave_position);

   869         return -EINVAL;

   870     }

   871 

   872     if (!data.nwords

   873             || data.offset + data.nwords > slave->sii_nwords) {

   874         up(&master->master_sem);

   875         EC_ERR("Invalid SII read offset/size %u/%u for slave "

   876                 "SII size %u!\n", data.offset,

   877                 data.nwords, slave->sii_nwords);

   878         return -EINVAL;

   879     }

   880 

   881     if (copy_to_user((void __user *) data.words,

   882                 slave->sii_words + data.offset, data.nwords * 2))

   883         retval = -EFAULT;

   884     else

   885         retval = 0;

   886 

   887     up(&master->master_sem);

   888     return retval;

   889 }

   890 

   891 /*****************************************************************************/

   892 

   893 /** Write a slave's SII.

   894  */

   895 int ec_cdev_ioctl_slave_sii_write(

   896         ec_master_t *master, /**< EtherCAT master. */

   897         unsigned long arg /**< ioctl() argument. */

   898         )

   899 {

   900     ec_ioctl_slave_sii_t data;

   901     ec_slave_t *slave;

   902     unsigned int byte_size;

   903     uint16_t *words;

   904     ec_sii_write_request_t request;

   905 

   906     if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {

   907         return -EFAULT;

   908     }

   909 

   910     if (!data.nwords)

   911         return 0;

   912 

   913     byte_size = sizeof(uint16_t) * data.nwords;

   914     if (!(words = kmalloc(byte_size, GFP_KERNEL))) {

   915         EC_ERR("Failed to allocate %u bytes for SII contents.\n",

   916                 byte_size);

   917         return -ENOMEM;

   918     }

   919 

   920     if (copy_from_user(words,

   921                 (void __user *) data.words, byte_size)) {

   922         kfree(words);

   923         return -EFAULT;

   924     }

   925 

   926     down(&master->master_sem);

   927 

   928     if (!(slave = ec_master_find_slave(

   929                     master, 0, data.slave_position))) {

   930         up(&master->master_sem);

   931         EC_ERR("Slave %u does not exist!\n", data.slave_position);

   932         kfree(words);

   933         return -EINVAL;

   934     }

   935 

   936     // init SII write request

   937     INIT_LIST_HEAD(&request.list);

   938     request.slave = slave;

   939     request.words = words;

   940     request.offset = data.offset;

   941     request.nwords = data.nwords;

   942     request.state = EC_REQUEST_QUEUED;

   943 

   944     // schedule SII write request.

   945     list_add_tail(&request.list, &master->sii_requests);

   946 

   947     up(&master->master_sem);

   948 

   949     // wait for processing through FSM

   950     if (wait_event_interruptible(master->sii_queue,

   951                 request.state != EC_REQUEST_QUEUED)) {

   952         // interrupted by signal

   953         down(&master->master_sem);

   954         if (request.state == EC_REQUEST_QUEUED) {

   955             // abort request

   956             list_del(&request.list);

   957             up(&master->master_sem);

   958             kfree(words);

   959             return -EINTR;

   960         }

   961         up(&master->master_sem);

   962     }

   963 

   964     // wait until master FSM has finished processing

   965     wait_event(master->sii_queue, request.state != EC_REQUEST_BUSY);

   966 

   967     kfree(words);

   968 

   969     return request.state == EC_REQUEST_SUCCESS ? 0 : -EIO;

   970 }

   971 

   972 /*****************************************************************************/

   973 

   974 /** Get slave configuration information.

   975  */

   976 int ec_cdev_ioctl_config(

   977         ec_master_t *master, /**< EtherCAT master. */

   978         unsigned long arg /**< ioctl() argument. */

   979         )

   980 {

   981     ec_ioctl_config_t data;

   982     const ec_slave_config_t *sc;

   983     uint8_t i;

   984 

   985     if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {

   986         return -EFAULT;

   987     }

   988 

   989     down(&master->master_sem);

   990 

   991     if (!(sc = ec_master_get_config_const(

   992                     master, data.config_index))) {

   993         up(&master->master_sem);

   994         EC_ERR("Slave config %u does not exist!\n",

   995                 data.config_index);

   996         return -EINVAL;

   997     }

   998 

   999     data.alias = sc->alias;

  1000     data.position = sc->position;

  1001     data.vendor_id = sc->vendor_id;

  1002     data.product_code = sc->product_code;

  1003     for (i = 0; i < EC_MAX_SYNCS; i++) {

  1004         data.syncs[i].dir = sc->sync_configs[i].dir;

  1005         data.syncs[i].pdo_count =

  1006             ec_pdo_list_count(&sc->sync_configs[i].pdos);

  1007     }

  1008     data.sdo_count = ec_slave_config_sdo_count(sc);

  1009     data.attached = sc->slave != NULL;

  1010     data.operational = sc->slave &&

  1011         sc->slave->current_state == EC_SLAVE_STATE_OP;

  1012 

  1013     up(&master->master_sem);

  1014 

  1015     if (copy_to_user((void __user *) arg, &data, sizeof(data)))

  1016         return -EFAULT;

  1017 

  1018     return 0;

  1019 }

  1020 

  1021 /*****************************************************************************/

  1022 

  1023 /** Get slave configuration Pdo information.

  1024  */

  1025 int ec_cdev_ioctl_config_pdo(

  1026         ec_master_t *master, /**< EtherCAT master. */

  1027         unsigned long arg /**< ioctl() argument. */

  1028         )

  1029 {

  1030     ec_ioctl_config_pdo_t data;

  1031     const ec_slave_config_t *sc;

  1032     const ec_pdo_t *pdo;

  1033 

  1034     if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {

  1035         return -EFAULT;

  1036     }

  1037 

  1038     if (data.sync_index >= EC_MAX_SYNCS) {

  1039         EC_ERR("Invalid sync manager index %u!\n",

  1040                 data.sync_index);

  1041         return -EINVAL;

  1042     }

  1043 

  1044     down(&master->master_sem);

  1045 

  1046     if (!(sc = ec_master_get_config_const(

  1047                     master, data.config_index))) {

  1048         up(&master->master_sem);

  1049         EC_ERR("Slave config %u does not exist!\n",

  1050                 data.config_index);

  1051         return -EINVAL;

  1052     }

  1053 

  1054     if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

  1055                     &sc->sync_configs[data.sync_index].pdos,

  1056                     data.pdo_pos))) {

  1057         up(&master->master_sem);

  1058         EC_ERR("Invalid Pdo position!\n");

  1059         return -EINVAL;

  1060     }

  1061 

  1062     data.index = pdo->index;

  1063     data.entry_count = ec_pdo_entry_count(pdo);

  1064 

  1065     if (pdo->name) {

  1066         strncpy(data.name, pdo->name, EC_IOCTL_STRING_SIZE);

  1067         data.name[EC_IOCTL_STRING_SIZE - 1] = 0;

  1068     } else {

  1069         data.name[0] = 0;

  1070     }

  1071 

  1072     up(&master->master_sem);

  1073 

  1074     if (copy_to_user((void __user *) arg, &data, sizeof(data)))

  1075         return -EFAULT;

  1076 

  1077     return 0;

  1078 }

  1079 

  1080 /*****************************************************************************/

  1081 

  1082 /** Get slave configuration Pdo entry information.

  1083  */

  1084 int ec_cdev_ioctl_config_pdo_entry(

  1085         ec_master_t *master, /**< EtherCAT master. */

  1086         unsigned long arg /**< ioctl() argument. */

  1087         )

  1088 {

  1089     ec_ioctl_config_pdo_entry_t data;

  1090     const ec_slave_config_t *sc;

  1091     const ec_pdo_t *pdo;

  1092     const ec_pdo_entry_t *entry;

  1093 

  1094     if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {

  1095         return -EFAULT;

  1096     }

  1097 

  1098     if (data.sync_index >= EC_MAX_SYNCS) {

  1099         EC_ERR("Invalid sync manager index %u!\n",

  1100                 data.sync_index);

  1101         return -EINVAL;

  1102     }

  1103 

  1104     down(&master->master_sem);

  1105 

  1106     if (!(sc = ec_master_get_config_const(

  1107                     master, data.config_index))) {

  1108         up(&master->master_sem);

  1109         EC_ERR("Slave config %u does not exist!\n",

  1110                 data.config_index);

  1111         return -EINVAL;

  1112     }

  1113 

  1114     if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

  1115                     &sc->sync_configs[data.sync_index].pdos,

  1116                     data.pdo_pos))) {

  1117         up(&master->master_sem);

  1118         EC_ERR("Invalid Pdo position!\n");

  1119         return -EINVAL;

  1120     }

  1121 

  1122     if (!(entry = ec_pdo_find_entry_by_pos_const(

  1123                     pdo, data.entry_pos))) {

  1124         up(&master->master_sem);

  1125         EC_ERR("Entry not found!\n");

  1126         return -EINVAL;

  1127     }

  1128 

  1129     data.index = entry->index;

  1130     data.subindex = entry->subindex;

  1131     data.bit_length = entry->bit_length;

  1132     if (entry->name) {

  1133         strncpy(data.name, entry->name, EC_IOCTL_STRING_SIZE);

  1134         data.name[EC_IOCTL_STRING_SIZE - 1] = 0;

  1135     } else {

  1136         data.name[0] = 0;

  1137     }

  1138 

  1139     up(&master->master_sem);

  1140 

  1141     if (copy_to_user((void __user *) arg, &data, sizeof(data)))

  1142         return -EFAULT;

  1143 

  1144     return 0;

  1145 }

  1146 

  1147 /*****************************************************************************/

  1148 

  1149 /** Get slave configuration Sdo information.

  1150  */

  1151 int ec_cdev_ioctl_config_sdo(

  1152         ec_master_t *master, /**< EtherCAT master. */

  1153         unsigned long arg /**< ioctl() argument. */

  1154         )

  1155 {

  1156     ec_ioctl_config_sdo_t data;

  1157     const ec_slave_config_t *sc;

  1158     const ec_sdo_request_t *req;

  1159 

  1160     if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {

  1161         return -EFAULT;

  1162     }

  1163 

  1164     down(&master->master_sem);

  1165 

  1166     if (!(sc = ec_master_get_config_const(

  1167                     master, data.config_index))) {

  1168         up(&master->master_sem);

  1169         EC_ERR("Slave config %u does not exist!\n",

  1170                 data.config_index);

  1171         return -EINVAL;

  1172     }

  1173 

  1174     if (!(req = ec_slave_config_get_sdo_by_pos_const(

  1175                     sc, data.sdo_pos))) {

  1176         up(&master->master_sem);

  1177         EC_ERR("Invalid Sdo position!\n");

  1178         return -EINVAL;

  1179     }

  1180 

  1181     data.index = req->index;

  1182     data.subindex = req->subindex;

  1183     data.size = req->data_size;

  1184     memcpy(&data.data, req->data, min((u32) data.size, (u32) 4));

  1185 

  1186     up(&master->master_sem);

  1187 

  1188     if (copy_to_user((void __user *) arg, &data, sizeof(data)))

  1189         return -EFAULT;

  1190 

  1191     return 0;

  1192 }

  1193