master/cdev.c
changeset 1108 7beba3e7e6b4
parent 1092 69393cf60399
child 1109 11ac4051db6b
equal deleted inserted replaced
1107:fccab40a5916 1108:7beba3e7e6b4
    99     cdev_del(&cdev->cdev);
    99     cdev_del(&cdev->cdev);
   100 }
   100 }
   101 
   101 
   102 /*****************************************************************************/
   102 /*****************************************************************************/
   103 
   103 
       
   104 /** Copies a string to an ioctl structure.
       
   105  */
       
   106 void ec_cdev_strcpy(
       
   107         char *target, /**< Target. */
       
   108         const char *source /**< Source. */
       
   109         )
       
   110 {
       
   111     if (source) {
       
   112         strncpy(target, source, EC_IOCTL_STRING_SIZE);
       
   113         target[EC_IOCTL_STRING_SIZE - 1] = 0;
       
   114     } else {
       
   115         target[0] = 0;
       
   116     }
       
   117 }
       
   118 
       
   119 /*****************************************************************************/
       
   120 
   104 /** Get master information.
   121 /** Get master information.
   105  */
   122  */
   106 int ec_cdev_ioctl_master(
   123 int ec_cdev_ioctl_master(
   107         ec_master_t *master, /**< EtherCAT master. */
   124         ec_master_t *master, /**< EtherCAT master. */
   108         unsigned long arg /**< Userspace address to store the results. */
   125         unsigned long arg /**< Userspace address to store the results. */
   177     data.error_flag = slave->error_flag;
   194     data.error_flag = slave->error_flag;
   178 
   195 
   179     data.sync_count = slave->sii.sync_count;
   196     data.sync_count = slave->sii.sync_count;
   180     data.sdo_count = ec_slave_sdo_count(slave);
   197     data.sdo_count = ec_slave_sdo_count(slave);
   181     data.sii_nwords = slave->sii_nwords;
   198     data.sii_nwords = slave->sii_nwords;
   182 
   199     ec_cdev_strcpy(data.name, slave->sii.name);
   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 
   200 
   191     up(&master->master_sem);
   201     up(&master->master_sem);
   192 
   202 
   193     if (copy_to_user((void __user *) arg, &data, sizeof(data)))
   203     if (copy_to_user((void __user *) arg, &data, sizeof(data)))
   194         return -EFAULT;
   204         return -EFAULT;
   290         return -EINVAL;
   300         return -EINVAL;
   291     }
   301     }
   292 
   302 
   293     data.index = pdo->index;
   303     data.index = pdo->index;
   294     data.entry_count = ec_pdo_entry_count(pdo);
   304     data.entry_count = ec_pdo_entry_count(pdo);
   295 
   305     ec_cdev_strcpy(data.name, pdo->name);
   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 
   306 
   303     up(&master->master_sem);
   307     up(&master->master_sem);
   304 
   308 
   305     if (copy_to_user((void __user *) arg, &data, sizeof(data)))
   309     if (copy_to_user((void __user *) arg, &data, sizeof(data)))
   306         return -EFAULT;
   310         return -EFAULT;
   363     }
   367     }
   364 
   368 
   365     data.index = entry->index;
   369     data.index = entry->index;
   366     data.subindex = entry->subindex;
   370     data.subindex = entry->subindex;
   367     data.bit_length = entry->bit_length;
   371     data.bit_length = entry->bit_length;
   368     if (entry->name) {
   372     ec_cdev_strcpy(data.name, 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 
   373 
   375     up(&master->master_sem);
   374     up(&master->master_sem);
   376 
   375 
   377     if (copy_to_user((void __user *) arg, &data, sizeof(data)))
   376     if (copy_to_user((void __user *) arg, &data, sizeof(data)))
   378         return -EFAULT;
   377         return -EFAULT;
   583         return -EINVAL;
   582         return -EINVAL;
   584     }
   583     }
   585 
   584 
   586     data.sdo_index = sdo->index;
   585     data.sdo_index = sdo->index;
   587     data.max_subindex = sdo->max_subindex;
   586     data.max_subindex = sdo->max_subindex;
   588 
   587     ec_cdev_strcpy(data.name, sdo->name);
   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 
   588 
   596     up(&master->master_sem);
   589     up(&master->master_sem);
   597 
   590 
   598     if (copy_to_user((void __user *) arg, &data, sizeof(data)))
   591     if (copy_to_user((void __user *) arg, &data, sizeof(data)))
   599         return -EFAULT;
   592         return -EFAULT;
   655         return -EINVAL;
   648         return -EINVAL;
   656     }
   649     }
   657 
   650 
   658     data.data_type = entry->data_type;
   651     data.data_type = entry->data_type;
   659     data.bit_length = entry->bit_length;
   652     data.bit_length = entry->bit_length;
   660 
   653     ec_cdev_strcpy(data.description, entry->description);
   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 
   654 
   670     up(&master->master_sem);
   655     up(&master->master_sem);
   671 
   656 
   672     if (copy_to_user((void __user *) arg, &data, sizeof(data)))
   657     if (copy_to_user((void __user *) arg, &data, sizeof(data)))
   673         return -EFAULT;
   658         return -EFAULT;
  1059         return -EINVAL;
  1044         return -EINVAL;
  1060     }
  1045     }
  1061 
  1046 
  1062     data.index = pdo->index;
  1047     data.index = pdo->index;
  1063     data.entry_count = ec_pdo_entry_count(pdo);
  1048     data.entry_count = ec_pdo_entry_count(pdo);
  1064 
  1049     ec_cdev_strcpy(data.name, pdo->name);
  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 
  1050 
  1072     up(&master->master_sem);
  1051     up(&master->master_sem);
  1073 
  1052 
  1074     if (copy_to_user((void __user *) arg, &data, sizeof(data)))
  1053     if (copy_to_user((void __user *) arg, &data, sizeof(data)))
  1075         return -EFAULT;
  1054         return -EFAULT;
  1127     }
  1106     }
  1128 
  1107 
  1129     data.index = entry->index;
  1108     data.index = entry->index;
  1130     data.subindex = entry->subindex;
  1109     data.subindex = entry->subindex;
  1131     data.bit_length = entry->bit_length;
  1110     data.bit_length = entry->bit_length;
  1132     if (entry->name) {
  1111     ec_cdev_strcpy(data.name, 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 
  1112 
  1139     up(&master->master_sem);
  1113     up(&master->master_sem);
  1140 
  1114 
  1141     if (copy_to_user((void __user *) arg, &data, sizeof(data)))
  1115     if (copy_to_user((void __user *) arg, &data, sizeof(data)))
  1142         return -EFAULT;
  1116         return -EFAULT;