1877 /** Create an SDO request.

  1878  */

  1879 int ec_cdev_ioctl_sc_create_sdo_request(

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

  1881         unsigned long arg, /**< ioctl() argument. */

  1882         ec_cdev_priv_t *priv /**< Private data structure of file handle. */

  1883         )

  1884 {

  1885     ec_ioctl_sdo_request_t data;

  1886     ec_slave_config_t *sc;

  1887     ec_sdo_request_t *req;

  1888 

  1889 	if (unlikely(!priv->requested))

  1890 		return -EPERM;

  1891 

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

  1893         return -EFAULT;

  1894     }

  1895 

  1896     data.request_index = 0;

  1897 

  1898     if (down_interruptible(&master->master_sem))

  1899         return -EINTR;

  1900 

  1901     sc = ec_master_get_config(master, data.config_index);

  1902     if (!sc) {

  1903         up(&master->master_sem);

  1904         return -ENOENT;

  1905     }

  1906 

  1907     list_for_each_entry(req, &sc->sdo_requests, list) {

  1908         data.request_index++;

  1909     }

  1910 

  1911     up(&master->master_sem);

  1912 

  1913     req = ecrt_slave_config_create_sdo_request_err(sc, data.sdo_index,

  1914             data.sdo_subindex, data.size);

  1915     if (IS_ERR(req))

  1916         return PTR_ERR(req);

  1917 

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

  1919         return -EFAULT;

  1920 

  1921     return 0;

  1922 }

  1923 

  1924 /*****************************************************************************/

  1925 

  2135     return 0;

  2136 }

  2137 

  2138 /*****************************************************************************/

  2139 

  2140 /** Sets an SDO request's timeout.

  2141  */

  2142 int ec_cdev_ioctl_sdo_request_timeout(

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

  2144         unsigned long arg, /**< ioctl() argument. */

  2145         ec_cdev_priv_t *priv /**< Private data structure of file handle. */

  2146         )

  2147 {

  2148     ec_ioctl_sdo_request_t data;

  2149     ec_slave_config_t *sc;

  2150     ec_sdo_request_t *req;

  2151 

  2152 	if (unlikely(!priv->requested))

  2153         return -EPERM;

  2154 

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

  2156         return -EFAULT;

  2157 

  2158     if (down_interruptible(&master->master_sem))

  2159         return -EINTR;

  2160 

  2161     if (!(sc = ec_master_get_config(master, data.config_index))) {

  2162         up(&master->master_sem);

  2163         return -ENOENT;

  2164     }

  2165 

  2166     if (!(req = ec_slave_config_find_sdo_request(sc, data.request_index))) {

  2167         up(&master->master_sem);

  2168         return -ENOENT;

  2169     }

  2170 

  2171     up(&master->master_sem);

  2172 

  2173     ecrt_sdo_request_timeout(req, data.timeout);

  2174     return 0;

  2175 }

  2176 

  2177 /*****************************************************************************/

  2178 

  2179 /** Gets an SDO request's state.

  2180  */

  2181 int ec_cdev_ioctl_sdo_request_state(

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

  2183         unsigned long arg, /**< ioctl() argument. */

  2184         ec_cdev_priv_t *priv /**< Private data structure of file handle. */

  2185         )

  2186 {

  2187     ec_ioctl_sdo_request_t data;

  2188     ec_slave_config_t *sc;

  2189     ec_sdo_request_t *req;

  2190 

  2191 	if (unlikely(!priv->requested))

  2192         return -EPERM;

  2193 

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

  2195         return -EFAULT;

  2196 

  2197     if (down_interruptible(&master->master_sem))

  2198         return -EINTR;

  2199 

  2200     if (!(sc = ec_master_get_config(master, data.config_index))) {

  2201         up(&master->master_sem);

  2202         return -ENOENT;

  2203     }

  2204 

  2205     if (!(req = ec_slave_config_find_sdo_request(sc, data.request_index))) {

  2206         up(&master->master_sem);

  2207         return -ENOENT;

  2208     }

  2209 

  2210     data.state = ecrt_sdo_request_state(req);

  2211     if (data.state == EC_REQUEST_SUCCESS && req->dir == EC_DIR_INPUT)

  2212         data.size = ecrt_sdo_request_data_size(req);

  2213     else

  2214         data.size = 0;

  2215 

  2216     up(&master->master_sem);

  2217 

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

  2219         return -EFAULT;

  2220 

  2221     return 0;

  2222 }

  2223 

  2224 /*****************************************************************************/

  2225 

  2226 /** Starts an SDO read operation.

  2227  */

  2228 int ec_cdev_ioctl_sdo_request_read(

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

  2230         unsigned long arg, /**< ioctl() argument. */

  2231         ec_cdev_priv_t *priv /**< Private data structure of file handle. */

  2232         )

  2233 {

  2234     ec_ioctl_sdo_request_t data;

  2235     ec_slave_config_t *sc;

  2236     ec_sdo_request_t *req;

  2237 

  2238 	if (unlikely(!priv->requested))

  2239         return -EPERM;

  2240 

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

  2242         return -EFAULT;

  2243 

  2244     if (down_interruptible(&master->master_sem))

  2245         return -EINTR;

  2246 

  2247     if (!(sc = ec_master_get_config(master, data.config_index))) {

  2248         up(&master->master_sem);

  2249         return -ENOENT;

  2250     }

  2251 

  2252     if (!(req = ec_slave_config_find_sdo_request(sc, data.request_index))) {

  2253         up(&master->master_sem);

  2254         return -ENOENT;

  2255     }

  2256 

  2257     up(&master->master_sem);

  2258 

  2259     ecrt_sdo_request_read(req);

  2260     return 0;

  2261 }

  2262 

  2263 /*****************************************************************************/

  2264 

  2265 /** Starts an SDO write operation.

  2266  */

  2267 int ec_cdev_ioctl_sdo_request_write(

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

  2269         unsigned long arg, /**< ioctl() argument. */

  2270         ec_cdev_priv_t *priv /**< Private data structure of file handle. */

  2271         )

  2272 {

  2273     ec_ioctl_sdo_request_t data;

  2274     ec_slave_config_t *sc;

  2275     ec_sdo_request_t *req;

  2276 

  2277 	if (unlikely(!priv->requested))

  2278         return -EPERM;

  2279 

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

  2281         return -EFAULT;

  2282 

  2283     if (down_interruptible(&master->master_sem))

  2284         return -EINTR;

  2285 

  2286     if (!(sc = ec_master_get_config(master, data.config_index))) {

  2287         up(&master->master_sem);

  2288         return -ENOENT;

  2289     }

  2290 

  2291     if (!(req = ec_slave_config_find_sdo_request(sc, data.request_index))) {

  2292         up(&master->master_sem);

  2293         return -ENOENT;

  2294     }

  2295 

  2296     up(&master->master_sem);

  2297 

  2298     ecrt_sdo_request_write(req);

  2299     return 0;

  2300 }

  2301 

  2302 /*****************************************************************************/

  2303 

  2304 /** Read SDO data.

  2305  */

  2306 int ec_cdev_ioctl_sdo_request_data(

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

  2308         unsigned long arg, /**< ioctl() argument. */

  2309         ec_cdev_priv_t *priv /**< Private data structure of file handle. */

  2310         )

  2311 {

  2312     ec_ioctl_sdo_request_t data;

  2313     ec_slave_config_t *sc;

  2314     ec_sdo_request_t *req;

  2315 

  2316 	if (unlikely(!priv->requested))

  2317         return -EPERM;

  2318 

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

  2320         return -EFAULT;

  2321 

  2322     if (down_interruptible(&master->master_sem))

  2323         return -EINTR;

  2324 

  2325     if (!(sc = ec_master_get_config(master, data.config_index))) {

  2326         up(&master->master_sem);

  2327         return -ENOENT;

  2328     }

  2329 

  2330     if (!(req = ec_slave_config_find_sdo_request(sc, data.request_index))) {

  2331         up(&master->master_sem);

  2332         return -ENOENT;

  2333     }

  2334 

  2335     up(&master->master_sem);

  2336 

  2337     ecrt_sdo_request_timeout(req, data.timeout);

  3019         case EC_IOCTL_SC_SDO_REQUEST:

  3020             if (!(filp->f_mode & FMODE_WRITE))

  3021 				return -EPERM;

  3022 			return ec_cdev_ioctl_sc_create_sdo_request(master, arg, priv);

  3041         case EC_IOCTL_SDO_REQUEST_TIMEOUT:

  3042             if (!(filp->f_mode & FMODE_WRITE))

  3043 				return -EPERM;

  3044 			return ec_cdev_ioctl_sdo_request_timeout(master, arg, priv);

  3045         case EC_IOCTL_SDO_REQUEST_STATE:

  3046 			return ec_cdev_ioctl_sdo_request_state(master, arg, priv);

  3047         case EC_IOCTL_SDO_REQUEST_READ:

  3048             if (!(filp->f_mode & FMODE_WRITE))

  3049 				return -EPERM;

  3050 			return ec_cdev_ioctl_sdo_request_read(master, arg, priv);

  3051         case EC_IOCTL_SDO_REQUEST_WRITE:

  3052             if (!(filp->f_mode & FMODE_WRITE))

  3053 				return -EPERM;

  3054 			return ec_cdev_ioctl_sdo_request_write(master, arg, priv);

  3055         case EC_IOCTL_SDO_REQUEST_DATA:

  3056 			return ec_cdev_ioctl_sdo_request_data(master, arg, priv);