52 int ec_dbgdev_tx(struct sk_buff *, struct net_device *); |
52 int ec_dbgdev_tx(struct sk_buff *, struct net_device *); |
53 struct net_device_stats *ec_dbgdev_stats(struct net_device *); |
53 struct net_device_stats *ec_dbgdev_stats(struct net_device *); |
54 |
54 |
55 /*****************************************************************************/ |
55 /*****************************************************************************/ |
56 |
56 |
57 /** |
57 /** Debug interface constructor. |
58 Debug constructor. |
58 * |
59 Initializes the debug object, creates a net_device and registeres it. |
59 * Initializes the debug object, creates a net_device and registeres it. |
60 */ |
60 */ |
61 |
|
62 int ec_debug_init( |
61 int ec_debug_init( |
63 ec_debug_t *dbg, /**< debug object */ |
62 ec_debug_t *dbg, /**< debug object */ |
64 const char *name /**< interface name */ |
63 const char *name /**< interface name */ |
65 ) |
64 ) |
66 { |
65 { |
67 int result; |
66 dbg->registered = 0; |
68 |
|
69 dbg->opened = 0; |
67 dbg->opened = 0; |
|
68 |
70 memset(&dbg->stats, 0, sizeof(struct net_device_stats)); |
69 memset(&dbg->stats, 0, sizeof(struct net_device_stats)); |
71 |
70 |
72 if (!(dbg->dev = |
71 if (!(dbg->dev = |
73 alloc_netdev(sizeof(ec_debug_t *), name, ether_setup))) { |
72 alloc_netdev(sizeof(ec_debug_t *), name, ether_setup))) { |
74 EC_ERR("Unable to allocate net_device for debug object!\n"); |
73 EC_ERR("Unable to allocate net_device for debug object!\n"); |
82 dbg->dev->get_stats = ec_dbgdev_stats; |
81 dbg->dev->get_stats = ec_dbgdev_stats; |
83 |
82 |
84 // initialize private data |
83 // initialize private data |
85 *((ec_debug_t **) netdev_priv(dbg->dev)) = dbg; |
84 *((ec_debug_t **) netdev_priv(dbg->dev)) = dbg; |
86 |
85 |
|
86 return 0; |
|
87 |
|
88 out_return: |
|
89 return -1; |
|
90 } |
|
91 |
|
92 /*****************************************************************************/ |
|
93 |
|
94 /** Debug interface destructor. |
|
95 * |
|
96 * Unregisters the net_device and frees allocated memory. |
|
97 */ |
|
98 void ec_debug_clear( |
|
99 ec_debug_t *dbg /**< debug object */ |
|
100 ) |
|
101 { |
|
102 ec_debug_unregister(dbg); |
|
103 free_netdev(dbg->dev); |
|
104 } |
|
105 |
|
106 /*****************************************************************************/ |
|
107 |
|
108 /** Register debug interface. |
|
109 */ |
|
110 void ec_debug_register( |
|
111 ec_debug_t *dbg, /**< debug object */ |
|
112 const struct net_device *net_dev /**< 'Real' Ethernet device. */ |
|
113 ) |
|
114 { |
|
115 int result; |
|
116 |
|
117 ec_debug_unregister(dbg); |
|
118 |
|
119 // use the Ethernet address of the physical device for the debug device |
|
120 memcpy(dbg->dev->dev_addr, net_dev->dev_addr, ETH_ALEN); |
|
121 |
87 // connect the net_device to the kernel |
122 // connect the net_device to the kernel |
88 if ((result = register_netdev(dbg->dev))) { |
123 if ((result = register_netdev(dbg->dev))) { |
89 EC_ERR("Unable to register net_device: error %i\n", result); |
124 EC_WARN("Unable to register net_device: error %i\n", result); |
90 goto out_free; |
125 } else { |
91 } |
126 dbg->registered = 1; |
92 |
127 } |
93 return 0; |
128 } |
94 |
129 |
95 out_free: |
130 /*****************************************************************************/ |
96 free_netdev(dbg->dev); |
131 |
97 dbg->dev = NULL; |
132 /** Unregister debug interface. |
98 out_return: |
133 */ |
99 return -1; |
134 void ec_debug_unregister( |
100 } |
135 ec_debug_t *dbg /**< debug object */ |
101 |
136 ) |
102 /*****************************************************************************/ |
137 { |
103 |
138 if (dbg->registered) { |
104 /** |
139 dbg->opened = 0; |
105 Debug destructor. |
140 dbg->registered = 0; |
106 Unregisteres the net_device and frees allocated memory. |
|
107 */ |
|
108 |
|
109 void ec_debug_clear(ec_debug_t *dbg /**< debug object */) |
|
110 { |
|
111 if (dbg->dev) { |
|
112 unregister_netdev(dbg->dev); |
141 unregister_netdev(dbg->dev); |
113 free_netdev(dbg->dev); |
142 } |
114 } |
143 } |
115 } |
144 |
116 |
145 /*****************************************************************************/ |
117 /*****************************************************************************/ |
146 |
118 |
147 /** Sends frame data to the interface. |
119 /** |
148 */ |
120 Sends frame data to the interface. |
149 void ec_debug_send( |
121 */ |
150 ec_debug_t *dbg, /**< debug object */ |
122 |
151 const uint8_t *data, /**< frame data */ |
123 void ec_debug_send(ec_debug_t *dbg, /**< debug object */ |
152 size_t size /**< size of the frame data */ |
124 const uint8_t *data, /**< frame data */ |
153 ) |
125 size_t size /**< size of the frame data */ |
|
126 ) |
|
127 { |
154 { |
128 struct sk_buff *skb; |
155 struct sk_buff *skb; |
129 |
156 |
130 if (!dbg->opened) return; |
157 if (!dbg->opened) |
|
158 return; |
131 |
159 |
132 // allocate socket buffer |
160 // allocate socket buffer |
133 if (!(skb = dev_alloc_skb(size))) { |
161 if (!(skb = dev_alloc_skb(size))) { |
134 dbg->stats.rx_dropped++; |
162 dbg->stats.rx_dropped++; |
135 return; |
163 return; |
151 |
179 |
152 /****************************************************************************** |
180 /****************************************************************************** |
153 * NET_DEVICE functions |
181 * NET_DEVICE functions |
154 *****************************************************************************/ |
182 *****************************************************************************/ |
155 |
183 |
156 /** |
184 /** Opens the virtual network device. |
157 Opens the virtual network device. |
185 */ |
158 */ |
186 int ec_dbgdev_open( |
159 |
187 struct net_device *dev /**< debug net_device */ |
160 int ec_dbgdev_open(struct net_device *dev /**< debug net_device */) |
188 ) |
161 { |
189 { |
162 ec_debug_t *dbg = *((ec_debug_t **) netdev_priv(dev)); |
190 ec_debug_t *dbg = *((ec_debug_t **) netdev_priv(dev)); |
163 dbg->opened = 1; |
191 dbg->opened = 1; |
164 EC_INFO("Debug interface %s opened.\n", dev->name); |
192 EC_INFO("Debug interface %s opened.\n", dev->name); |
165 return 0; |
193 return 0; |
166 } |
194 } |
167 |
195 |
168 /*****************************************************************************/ |
196 /*****************************************************************************/ |
169 |
197 |
170 /** |
198 /** Stops the virtual network device. |
171 Stops the virtual network device. |
199 */ |
172 */ |
200 int ec_dbgdev_stop( |
173 |
201 struct net_device *dev /**< debug net_device */ |
174 int ec_dbgdev_stop(struct net_device *dev /**< debug net_device */) |
202 ) |
175 { |
203 { |
176 ec_debug_t *dbg = *((ec_debug_t **) netdev_priv(dev)); |
204 ec_debug_t *dbg = *((ec_debug_t **) netdev_priv(dev)); |
177 dbg->opened = 0; |
205 dbg->opened = 0; |
178 EC_INFO("Debug interface %s stopped.\n", dev->name); |
206 EC_INFO("Debug interface %s stopped.\n", dev->name); |
179 return 0; |
207 return 0; |
180 } |
208 } |
181 |
209 |
182 /*****************************************************************************/ |
210 /*****************************************************************************/ |
183 |
211 |
184 /** |
212 /** Transmits data via the virtual network device. |
185 Transmits data via the virtual network device. |
213 */ |
186 */ |
214 int ec_dbgdev_tx( |
187 |
215 struct sk_buff *skb, /**< transmit socket buffer */ |
188 int ec_dbgdev_tx(struct sk_buff *skb, /**< transmit socket buffer */ |
216 struct net_device *dev /**< EoE net_device */ |
189 struct net_device *dev /**< EoE net_device */ |
217 ) |
190 ) |
|
191 { |
218 { |
192 ec_debug_t *dbg = *((ec_debug_t **) netdev_priv(dev)); |
219 ec_debug_t *dbg = *((ec_debug_t **) netdev_priv(dev)); |
193 |
220 |
194 dev_kfree_skb(skb); |
221 dev_kfree_skb(skb); |
195 dbg->stats.tx_dropped++; |
222 dbg->stats.tx_dropped++; |
196 return 0; |
223 return 0; |
197 } |
224 } |
198 |
225 |
199 /*****************************************************************************/ |
226 /*****************************************************************************/ |
200 |
227 |
201 /** |
228 /** Gets statistics about the virtual network device. |
202 Gets statistics about the virtual network device. |
229 */ |
203 */ |
230 struct net_device_stats *ec_dbgdev_stats( |
204 |
231 struct net_device *dev /**< debug net_device */ |
205 struct net_device_stats *ec_dbgdev_stats(struct net_device *dev |
232 ) |
206 /**< debug net_device */) |
|
207 { |
233 { |
208 ec_debug_t *dbg = *((ec_debug_t **) netdev_priv(dev)); |
234 ec_debug_t *dbg = *((ec_debug_t **) netdev_priv(dev)); |
209 return &dbg->stats; |
235 return &dbg->stats; |
210 } |
236 } |
211 |
237 |