125 unsigned long arg /**< Userspace address to store the results. */ |
125 unsigned long arg /**< Userspace address to store the results. */ |
126 ) |
126 ) |
127 { |
127 { |
128 ec_ioctl_master_t data; |
128 ec_ioctl_master_t data; |
129 |
129 |
130 down(&master->master_sem); |
130 if (down_interruptible(&master->master_sem)) |
|
131 return -EINTR; |
131 data.slave_count = master->slave_count; |
132 data.slave_count = master->slave_count; |
132 data.config_count = ec_master_config_count(master); |
133 data.config_count = ec_master_config_count(master); |
133 data.domain_count = ec_master_domain_count(master); |
134 data.domain_count = ec_master_domain_count(master); |
134 data.phase = (uint8_t) master->phase; |
135 data.phase = (uint8_t) master->phase; |
135 up(&master->master_sem); |
136 up(&master->master_sem); |
136 |
137 |
137 down(&master->device_sem); |
138 if (down_interruptible(&master->device_sem)) |
|
139 return -EINTR; |
138 if (master->main_device.dev) { |
140 if (master->main_device.dev) { |
139 memcpy(data.devices[0].address, |
141 memcpy(data.devices[0].address, |
140 master->main_device.dev->dev_addr, ETH_ALEN); |
142 master->main_device.dev->dev_addr, ETH_ALEN); |
141 } else { |
143 } else { |
142 memcpy(data.devices[0].address, master->main_mac, ETH_ALEN); |
144 memcpy(data.devices[0].address, master->main_mac, ETH_ALEN); |
176 |
178 |
177 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
179 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
178 return -EFAULT; |
180 return -EFAULT; |
179 } |
181 } |
180 |
182 |
181 down(&master->master_sem); |
183 if (down_interruptible(&master->master_sem)) |
|
184 return -EINTR; |
182 |
185 |
183 if (!(slave = ec_master_find_slave_const( |
186 if (!(slave = ec_master_find_slave_const( |
184 master, 0, data.position))) { |
187 master, 0, data.position))) { |
185 up(&master->master_sem); |
188 up(&master->master_sem); |
186 EC_ERR("Slave %u does not exist!\n", data.position); |
189 EC_ERR("Slave %u does not exist!\n", data.position); |
235 |
238 |
236 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
239 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
237 return -EFAULT; |
240 return -EFAULT; |
238 } |
241 } |
239 |
242 |
240 down(&master->master_sem); |
243 if (down_interruptible(&master->master_sem)) |
|
244 return -EINTR; |
241 |
245 |
242 if (!(slave = ec_master_find_slave_const( |
246 if (!(slave = ec_master_find_slave_const( |
243 master, 0, data.slave_position))) { |
247 master, 0, data.slave_position))) { |
244 up(&master->master_sem); |
248 up(&master->master_sem); |
245 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
249 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
285 |
289 |
286 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
290 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
287 return -EFAULT; |
291 return -EFAULT; |
288 } |
292 } |
289 |
293 |
290 down(&master->master_sem); |
294 if (down_interruptible(&master->master_sem)) |
|
295 return -EINTR; |
291 |
296 |
292 if (!(slave = ec_master_find_slave_const( |
297 if (!(slave = ec_master_find_slave_const( |
293 master, 0, data.slave_position))) { |
298 master, 0, data.slave_position))) { |
294 up(&master->master_sem); |
299 up(&master->master_sem); |
295 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
300 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
342 |
347 |
343 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
348 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
344 return -EFAULT; |
349 return -EFAULT; |
345 } |
350 } |
346 |
351 |
347 down(&master->master_sem); |
352 if (down_interruptible(&master->master_sem)) |
|
353 return -EINTR; |
348 |
354 |
349 if (!(slave = ec_master_find_slave_const( |
355 if (!(slave = ec_master_find_slave_const( |
350 master, 0, data.slave_position))) { |
356 master, 0, data.slave_position))) { |
351 up(&master->master_sem); |
357 up(&master->master_sem); |
352 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
358 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
406 |
412 |
407 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
413 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
408 return -EFAULT; |
414 return -EFAULT; |
409 } |
415 } |
410 |
416 |
411 down(&master->master_sem); |
417 if (down_interruptible(&master->master_sem)) |
|
418 return -EINTR; |
412 |
419 |
413 if (!(domain = ec_master_find_domain_const(master, data.index))) { |
420 if (!(domain = ec_master_find_domain_const(master, data.index))) { |
414 up(&master->master_sem); |
421 up(&master->master_sem); |
415 EC_ERR("Domain %u does not exist!\n", data.index); |
422 EC_ERR("Domain %u does not exist!\n", data.index); |
416 return -EINVAL; |
423 return -EINVAL; |
445 |
452 |
446 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
453 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
447 return -EFAULT; |
454 return -EFAULT; |
448 } |
455 } |
449 |
456 |
450 down(&master->master_sem); |
457 if (down_interruptible(&master->master_sem)) |
|
458 return -EINTR; |
451 |
459 |
452 if (!(domain = ec_master_find_domain_const(master, data.domain_index))) { |
460 if (!(domain = ec_master_find_domain_const(master, data.domain_index))) { |
453 up(&master->master_sem); |
461 up(&master->master_sem); |
454 EC_ERR("Domain %u does not exist!\n", data.domain_index); |
462 EC_ERR("Domain %u does not exist!\n", data.domain_index); |
455 return -EINVAL; |
463 return -EINVAL; |
491 |
499 |
492 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
500 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
493 return -EFAULT; |
501 return -EFAULT; |
494 } |
502 } |
495 |
503 |
496 down(&master->master_sem); |
504 if (down_interruptible(&master->master_sem)) |
|
505 return -EINTR; |
497 |
506 |
498 if (!(domain = ec_master_find_domain_const(master, data.domain_index))) { |
507 if (!(domain = ec_master_find_domain_const(master, data.domain_index))) { |
499 up(&master->master_sem); |
508 up(&master->master_sem); |
500 EC_ERR("Domain %u does not exist!\n", data.domain_index); |
509 EC_ERR("Domain %u does not exist!\n", data.domain_index); |
501 return -EINVAL; |
510 return -EINVAL; |
545 |
554 |
546 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
555 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
547 return -EFAULT; |
556 return -EFAULT; |
548 } |
557 } |
549 |
558 |
550 down(&master->master_sem); |
559 if (down_interruptible(&master->master_sem)) |
|
560 return -EINTR; |
551 |
561 |
552 if (!(slave = ec_master_find_slave( |
562 if (!(slave = ec_master_find_slave( |
553 master, 0, data.slave_position))) { |
563 master, 0, data.slave_position))) { |
554 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
564 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
555 return -EINVAL; |
565 return -EINVAL; |
576 |
586 |
577 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
587 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
578 return -EFAULT; |
588 return -EFAULT; |
579 } |
589 } |
580 |
590 |
581 down(&master->master_sem); |
591 if (down_interruptible(&master->master_sem)) |
|
592 return -EINTR; |
582 |
593 |
583 if (!(slave = ec_master_find_slave_const( |
594 if (!(slave = ec_master_find_slave_const( |
584 master, 0, data.slave_position))) { |
595 master, 0, data.slave_position))) { |
585 up(&master->master_sem); |
596 up(&master->master_sem); |
586 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
597 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
623 |
634 |
624 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
635 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
625 return -EFAULT; |
636 return -EFAULT; |
626 } |
637 } |
627 |
638 |
628 down(&master->master_sem); |
639 if (down_interruptible(&master->master_sem)) |
|
640 return -EINTR; |
629 |
641 |
630 if (!(slave = ec_master_find_slave_const( |
642 if (!(slave = ec_master_find_slave_const( |
631 master, 0, data.slave_position))) { |
643 master, 0, data.slave_position))) { |
632 up(&master->master_sem); |
644 up(&master->master_sem); |
633 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
645 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
693 ec_sdo_request_init(&request.req); |
705 ec_sdo_request_init(&request.req); |
694 ec_sdo_request_address(&request.req, |
706 ec_sdo_request_address(&request.req, |
695 data.sdo_index, data.sdo_entry_subindex); |
707 data.sdo_index, data.sdo_entry_subindex); |
696 ecrt_sdo_request_read(&request.req); |
708 ecrt_sdo_request_read(&request.req); |
697 |
709 |
698 down(&master->master_sem); |
710 if (down_interruptible(&master->master_sem)) |
|
711 return -EINTR; |
699 |
712 |
700 if (!(request.slave = ec_master_find_slave( |
713 if (!(request.slave = ec_master_find_slave( |
701 master, 0, data.slave_position))) { |
714 master, 0, data.slave_position))) { |
702 up(&master->master_sem); |
715 up(&master->master_sem); |
703 ec_sdo_request_clear(&request.req); |
716 ec_sdo_request_clear(&request.req); |
794 } |
807 } |
795 request.req.data_size = data.data_size; |
808 request.req.data_size = data.data_size; |
796 ecrt_sdo_request_write(&request.req); |
809 ecrt_sdo_request_write(&request.req); |
797 |
810 |
798 |
811 |
799 down(&master->master_sem); |
812 if (down_interruptible(&master->master_sem)) |
|
813 return -EINTR; |
800 |
814 |
801 if (!(request.slave = ec_master_find_slave( |
815 if (!(request.slave = ec_master_find_slave( |
802 master, 0, data.slave_position))) { |
816 master, 0, data.slave_position))) { |
803 up(&master->master_sem); |
817 up(&master->master_sem); |
804 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
818 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
856 |
870 |
857 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
871 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
858 return -EFAULT; |
872 return -EFAULT; |
859 } |
873 } |
860 |
874 |
861 down(&master->master_sem); |
875 if (down_interruptible(&master->master_sem)) |
|
876 return -EINTR; |
862 |
877 |
863 if (!(slave = ec_master_find_slave_const( |
878 if (!(slave = ec_master_find_slave_const( |
864 master, 0, data.slave_position))) { |
879 master, 0, data.slave_position))) { |
865 up(&master->master_sem); |
880 up(&master->master_sem); |
866 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
881 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
919 (void __user *) data.words, byte_size)) { |
934 (void __user *) data.words, byte_size)) { |
920 kfree(words); |
935 kfree(words); |
921 return -EFAULT; |
936 return -EFAULT; |
922 } |
937 } |
923 |
938 |
924 down(&master->master_sem); |
939 if (down_interruptible(&master->master_sem)) |
|
940 return -EINTR; |
925 |
941 |
926 if (!(slave = ec_master_find_slave( |
942 if (!(slave = ec_master_find_slave( |
927 master, 0, data.slave_position))) { |
943 master, 0, data.slave_position))) { |
928 up(&master->master_sem); |
944 up(&master->master_sem); |
929 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
945 EC_ERR("Slave %u does not exist!\n", data.slave_position); |
982 |
998 |
983 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
999 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
984 return -EFAULT; |
1000 return -EFAULT; |
985 } |
1001 } |
986 |
1002 |
987 down(&master->master_sem); |
1003 if (down_interruptible(&master->master_sem)) |
|
1004 return -EINTR; |
988 |
1005 |
989 if (!(sc = ec_master_get_config_const( |
1006 if (!(sc = ec_master_get_config_const( |
990 master, data.config_index))) { |
1007 master, data.config_index))) { |
991 up(&master->master_sem); |
1008 up(&master->master_sem); |
992 EC_ERR("Slave config %u does not exist!\n", |
1009 EC_ERR("Slave config %u does not exist!\n", |
1035 EC_ERR("Invalid sync manager index %u!\n", |
1052 EC_ERR("Invalid sync manager index %u!\n", |
1036 data.sync_index); |
1053 data.sync_index); |
1037 return -EINVAL; |
1054 return -EINVAL; |
1038 } |
1055 } |
1039 |
1056 |
1040 down(&master->master_sem); |
1057 if (down_interruptible(&master->master_sem)) |
|
1058 return -EINTR; |
1041 |
1059 |
1042 if (!(sc = ec_master_get_config_const( |
1060 if (!(sc = ec_master_get_config_const( |
1043 master, data.config_index))) { |
1061 master, data.config_index))) { |
1044 up(&master->master_sem); |
1062 up(&master->master_sem); |
1045 EC_ERR("Slave config %u does not exist!\n", |
1063 EC_ERR("Slave config %u does not exist!\n", |
1089 EC_ERR("Invalid sync manager index %u!\n", |
1107 EC_ERR("Invalid sync manager index %u!\n", |
1090 data.sync_index); |
1108 data.sync_index); |
1091 return -EINVAL; |
1109 return -EINVAL; |
1092 } |
1110 } |
1093 |
1111 |
1094 down(&master->master_sem); |
1112 if (down_interruptible(&master->master_sem)) |
|
1113 return -EINTR; |
1095 |
1114 |
1096 if (!(sc = ec_master_get_config_const( |
1115 if (!(sc = ec_master_get_config_const( |
1097 master, data.config_index))) { |
1116 master, data.config_index))) { |
1098 up(&master->master_sem); |
1117 up(&master->master_sem); |
1099 EC_ERR("Slave config %u does not exist!\n", |
1118 EC_ERR("Slave config %u does not exist!\n", |
1144 |
1163 |
1145 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
1164 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) { |
1146 return -EFAULT; |
1165 return -EFAULT; |
1147 } |
1166 } |
1148 |
1167 |
1149 down(&master->master_sem); |
1168 if (down_interruptible(&master->master_sem)) |
|
1169 return -EINTR; |
1150 |
1170 |
1151 if (!(sc = ec_master_get_config_const( |
1171 if (!(sc = ec_master_get_config_const( |
1152 master, data.config_index))) { |
1172 master, data.config_index))) { |
1153 up(&master->master_sem); |
1173 up(&master->master_sem); |
1154 EC_ERR("Slave config %u does not exist!\n", |
1174 EC_ERR("Slave config %u does not exist!\n", |