19 |
19 |
20 /*****************************************************************************/ |
20 /*****************************************************************************/ |
21 |
21 |
22 /** |
22 /** |
23 EtherCAT-Geräte-Konstuktor. |
23 EtherCAT-Geräte-Konstuktor. |
|
24 |
|
25 \return 0 wenn alles ok, < 0 bei Fehler (zu wenig Speicher) |
24 */ |
26 */ |
25 |
27 |
26 int ec_device_init(ec_device_t *device, /**< EtherCAT-Gerät */ |
28 int ec_device_init(ec_device_t *device, /**< EtherCAT-Gerät */ |
27 ec_master_t *master /**< Zugehöriger Master */ |
29 ec_master_t *master /**< Zugehöriger Master */ |
28 ) |
30 ) |
50 |
52 |
51 /** |
53 /** |
52 EtherCAT-Geräte-Destuktor. |
54 EtherCAT-Geräte-Destuktor. |
53 |
55 |
54 Gibt den dynamisch allozierten Speicher des |
56 Gibt den dynamisch allozierten Speicher des |
55 EtherCAT-Gerätes (die beiden Socket-Buffer) wieder frei. |
57 EtherCAT-Gerätes (den Sende-Socket-Buffer) wieder frei. |
56 */ |
58 */ |
57 |
59 |
58 void ec_device_clear(ec_device_t *device /**< EtherCAT-Gerät */) |
60 void ec_device_clear(ec_device_t *device /**< EtherCAT-Gerät */) |
59 { |
61 { |
60 if (device->open) ec_device_close(device); |
62 if (device->open) ec_device_close(device); |
82 |
84 |
83 int ec_device_open(ec_device_t *device /**< EtherCAT-Gerät */) |
85 int ec_device_open(ec_device_t *device /**< EtherCAT-Gerät */) |
84 { |
86 { |
85 unsigned int i; |
87 unsigned int i; |
86 |
88 |
87 if (!device) { |
|
88 EC_ERR("Trying to open a NULL device!\n"); |
|
89 return -1; |
|
90 } |
|
91 |
|
92 if (!device->dev) { |
89 if (!device->dev) { |
93 EC_ERR("No net_device to open!\n"); |
90 EC_ERR("No net_device to open!\n"); |
94 return -1; |
91 return -1; |
95 } |
92 } |
96 |
93 |
97 if (device->open) { |
94 if (device->open) { |
98 EC_WARN("Device already opened!\n"); |
95 EC_WARN("Device already opened!\n"); |
99 } |
96 return 0; |
100 else { |
97 } |
101 // Device could have received frames before |
98 |
102 for (i = 0; i < 4; i++) ec_device_call_isr(device); |
99 // Device could have received frames before |
103 |
100 for (i = 0; i < 4; i++) ec_device_call_isr(device); |
104 // Reset old device state |
101 |
105 device->state = EC_DEVICE_STATE_READY; |
102 // Reset old device state |
106 |
103 device->state = EC_DEVICE_STATE_READY; |
107 if (device->dev->open(device->dev) == 0) device->open = 1; |
104 |
108 } |
105 if (device->dev->open(device->dev) == 0) device->open = 1; |
109 |
106 |
110 return device->open ? 0 : -1; |
107 return device->open ? 0 : -1; |
111 } |
108 } |
112 |
109 |
113 /*****************************************************************************/ |
110 /*****************************************************************************/ |
114 |
111 |
115 /** |
112 /** |
116 Führt die stop()-Funktion des net_devices aus. |
113 Führt die stop()-Funktion des net_devices aus. |
117 |
114 |
118 \return 0 bei Erfolg, < 0: Kein Gerät zum Schliessen oder |
115 \return 0 bei Erfolg, < 0: Kein Gerät zum Schließen oder |
119 Schliessen fehlgeschlagen. |
116 Schließen fehlgeschlagen. |
120 */ |
117 */ |
121 |
118 |
122 int ec_device_close(ec_device_t *device /**< EtherCAT-Gerät */) |
119 int ec_device_close(ec_device_t *device /**< EtherCAT-Gerät */) |
123 { |
120 { |
124 if (!device->dev) { |
121 if (!device->dev) { |
144 \return Zeiger auf den Speicher, in den die Frame-Daten sollen. |
141 \return Zeiger auf den Speicher, in den die Frame-Daten sollen. |
145 */ |
142 */ |
146 |
143 |
147 uint8_t *ec_device_prepare(ec_device_t *device /**< EtherCAT-Gerät */) |
144 uint8_t *ec_device_prepare(ec_device_t *device /**< EtherCAT-Gerät */) |
148 { |
145 { |
149 // Clear transmit socket buffer and reserve space for Ethernet-II header |
146 skb_trim(device->tx_skb, 0); // Auf Länge 0 abschneiden |
150 skb_trim(device->tx_skb, 0); |
147 skb_reserve(device->tx_skb, ETH_HLEN); // Reserve für Ethernet-II-Header |
151 skb_reserve(device->tx_skb, ETH_HLEN); |
148 |
152 |
149 // Vorerst Speicher für maximal langen Frame reservieren |
153 // Erstmal Speicher für maximal langen Frame reservieren |
|
154 return skb_put(device->tx_skb, EC_MAX_FRAME_SIZE); |
150 return skb_put(device->tx_skb, EC_MAX_FRAME_SIZE); |
155 } |
151 } |
156 |
152 |
157 /*****************************************************************************/ |
153 /*****************************************************************************/ |
158 |
154 |
159 /** |
155 /** |
160 Sendet einen Rahmen über das EtherCAT-Gerät. |
156 Sendet den Inhalt des Socket-Buffers. |
161 |
157 |
162 Kopiert die zu sendenden Daten in den statischen Socket- |
158 Schneidet den Inhalt des Socket-Buffers auf die (nun bekannte) Größe zu, |
163 Buffer, fügt den Ethernat-II-Header hinzu und ruft die |
159 fügt den Ethernet-II-Header an und ruft die start_xmit()-Funktion der |
164 start_xmit()-Funktion der Netzwerkkarte auf. |
160 Netzwerkkarte auf. |
165 |
|
166 \return 0 bei Erfolg, < 0: Vorheriger Rahmen noch |
|
167 nicht empfangen, oder kein Speicher mehr vorhanden |
|
168 */ |
161 */ |
169 |
162 |
170 void ec_device_send(ec_device_t *device, /**< EtherCAT-Gerät */ |
163 void ec_device_send(ec_device_t *device, /**< EtherCAT-Gerät */ |
171 unsigned int length /**< Länge der zu sendenden Daten */ |
164 unsigned int length /**< Länge der zu sendenden Daten */ |
172 ) |
165 ) |
173 { |
166 { |
174 struct ethhdr *eth; |
167 struct ethhdr *eth; |
175 |
168 |
176 // Framegroesse auf (jetzt bekannte) Laenge abschneiden |
169 // Framegröße auf (jetzt bekannte) Länge abschneiden |
177 skb_trim(device->tx_skb, length); |
170 skb_trim(device->tx_skb, length); |
178 |
171 |
179 // Ethernet-II-Header hinzufuegen |
172 // Ethernet-II-Header hinzufuegen |
180 eth = (struct ethhdr *) skb_push(device->tx_skb, ETH_HLEN); |
173 eth = (struct ethhdr *) skb_push(device->tx_skb, ETH_HLEN); |
181 eth->h_proto = htons(0x88A4); |
174 eth->h_proto = htons(0x88A4); |
211 /*****************************************************************************/ |
204 /*****************************************************************************/ |
212 |
205 |
213 /** |
206 /** |
214 Gibt die empfangenen Daten zurück. |
207 Gibt die empfangenen Daten zurück. |
215 |
208 |
216 \return Adresse auf empfangene Daten. |
209 \return Zeiger auf empfangene Daten. |
217 */ |
210 */ |
218 |
211 |
219 uint8_t *ec_device_data(ec_device_t *device) |
212 uint8_t *ec_device_data(ec_device_t *device) |
220 { |
213 { |
221 return device->rx_data; |
214 return device->rx_data; |
267 |
260 |
268 void ec_device_debug(const ec_device_t *device /**< EtherCAT-Gerät */) |
261 void ec_device_debug(const ec_device_t *device /**< EtherCAT-Gerät */) |
269 { |
262 { |
270 EC_DBG(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n"); |
263 EC_DBG(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n"); |
271 ec_data_print(device->tx_skb->data + ETH_HLEN, device->tx_skb->len); |
264 ec_data_print(device->tx_skb->data + ETH_HLEN, device->tx_skb->len); |
272 EC_DBG("------------------------------------------------\n"); |
265 EC_DBG("--------------------------------------\n"); |
273 ec_data_print_diff(device->tx_skb->data + ETH_HLEN, device->rx_data, |
266 ec_data_print_diff(device->tx_skb->data + ETH_HLEN, device->rx_data, |
274 device->rx_data_size); |
267 device->rx_data_size); |
275 EC_DBG("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n"); |
268 EC_DBG("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n"); |
276 } |
269 } |
277 |
270 |
342 |
335 |
343 /*****************************************************************************/ |
336 /*****************************************************************************/ |
344 |
337 |
345 /** |
338 /** |
346 Prüft, ob das Net-Device \a dev zum registrierten EtherCAT-Gerät gehört. |
339 Prüft, ob das Net-Device \a dev zum registrierten EtherCAT-Gerät gehört. |
|
340 |
|
341 \return 0 wenn nein, nicht-null wenn ja. |
347 */ |
342 */ |
348 |
343 |
349 int EtherCAT_dev_is_ec(const ec_device_t *device, /**< EtherCAT-Gerät */ |
344 int EtherCAT_dev_is_ec(const ec_device_t *device, /**< EtherCAT-Gerät */ |
350 const struct net_device *dev /**< Net-Device */ |
345 const struct net_device *dev /**< Net-Device */ |
351 ) |
346 ) |
353 return device && device->dev == dev; |
348 return device && device->dev == dev; |
354 } |
349 } |
355 |
350 |
356 /*****************************************************************************/ |
351 /*****************************************************************************/ |
357 |
352 |
358 void EtherCAT_dev_receive(ec_device_t *device, const void *data, size_t size) |
353 /** |
|
354 Nimmt einen Empfangenen Rahmen entgegen. |
|
355 |
|
356 Kopiert die empfangenen Daten in den Receive-Buffer. |
|
357 */ |
|
358 |
|
359 void EtherCAT_dev_receive(ec_device_t *device, /**< EtherCAT-Gerät */ |
|
360 const void *data, /**< Zeiger auf empfangene Daten */ |
|
361 size_t size /**< Größe der empfangenen Daten */ |
|
362 ) |
359 { |
363 { |
360 // Copy received data to ethercat-device buffer |
364 // Copy received data to ethercat-device buffer |
361 memcpy(device->rx_data, data, size); |
365 memcpy(device->rx_data, data, size); |
362 device->rx_data_size = size; |
366 device->rx_data_size = size; |
363 device->state = EC_DEVICE_STATE_RECEIVED; |
367 device->state = EC_DEVICE_STATE_RECEIVED; |