master/cdev.c
changeset 2004 be807e224b0e
parent 1995 7d748d9cf9e8
parent 1972 c1b564299829
child 2023 da133ec36c3a
equal deleted inserted replaced
2003:a7ff6c28a432 2004:be807e224b0e
  1349             ec_pdo_list_count(&sc->sync_configs[i].pdos);
  1349             ec_pdo_list_count(&sc->sync_configs[i].pdos);
  1350     }
  1350     }
  1351     data.watchdog_divider = sc->watchdog_divider;
  1351     data.watchdog_divider = sc->watchdog_divider;
  1352     data.watchdog_intervals = sc->watchdog_intervals;
  1352     data.watchdog_intervals = sc->watchdog_intervals;
  1353     data.sdo_count = ec_slave_config_sdo_count(sc);
  1353     data.sdo_count = ec_slave_config_sdo_count(sc);
       
  1354     data.idn_count = ec_slave_config_idn_count(sc);
  1354     data.slave_position = sc->slave ? sc->slave->ring_position : -1;
  1355     data.slave_position = sc->slave ? sc->slave->ring_position : -1;
  1355     data.dc_assign_activate = sc->dc_assign_activate;
  1356     data.dc_assign_activate = sc->dc_assign_activate;
  1356     for (i = 0; i < EC_SYNC_SIGNAL_COUNT; i++) {
  1357     for (i = 0; i < EC_SYNC_SIGNAL_COUNT; i++) {
  1357         data.dc_sync[i] = sc->dc_sync[i];
  1358         data.dc_sync[i] = sc->dc_sync[i];
  1358     }
  1359     }
  1520     data.index = req->index;
  1521     data.index = req->index;
  1521     data.subindex = req->subindex;
  1522     data.subindex = req->subindex;
  1522     data.size = req->data_size;
  1523     data.size = req->data_size;
  1523     memcpy(&data.data, req->data,
  1524     memcpy(&data.data, req->data,
  1524             min((u32) data.size, (u32) EC_MAX_SDO_DATA_SIZE));
  1525             min((u32) data.size, (u32) EC_MAX_SDO_DATA_SIZE));
       
  1526 
       
  1527     up(&master->master_sem);
       
  1528 
       
  1529     if (copy_to_user((void __user *) arg, &data, sizeof(data)))
       
  1530         return -EFAULT;
       
  1531 
       
  1532     return 0;
       
  1533 }
       
  1534 
       
  1535 /*****************************************************************************/
       
  1536 
       
  1537 /** Get slave configuration IDN information.
       
  1538  */
       
  1539 int ec_cdev_ioctl_config_idn(
       
  1540         ec_master_t *master, /**< EtherCAT master. */
       
  1541         unsigned long arg /**< ioctl() argument. */
       
  1542         )
       
  1543 {
       
  1544     ec_ioctl_config_idn_t data;
       
  1545     const ec_slave_config_t *sc;
       
  1546     const ec_soe_request_t *req;
       
  1547 
       
  1548     if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
       
  1549         return -EFAULT;
       
  1550     }
       
  1551 
       
  1552     if (down_interruptible(&master->master_sem))
       
  1553         return -EINTR;
       
  1554 
       
  1555     if (!(sc = ec_master_get_config_const(
       
  1556                     master, data.config_index))) {
       
  1557         up(&master->master_sem);
       
  1558         EC_MASTER_ERR(master, "Slave config %u does not exist!\n",
       
  1559                 data.config_index);
       
  1560         return -EINVAL;
       
  1561     }
       
  1562 
       
  1563     if (!(req = ec_slave_config_get_idn_by_pos_const(
       
  1564                     sc, data.idn_pos))) {
       
  1565         up(&master->master_sem);
       
  1566         EC_MASTER_ERR(master, "Invalid IDN position!\n");
       
  1567         return -EINVAL;
       
  1568     }
       
  1569 
       
  1570     data.drive_no = req->drive_no;
       
  1571     data.idn = req->idn;
       
  1572     data.state = req->state;
       
  1573     data.size = req->data_size;
       
  1574     memcpy(&data.data, req->data,
       
  1575             min((u32) data.size, (u32) EC_MAX_IDN_DATA_SIZE));
  1525 
  1576 
  1526     up(&master->master_sem);
  1577     up(&master->master_sem);
  1527 
  1578 
  1528     if (copy_to_user((void __user *) arg, &data, sizeof(data)))
  1579     if (copy_to_user((void __user *) arg, &data, sizeof(data)))
  1529         return -EFAULT;
  1580         return -EFAULT;
  3465         return -EFAULT;
  3516         return -EFAULT;
  3466     }
  3517     }
  3467 
  3518 
  3468     data = kmalloc(ioctl.data_size, GFP_KERNEL);
  3519     data = kmalloc(ioctl.data_size, GFP_KERNEL);
  3469     if (!data) {
  3520     if (!data) {
  3470         EC_MASTER_ERR(master, "Failed to allocate %u bytes of IDN data.\n",
  3521         EC_MASTER_ERR(master, "Failed to allocate %zu bytes of IDN data.\n",
  3471                 ioctl.data_size);
  3522                 ioctl.data_size);
  3472         return -ENOMEM;
  3523         return -ENOMEM;
  3473     }
  3524     }
  3474     if (copy_from_user(data, (void __user *) ioctl.data, ioctl.data_size)) {
  3525     if (copy_from_user(data, (void __user *) ioctl.data, ioctl.data_size)) {
  3475         kfree(data);
  3526         kfree(data);
  3631             return ec_cdev_ioctl_config_pdo(master, arg);
  3682             return ec_cdev_ioctl_config_pdo(master, arg);
  3632         case EC_IOCTL_CONFIG_PDO_ENTRY:
  3683         case EC_IOCTL_CONFIG_PDO_ENTRY:
  3633             return ec_cdev_ioctl_config_pdo_entry(master, arg);
  3684             return ec_cdev_ioctl_config_pdo_entry(master, arg);
  3634         case EC_IOCTL_CONFIG_SDO:
  3685         case EC_IOCTL_CONFIG_SDO:
  3635             return ec_cdev_ioctl_config_sdo(master, arg);
  3686             return ec_cdev_ioctl_config_sdo(master, arg);
       
  3687         case EC_IOCTL_CONFIG_IDN:
       
  3688             return ec_cdev_ioctl_config_idn(master, arg);
  3636 #ifdef EC_EOE
  3689 #ifdef EC_EOE
  3637         case EC_IOCTL_EOE_HANDLER:
  3690         case EC_IOCTL_EOE_HANDLER:
  3638             return ec_cdev_ioctl_eoe_handler(master, arg);
  3691             return ec_cdev_ioctl_eoe_handler(master, arg);
  3639 #endif
  3692 #endif
  3640         case EC_IOCTL_REQUEST:
  3693         case EC_IOCTL_REQUEST: