equal
deleted
inserted
replaced
67 int ec_device_init( |
67 int ec_device_init( |
68 ec_device_t *device, /**< EtherCAT device */ |
68 ec_device_t *device, /**< EtherCAT device */ |
69 ec_master_t *master /**< master owning the device */ |
69 ec_master_t *master /**< master owning the device */ |
70 ) |
70 ) |
71 { |
71 { |
|
72 int ret; |
72 unsigned int i; |
73 unsigned int i; |
73 struct ethhdr *eth; |
74 struct ethhdr *eth; |
74 #ifdef EC_DEBUG_IF |
75 #ifdef EC_DEBUG_IF |
75 char ifname[10]; |
76 char ifname[10]; |
76 char mb = 'x'; |
77 char mb = 'x'; |
89 else if (device == &master->backup_device) |
90 else if (device == &master->backup_device) |
90 mb = 'b'; |
91 mb = 'b'; |
91 |
92 |
92 sprintf(ifname, "ecdbg%c%u", mb, master->index); |
93 sprintf(ifname, "ecdbg%c%u", mb, master->index); |
93 |
94 |
94 if (ec_debug_init(&device->dbg, ifname)) { |
95 ret = ec_debug_init(&device->dbg, ifname); |
|
96 if (ret < 0) { |
95 EC_ERR("Failed to init debug device!\n"); |
97 EC_ERR("Failed to init debug device!\n"); |
96 goto out_return; |
98 goto out_return; |
97 } |
99 } |
98 #endif |
100 #endif |
99 |
101 |
101 device->tx_skb[i] = NULL; |
103 device->tx_skb[i] = NULL; |
102 |
104 |
103 for (i = 0; i < EC_TX_RING_SIZE; i++) { |
105 for (i = 0; i < EC_TX_RING_SIZE; i++) { |
104 if (!(device->tx_skb[i] = dev_alloc_skb(ETH_FRAME_LEN))) { |
106 if (!(device->tx_skb[i] = dev_alloc_skb(ETH_FRAME_LEN))) { |
105 EC_ERR("Error allocating device socket buffer!\n"); |
107 EC_ERR("Error allocating device socket buffer!\n"); |
|
108 ret = -ENOMEM; |
106 goto out_tx_ring; |
109 goto out_tx_ring; |
107 } |
110 } |
108 |
111 |
109 // add Ethernet-II-header |
112 // add Ethernet-II-header |
110 skb_reserve(device->tx_skb[i], ETH_HLEN); |
113 skb_reserve(device->tx_skb[i], ETH_HLEN); |
122 dev_kfree_skb(device->tx_skb[i]); |
125 dev_kfree_skb(device->tx_skb[i]); |
123 #ifdef EC_DEBUG_IF |
126 #ifdef EC_DEBUG_IF |
124 ec_debug_clear(&device->dbg); |
127 ec_debug_clear(&device->dbg); |
125 out_return: |
128 out_return: |
126 #endif |
129 #endif |
127 return -1; |
130 return ret; |
128 } |
131 } |
129 |
132 |
130 /*****************************************************************************/ |
133 /*****************************************************************************/ |
131 |
134 |
132 /** Destuctor. |
135 /** Destructor. |
133 */ |
136 */ |
134 void ec_device_clear( |
137 void ec_device_clear( |
135 ec_device_t *device /**< EtherCAT device */ |
138 ec_device_t *device /**< EtherCAT device */ |
136 ) |
139 ) |
137 { |
140 { |
209 */ |
212 */ |
210 int ec_device_open( |
213 int ec_device_open( |
211 ec_device_t *device /**< EtherCAT device */ |
214 ec_device_t *device /**< EtherCAT device */ |
212 ) |
215 ) |
213 { |
216 { |
|
217 int ret; |
|
218 |
214 if (!device->dev) { |
219 if (!device->dev) { |
215 EC_ERR("No net_device to open!\n"); |
220 EC_ERR("No net_device to open!\n"); |
216 return -1; |
221 return -ENODEV; |
217 } |
222 } |
218 |
223 |
219 if (device->open) { |
224 if (device->open) { |
220 EC_WARN("Device already opened!\n"); |
225 EC_WARN("Device already opened!\n"); |
221 return 0; |
226 return 0; |
223 |
228 |
224 device->link_state = 0; |
229 device->link_state = 0; |
225 device->tx_count = 0; |
230 device->tx_count = 0; |
226 device->rx_count = 0; |
231 device->rx_count = 0; |
227 |
232 |
228 if (device->dev->open(device->dev) == 0) device->open = 1; |
233 ret = device->dev->open(device->dev); |
229 |
234 if (!ret) |
230 return device->open ? 0 : -1; |
235 device->open = 1; |
|
236 |
|
237 return ret; |
231 } |
238 } |
232 |
239 |
233 /*****************************************************************************/ |
240 /*****************************************************************************/ |
234 |
241 |
235 /** Stops the EtherCAT device. |
242 /** Stops the EtherCAT device. |
238 */ |
245 */ |
239 int ec_device_close( |
246 int ec_device_close( |
240 ec_device_t *device /**< EtherCAT device */ |
247 ec_device_t *device /**< EtherCAT device */ |
241 ) |
248 ) |
242 { |
249 { |
|
250 int ret; |
|
251 |
243 if (!device->dev) { |
252 if (!device->dev) { |
244 EC_ERR("No device to close!\n"); |
253 EC_ERR("No device to close!\n"); |
245 return -1; |
254 return -ENODEV; |
246 } |
255 } |
247 |
256 |
248 if (!device->open) { |
257 if (!device->open) { |
249 EC_WARN("Device already closed!\n"); |
258 EC_WARN("Device already closed!\n"); |
250 return 0; |
259 return 0; |
251 } |
260 } |
252 |
261 |
253 if (device->dev->stop(device->dev) == 0) device->open = 0; |
262 ret = device->dev->stop(device->dev); |
254 |
263 if (!ret) |
255 return !device->open ? 0 : -1; |
264 device->open = 0; |
|
265 |
|
266 return ret; |
256 } |
267 } |
257 |
268 |
258 /*****************************************************************************/ |
269 /*****************************************************************************/ |
259 |
270 |
260 /** Returns a pointer to the device's transmit memory. |
271 /** Returns a pointer to the device's transmit memory. |
436 * \return 0 on success, else < 0 |
447 * \return 0 on success, else < 0 |
437 * \ingroup DeviceInterface |
448 * \ingroup DeviceInterface |
438 */ |
449 */ |
439 int ecdev_open(ec_device_t *device /**< EtherCAT device */) |
450 int ecdev_open(ec_device_t *device /**< EtherCAT device */) |
440 { |
451 { |
441 if (ec_device_open(device)) { |
452 int ret; |
|
453 |
|
454 ret = ec_device_open(device); |
|
455 if (ret) { |
442 EC_ERR("Failed to open device!\n"); |
456 EC_ERR("Failed to open device!\n"); |
443 return -1; |
457 return ret; |
444 } |
458 } |
445 |
459 |
446 if (ec_master_enter_idle_phase(device->master)) { |
460 ret = ec_master_enter_idle_phase(device->master); |
|
461 if (ret) { |
447 EC_ERR("Failed to enter IDLE phase!\n"); |
462 EC_ERR("Failed to enter IDLE phase!\n"); |
448 return -1; |
463 return ret; |
449 } |
464 } |
450 |
465 |
451 return 0; |
466 return 0; |
452 } |
467 } |
453 |
468 |