diff options
author | Stefan Richter <stefanr@s5r6.in-berlin.de> | 2005-12-01 18:52:03 -0500 |
---|---|---|
committer | Jody McIntyre <scjody@modernduck.com> | 2005-12-01 18:52:03 -0500 |
commit | 741854e4f9a23421e194df8d846899172ff393d6 (patch) | |
tree | 2ca98e6bcc7515eb3065ffa2be8c0c535502b493 /drivers/ieee1394/ieee1394_core.c | |
parent | 546513f9fd96cba613cc2d025ee03d32d79394b7 (diff) |
ieee1394: whitespace cleanup in hosts.[ch], ieee1394_core.[ch]
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
Signed-off-by: Jody McIntyre <scjody@modernduck.com>
Diffstat (limited to 'drivers/ieee1394/ieee1394_core.c')
-rw-r--r-- | drivers/ieee1394/ieee1394_core.c | 762 |
1 files changed, 381 insertions, 381 deletions
diff --git a/drivers/ieee1394/ieee1394_core.c b/drivers/ieee1394/ieee1394_core.c index ff8a40980607..64fbbb01d52a 100644 --- a/drivers/ieee1394/ieee1394_core.c +++ b/drivers/ieee1394/ieee1394_core.c | |||
@@ -179,34 +179,34 @@ void hpsb_free_packet(struct hpsb_packet *packet) | |||
179 | 179 | ||
180 | int hpsb_reset_bus(struct hpsb_host *host, int type) | 180 | int hpsb_reset_bus(struct hpsb_host *host, int type) |
181 | { | 181 | { |
182 | if (!host->in_bus_reset) { | 182 | if (!host->in_bus_reset) { |
183 | host->driver->devctl(host, RESET_BUS, type); | 183 | host->driver->devctl(host, RESET_BUS, type); |
184 | return 0; | 184 | return 0; |
185 | } else { | 185 | } else { |
186 | return 1; | 186 | return 1; |
187 | } | 187 | } |
188 | } | 188 | } |
189 | 189 | ||
190 | 190 | ||
191 | int hpsb_bus_reset(struct hpsb_host *host) | 191 | int hpsb_bus_reset(struct hpsb_host *host) |
192 | { | 192 | { |
193 | if (host->in_bus_reset) { | 193 | if (host->in_bus_reset) { |
194 | HPSB_NOTICE("%s called while bus reset already in progress", | 194 | HPSB_NOTICE("%s called while bus reset already in progress", |
195 | __FUNCTION__); | 195 | __FUNCTION__); |
196 | return 1; | 196 | return 1; |
197 | } | 197 | } |
198 | 198 | ||
199 | abort_requests(host); | 199 | abort_requests(host); |
200 | host->in_bus_reset = 1; | 200 | host->in_bus_reset = 1; |
201 | host->irm_id = -1; | 201 | host->irm_id = -1; |
202 | host->is_irm = 0; | 202 | host->is_irm = 0; |
203 | host->busmgr_id = -1; | 203 | host->busmgr_id = -1; |
204 | host->is_busmgr = 0; | 204 | host->is_busmgr = 0; |
205 | host->is_cycmst = 0; | 205 | host->is_cycmst = 0; |
206 | host->node_count = 0; | 206 | host->node_count = 0; |
207 | host->selfid_count = 0; | 207 | host->selfid_count = 0; |
208 | 208 | ||
209 | return 0; | 209 | return 0; |
210 | } | 210 | } |
211 | 211 | ||
212 | 212 | ||
@@ -216,47 +216,47 @@ int hpsb_bus_reset(struct hpsb_host *host) | |||
216 | */ | 216 | */ |
217 | static int check_selfids(struct hpsb_host *host) | 217 | static int check_selfids(struct hpsb_host *host) |
218 | { | 218 | { |
219 | int nodeid = -1; | 219 | int nodeid = -1; |
220 | int rest_of_selfids = host->selfid_count; | 220 | int rest_of_selfids = host->selfid_count; |
221 | struct selfid *sid = (struct selfid *)host->topology_map; | 221 | struct selfid *sid = (struct selfid *)host->topology_map; |
222 | struct ext_selfid *esid; | 222 | struct ext_selfid *esid; |
223 | int esid_seq = 23; | 223 | int esid_seq = 23; |
224 | 224 | ||
225 | host->nodes_active = 0; | 225 | host->nodes_active = 0; |
226 | 226 | ||
227 | while (rest_of_selfids--) { | 227 | while (rest_of_selfids--) { |
228 | if (!sid->extended) { | 228 | if (!sid->extended) { |
229 | nodeid++; | 229 | nodeid++; |
230 | esid_seq = 0; | 230 | esid_seq = 0; |
231 | 231 | ||
232 | if (sid->phy_id != nodeid) { | 232 | if (sid->phy_id != nodeid) { |
233 | HPSB_INFO("SelfIDs failed monotony check with " | 233 | HPSB_INFO("SelfIDs failed monotony check with " |
234 | "%d", sid->phy_id); | 234 | "%d", sid->phy_id); |
235 | return 0; | 235 | return 0; |
236 | } | 236 | } |
237 | 237 | ||
238 | if (sid->link_active) { | 238 | if (sid->link_active) { |
239 | host->nodes_active++; | 239 | host->nodes_active++; |
240 | if (sid->contender) | 240 | if (sid->contender) |
241 | host->irm_id = LOCAL_BUS | sid->phy_id; | 241 | host->irm_id = LOCAL_BUS | sid->phy_id; |
242 | } | 242 | } |
243 | } else { | 243 | } else { |
244 | esid = (struct ext_selfid *)sid; | 244 | esid = (struct ext_selfid *)sid; |
245 | 245 | ||
246 | if ((esid->phy_id != nodeid) | 246 | if ((esid->phy_id != nodeid) |
247 | || (esid->seq_nr != esid_seq)) { | 247 | || (esid->seq_nr != esid_seq)) { |
248 | HPSB_INFO("SelfIDs failed monotony check with " | 248 | HPSB_INFO("SelfIDs failed monotony check with " |
249 | "%d/%d", esid->phy_id, esid->seq_nr); | 249 | "%d/%d", esid->phy_id, esid->seq_nr); |
250 | return 0; | 250 | return 0; |
251 | } | 251 | } |
252 | esid_seq++; | 252 | esid_seq++; |
253 | } | 253 | } |
254 | sid++; | 254 | sid++; |
255 | } | 255 | } |
256 | 256 | ||
257 | esid = (struct ext_selfid *)(sid - 1); | 257 | esid = (struct ext_selfid *)(sid - 1); |
258 | while (esid->extended) { | 258 | while (esid->extended) { |
259 | if ((esid->porta == SELFID_PORT_PARENT) || | 259 | if ((esid->porta == SELFID_PORT_PARENT) || |
260 | (esid->portb == SELFID_PORT_PARENT) || | 260 | (esid->portb == SELFID_PORT_PARENT) || |
261 | (esid->portc == SELFID_PORT_PARENT) || | 261 | (esid->portc == SELFID_PORT_PARENT) || |
262 | (esid->portd == SELFID_PORT_PARENT) || | 262 | (esid->portd == SELFID_PORT_PARENT) || |
@@ -267,47 +267,47 @@ static int check_selfids(struct hpsb_host *host) | |||
267 | HPSB_INFO("SelfIDs failed root check on " | 267 | HPSB_INFO("SelfIDs failed root check on " |
268 | "extended SelfID"); | 268 | "extended SelfID"); |
269 | return 0; | 269 | return 0; |
270 | } | 270 | } |
271 | esid--; | 271 | esid--; |
272 | } | 272 | } |
273 | 273 | ||
274 | sid = (struct selfid *)esid; | 274 | sid = (struct selfid *)esid; |
275 | if ((sid->port0 == SELFID_PORT_PARENT) || | 275 | if ((sid->port0 == SELFID_PORT_PARENT) || |
276 | (sid->port1 == SELFID_PORT_PARENT) || | 276 | (sid->port1 == SELFID_PORT_PARENT) || |
277 | (sid->port2 == SELFID_PORT_PARENT)) { | 277 | (sid->port2 == SELFID_PORT_PARENT)) { |
278 | HPSB_INFO("SelfIDs failed root check"); | 278 | HPSB_INFO("SelfIDs failed root check"); |
279 | return 0; | 279 | return 0; |
280 | } | 280 | } |
281 | 281 | ||
282 | host->node_count = nodeid + 1; | 282 | host->node_count = nodeid + 1; |
283 | return 1; | 283 | return 1; |
284 | } | 284 | } |
285 | 285 | ||
286 | static void build_speed_map(struct hpsb_host *host, int nodecount) | 286 | static void build_speed_map(struct hpsb_host *host, int nodecount) |
287 | { | 287 | { |
288 | u8 speedcap[nodecount]; | 288 | u8 speedcap[nodecount]; |
289 | u8 cldcnt[nodecount]; | 289 | u8 cldcnt[nodecount]; |
290 | u8 *map = host->speed_map; | 290 | u8 *map = host->speed_map; |
291 | struct selfid *sid; | 291 | struct selfid *sid; |
292 | struct ext_selfid *esid; | 292 | struct ext_selfid *esid; |
293 | int i, j, n; | 293 | int i, j, n; |
294 | 294 | ||
295 | for (i = 0; i < (nodecount * 64); i += 64) { | 295 | for (i = 0; i < (nodecount * 64); i += 64) { |
296 | for (j = 0; j < nodecount; j++) { | 296 | for (j = 0; j < nodecount; j++) { |
297 | map[i+j] = IEEE1394_SPEED_MAX; | 297 | map[i+j] = IEEE1394_SPEED_MAX; |
298 | } | 298 | } |
299 | } | 299 | } |
300 | 300 | ||
301 | for (i = 0; i < nodecount; i++) { | 301 | for (i = 0; i < nodecount; i++) { |
302 | cldcnt[i] = 0; | 302 | cldcnt[i] = 0; |
303 | } | 303 | } |
304 | 304 | ||
305 | /* find direct children count and speed */ | 305 | /* find direct children count and speed */ |
306 | for (sid = (struct selfid *)&host->topology_map[host->selfid_count-1], | 306 | for (sid = (struct selfid *)&host->topology_map[host->selfid_count-1], |
307 | n = nodecount - 1; | 307 | n = nodecount - 1; |
308 | (void *)sid >= (void *)host->topology_map; sid--) { | 308 | (void *)sid >= (void *)host->topology_map; sid--) { |
309 | if (sid->extended) { | 309 | if (sid->extended) { |
310 | esid = (struct ext_selfid *)sid; | 310 | esid = (struct ext_selfid *)sid; |
311 | 311 | ||
312 | if (esid->porta == SELFID_PORT_CHILD) cldcnt[n]++; | 312 | if (esid->porta == SELFID_PORT_CHILD) cldcnt[n]++; |
313 | if (esid->portb == SELFID_PORT_CHILD) cldcnt[n]++; | 313 | if (esid->portb == SELFID_PORT_CHILD) cldcnt[n]++; |
@@ -322,50 +322,50 @@ static void build_speed_map(struct hpsb_host *host, int nodecount) | |||
322 | if (sid->port1 == SELFID_PORT_CHILD) cldcnt[n]++; | 322 | if (sid->port1 == SELFID_PORT_CHILD) cldcnt[n]++; |
323 | if (sid->port2 == SELFID_PORT_CHILD) cldcnt[n]++; | 323 | if (sid->port2 == SELFID_PORT_CHILD) cldcnt[n]++; |
324 | 324 | ||
325 | speedcap[n] = sid->speed; | 325 | speedcap[n] = sid->speed; |
326 | n--; | 326 | n--; |
327 | } | 327 | } |
328 | } | 328 | } |
329 | 329 | ||
330 | /* set self mapping */ | 330 | /* set self mapping */ |
331 | for (i = 0; i < nodecount; i++) { | 331 | for (i = 0; i < nodecount; i++) { |
332 | map[64*i + i] = speedcap[i]; | 332 | map[64*i + i] = speedcap[i]; |
333 | } | 333 | } |
334 | 334 | ||
335 | /* fix up direct children count to total children count; | 335 | /* fix up direct children count to total children count; |
336 | * also fix up speedcaps for sibling and parent communication */ | 336 | * also fix up speedcaps for sibling and parent communication */ |
337 | for (i = 1; i < nodecount; i++) { | 337 | for (i = 1; i < nodecount; i++) { |
338 | for (j = cldcnt[i], n = i - 1; j > 0; j--) { | 338 | for (j = cldcnt[i], n = i - 1; j > 0; j--) { |
339 | cldcnt[i] += cldcnt[n]; | 339 | cldcnt[i] += cldcnt[n]; |
340 | speedcap[n] = min(speedcap[n], speedcap[i]); | 340 | speedcap[n] = min(speedcap[n], speedcap[i]); |
341 | n -= cldcnt[n] + 1; | 341 | n -= cldcnt[n] + 1; |
342 | } | 342 | } |
343 | } | 343 | } |
344 | 344 | ||
345 | for (n = 0; n < nodecount; n++) { | 345 | for (n = 0; n < nodecount; n++) { |
346 | for (i = n - cldcnt[n]; i <= n; i++) { | 346 | for (i = n - cldcnt[n]; i <= n; i++) { |
347 | for (j = 0; j < (n - cldcnt[n]); j++) { | 347 | for (j = 0; j < (n - cldcnt[n]); j++) { |
348 | map[j*64 + i] = map[i*64 + j] = | 348 | map[j*64 + i] = map[i*64 + j] = |
349 | min(map[i*64 + j], speedcap[n]); | 349 | min(map[i*64 + j], speedcap[n]); |
350 | } | 350 | } |
351 | for (j = n + 1; j < nodecount; j++) { | 351 | for (j = n + 1; j < nodecount; j++) { |
352 | map[j*64 + i] = map[i*64 + j] = | 352 | map[j*64 + i] = map[i*64 + j] = |
353 | min(map[i*64 + j], speedcap[n]); | 353 | min(map[i*64 + j], speedcap[n]); |
354 | } | 354 | } |
355 | } | 355 | } |
356 | } | 356 | } |
357 | } | 357 | } |
358 | 358 | ||
359 | 359 | ||
360 | void hpsb_selfid_received(struct hpsb_host *host, quadlet_t sid) | 360 | void hpsb_selfid_received(struct hpsb_host *host, quadlet_t sid) |
361 | { | 361 | { |
362 | if (host->in_bus_reset) { | 362 | if (host->in_bus_reset) { |
363 | HPSB_VERBOSE("Including SelfID 0x%x", sid); | 363 | HPSB_VERBOSE("Including SelfID 0x%x", sid); |
364 | host->topology_map[host->selfid_count++] = sid; | 364 | host->topology_map[host->selfid_count++] = sid; |
365 | } else { | 365 | } else { |
366 | HPSB_NOTICE("Spurious SelfID packet (0x%08x) received from bus %d", | 366 | HPSB_NOTICE("Spurious SelfID packet (0x%08x) received from bus %d", |
367 | sid, NODEID_TO_BUS(host->node_id)); | 367 | sid, NODEID_TO_BUS(host->node_id)); |
368 | } | 368 | } |
369 | } | 369 | } |
370 | 370 | ||
371 | void hpsb_selfid_complete(struct hpsb_host *host, int phyid, int isroot) | 371 | void hpsb_selfid_complete(struct hpsb_host *host, int phyid, int isroot) |
@@ -373,50 +373,50 @@ void hpsb_selfid_complete(struct hpsb_host *host, int phyid, int isroot) | |||
373 | if (!host->in_bus_reset) | 373 | if (!host->in_bus_reset) |
374 | HPSB_NOTICE("SelfID completion called outside of bus reset!"); | 374 | HPSB_NOTICE("SelfID completion called outside of bus reset!"); |
375 | 375 | ||
376 | host->node_id = LOCAL_BUS | phyid; | 376 | host->node_id = LOCAL_BUS | phyid; |
377 | host->is_root = isroot; | 377 | host->is_root = isroot; |
378 | 378 | ||
379 | if (!check_selfids(host)) { | 379 | if (!check_selfids(host)) { |
380 | if (host->reset_retries++ < 20) { | 380 | if (host->reset_retries++ < 20) { |
381 | /* selfid stage did not complete without error */ | 381 | /* selfid stage did not complete without error */ |
382 | HPSB_NOTICE("Error in SelfID stage, resetting"); | 382 | HPSB_NOTICE("Error in SelfID stage, resetting"); |
383 | host->in_bus_reset = 0; | 383 | host->in_bus_reset = 0; |
384 | /* this should work from ohci1394 now... */ | 384 | /* this should work from ohci1394 now... */ |
385 | hpsb_reset_bus(host, LONG_RESET); | 385 | hpsb_reset_bus(host, LONG_RESET); |
386 | return; | 386 | return; |
387 | } else { | 387 | } else { |
388 | HPSB_NOTICE("Stopping out-of-control reset loop"); | 388 | HPSB_NOTICE("Stopping out-of-control reset loop"); |
389 | HPSB_NOTICE("Warning - topology map and speed map will not be valid"); | 389 | HPSB_NOTICE("Warning - topology map and speed map will not be valid"); |
390 | host->reset_retries = 0; | 390 | host->reset_retries = 0; |
391 | } | 391 | } |
392 | } else { | 392 | } else { |
393 | host->reset_retries = 0; | 393 | host->reset_retries = 0; |
394 | build_speed_map(host, host->node_count); | 394 | build_speed_map(host, host->node_count); |
395 | } | 395 | } |
396 | 396 | ||
397 | HPSB_VERBOSE("selfid_complete called with successful SelfID stage " | 397 | HPSB_VERBOSE("selfid_complete called with successful SelfID stage " |
398 | "... irm_id: 0x%X node_id: 0x%X",host->irm_id,host->node_id); | 398 | "... irm_id: 0x%X node_id: 0x%X",host->irm_id,host->node_id); |
399 | 399 | ||
400 | /* irm_id is kept up to date by check_selfids() */ | 400 | /* irm_id is kept up to date by check_selfids() */ |
401 | if (host->irm_id == host->node_id) { | 401 | if (host->irm_id == host->node_id) { |
402 | host->is_irm = 1; | 402 | host->is_irm = 1; |
403 | } else { | 403 | } else { |
404 | host->is_busmgr = 0; | 404 | host->is_busmgr = 0; |
405 | host->is_irm = 0; | 405 | host->is_irm = 0; |
406 | } | 406 | } |
407 | 407 | ||
408 | if (isroot) { | 408 | if (isroot) { |
409 | host->driver->devctl(host, ACT_CYCLE_MASTER, 1); | 409 | host->driver->devctl(host, ACT_CYCLE_MASTER, 1); |
410 | host->is_cycmst = 1; | 410 | host->is_cycmst = 1; |
411 | } | 411 | } |
412 | atomic_inc(&host->generation); | 412 | atomic_inc(&host->generation); |
413 | host->in_bus_reset = 0; | 413 | host->in_bus_reset = 0; |
414 | highlevel_host_reset(host); | 414 | highlevel_host_reset(host); |
415 | } | 415 | } |
416 | 416 | ||
417 | 417 | ||
418 | void hpsb_packet_sent(struct hpsb_host *host, struct hpsb_packet *packet, | 418 | void hpsb_packet_sent(struct hpsb_host *host, struct hpsb_packet *packet, |
419 | int ackcode) | 419 | int ackcode) |
420 | { | 420 | { |
421 | unsigned long flags; | 421 | unsigned long flags; |
422 | 422 | ||
@@ -507,13 +507,13 @@ int hpsb_send_packet(struct hpsb_packet *packet) | |||
507 | { | 507 | { |
508 | struct hpsb_host *host = packet->host; | 508 | struct hpsb_host *host = packet->host; |
509 | 509 | ||
510 | if (host->is_shutdown) | 510 | if (host->is_shutdown) |
511 | return -EINVAL; | 511 | return -EINVAL; |
512 | if (host->in_bus_reset || | 512 | if (host->in_bus_reset || |
513 | (packet->generation != get_hpsb_generation(host))) | 513 | (packet->generation != get_hpsb_generation(host))) |
514 | return -EAGAIN; | 514 | return -EAGAIN; |
515 | 515 | ||
516 | packet->state = hpsb_queued; | 516 | packet->state = hpsb_queued; |
517 | 517 | ||
518 | /* This just seems silly to me */ | 518 | /* This just seems silly to me */ |
519 | WARN_ON(packet->no_waiter && packet->expect_response); | 519 | WARN_ON(packet->no_waiter && packet->expect_response); |
@@ -527,42 +527,42 @@ int hpsb_send_packet(struct hpsb_packet *packet) | |||
527 | skb_queue_tail(&host->pending_packet_queue, packet->skb); | 527 | skb_queue_tail(&host->pending_packet_queue, packet->skb); |
528 | } | 528 | } |
529 | 529 | ||
530 | if (packet->node_id == host->node_id) { | 530 | if (packet->node_id == host->node_id) { |
531 | /* it is a local request, so handle it locally */ | 531 | /* it is a local request, so handle it locally */ |
532 | 532 | ||
533 | quadlet_t *data; | 533 | quadlet_t *data; |
534 | size_t size = packet->data_size + packet->header_size; | 534 | size_t size = packet->data_size + packet->header_size; |
535 | 535 | ||
536 | data = kmalloc(size, GFP_ATOMIC); | 536 | data = kmalloc(size, GFP_ATOMIC); |
537 | if (!data) { | 537 | if (!data) { |
538 | HPSB_ERR("unable to allocate memory for concatenating header and data"); | 538 | HPSB_ERR("unable to allocate memory for concatenating header and data"); |
539 | return -ENOMEM; | 539 | return -ENOMEM; |
540 | } | 540 | } |
541 | 541 | ||
542 | memcpy(data, packet->header, packet->header_size); | 542 | memcpy(data, packet->header, packet->header_size); |
543 | 543 | ||
544 | if (packet->data_size) | 544 | if (packet->data_size) |
545 | memcpy(((u8*)data) + packet->header_size, packet->data, packet->data_size); | 545 | memcpy(((u8*)data) + packet->header_size, packet->data, packet->data_size); |
546 | 546 | ||
547 | dump_packet("send packet local", packet->header, packet->header_size, -1); | 547 | dump_packet("send packet local", packet->header, packet->header_size, -1); |
548 | 548 | ||
549 | hpsb_packet_sent(host, packet, packet->expect_response ? ACK_PENDING : ACK_COMPLETE); | 549 | hpsb_packet_sent(host, packet, packet->expect_response ? ACK_PENDING : ACK_COMPLETE); |
550 | hpsb_packet_received(host, data, size, 0); | 550 | hpsb_packet_received(host, data, size, 0); |
551 | 551 | ||
552 | kfree(data); | 552 | kfree(data); |
553 | 553 | ||
554 | return 0; | 554 | return 0; |
555 | } | 555 | } |
556 | 556 | ||
557 | if (packet->type == hpsb_async && packet->node_id != ALL_NODES) { | 557 | if (packet->type == hpsb_async && packet->node_id != ALL_NODES) { |
558 | packet->speed_code = | 558 | packet->speed_code = |
559 | host->speed_map[NODEID_TO_NODE(host->node_id) * 64 | 559 | host->speed_map[NODEID_TO_NODE(host->node_id) * 64 |
560 | + NODEID_TO_NODE(packet->node_id)]; | 560 | + NODEID_TO_NODE(packet->node_id)]; |
561 | } | 561 | } |
562 | 562 | ||
563 | dump_packet("send packet", packet->header, packet->header_size, packet->speed_code); | 563 | dump_packet("send packet", packet->header, packet->header_size, packet->speed_code); |
564 | 564 | ||
565 | return host->driver->transmit_packet(host, packet); | 565 | return host->driver->transmit_packet(host, packet); |
566 | } | 566 | } |
567 | 567 | ||
568 | /* We could just use complete() directly as the packet complete | 568 | /* We could just use complete() directly as the packet complete |
@@ -590,81 +590,81 @@ int hpsb_send_packet_and_wait(struct hpsb_packet *packet) | |||
590 | 590 | ||
591 | static void send_packet_nocare(struct hpsb_packet *packet) | 591 | static void send_packet_nocare(struct hpsb_packet *packet) |
592 | { | 592 | { |
593 | if (hpsb_send_packet(packet) < 0) { | 593 | if (hpsb_send_packet(packet) < 0) { |
594 | hpsb_free_packet(packet); | 594 | hpsb_free_packet(packet); |
595 | } | 595 | } |
596 | } | 596 | } |
597 | 597 | ||
598 | 598 | ||
599 | static void handle_packet_response(struct hpsb_host *host, int tcode, | 599 | static void handle_packet_response(struct hpsb_host *host, int tcode, |
600 | quadlet_t *data, size_t size) | 600 | quadlet_t *data, size_t size) |
601 | { | 601 | { |
602 | struct hpsb_packet *packet = NULL; | 602 | struct hpsb_packet *packet = NULL; |
603 | struct sk_buff *skb; | 603 | struct sk_buff *skb; |
604 | int tcode_match = 0; | 604 | int tcode_match = 0; |
605 | int tlabel; | 605 | int tlabel; |
606 | unsigned long flags; | 606 | unsigned long flags; |
607 | 607 | ||
608 | tlabel = (data[0] >> 10) & 0x3f; | 608 | tlabel = (data[0] >> 10) & 0x3f; |
609 | 609 | ||
610 | spin_lock_irqsave(&host->pending_packet_queue.lock, flags); | 610 | spin_lock_irqsave(&host->pending_packet_queue.lock, flags); |
611 | 611 | ||
612 | skb_queue_walk(&host->pending_packet_queue, skb) { | 612 | skb_queue_walk(&host->pending_packet_queue, skb) { |
613 | packet = (struct hpsb_packet *)skb->data; | 613 | packet = (struct hpsb_packet *)skb->data; |
614 | if ((packet->tlabel == tlabel) | 614 | if ((packet->tlabel == tlabel) |
615 | && (packet->node_id == (data[1] >> 16))){ | 615 | && (packet->node_id == (data[1] >> 16))){ |
616 | break; | 616 | break; |
617 | } | 617 | } |
618 | 618 | ||
619 | packet = NULL; | 619 | packet = NULL; |
620 | } | 620 | } |
621 | 621 | ||
622 | if (packet == NULL) { | 622 | if (packet == NULL) { |
623 | HPSB_DEBUG("unsolicited response packet received - no tlabel match"); | 623 | HPSB_DEBUG("unsolicited response packet received - no tlabel match"); |
624 | dump_packet("contents", data, 16, -1); | 624 | dump_packet("contents", data, 16, -1); |
625 | spin_unlock_irqrestore(&host->pending_packet_queue.lock, flags); | 625 | spin_unlock_irqrestore(&host->pending_packet_queue.lock, flags); |
626 | return; | 626 | return; |
627 | } | 627 | } |
628 | 628 | ||
629 | switch (packet->tcode) { | 629 | switch (packet->tcode) { |
630 | case TCODE_WRITEQ: | 630 | case TCODE_WRITEQ: |
631 | case TCODE_WRITEB: | 631 | case TCODE_WRITEB: |
632 | if (tcode != TCODE_WRITE_RESPONSE) | 632 | if (tcode != TCODE_WRITE_RESPONSE) |
633 | break; | 633 | break; |
634 | tcode_match = 1; | 634 | tcode_match = 1; |
635 | memcpy(packet->header, data, 12); | 635 | memcpy(packet->header, data, 12); |
636 | break; | 636 | break; |
637 | case TCODE_READQ: | 637 | case TCODE_READQ: |
638 | if (tcode != TCODE_READQ_RESPONSE) | 638 | if (tcode != TCODE_READQ_RESPONSE) |
639 | break; | 639 | break; |
640 | tcode_match = 1; | 640 | tcode_match = 1; |
641 | memcpy(packet->header, data, 16); | 641 | memcpy(packet->header, data, 16); |
642 | break; | 642 | break; |
643 | case TCODE_READB: | 643 | case TCODE_READB: |
644 | if (tcode != TCODE_READB_RESPONSE) | 644 | if (tcode != TCODE_READB_RESPONSE) |
645 | break; | 645 | break; |
646 | tcode_match = 1; | 646 | tcode_match = 1; |
647 | BUG_ON(packet->skb->len - sizeof(*packet) < size - 16); | 647 | BUG_ON(packet->skb->len - sizeof(*packet) < size - 16); |
648 | memcpy(packet->header, data, 16); | 648 | memcpy(packet->header, data, 16); |
649 | memcpy(packet->data, data + 4, size - 16); | 649 | memcpy(packet->data, data + 4, size - 16); |
650 | break; | 650 | break; |
651 | case TCODE_LOCK_REQUEST: | 651 | case TCODE_LOCK_REQUEST: |
652 | if (tcode != TCODE_LOCK_RESPONSE) | 652 | if (tcode != TCODE_LOCK_RESPONSE) |
653 | break; | 653 | break; |
654 | tcode_match = 1; | 654 | tcode_match = 1; |
655 | size = min((size - 16), (size_t)8); | 655 | size = min((size - 16), (size_t)8); |
656 | BUG_ON(packet->skb->len - sizeof(*packet) < size); | 656 | BUG_ON(packet->skb->len - sizeof(*packet) < size); |
657 | memcpy(packet->header, data, 16); | 657 | memcpy(packet->header, data, 16); |
658 | memcpy(packet->data, data + 4, size); | 658 | memcpy(packet->data, data + 4, size); |
659 | break; | 659 | break; |
660 | } | 660 | } |
661 | 661 | ||
662 | if (!tcode_match) { | 662 | if (!tcode_match) { |
663 | spin_unlock_irqrestore(&host->pending_packet_queue.lock, flags); | 663 | spin_unlock_irqrestore(&host->pending_packet_queue.lock, flags); |
664 | HPSB_INFO("unsolicited response packet received - tcode mismatch"); | 664 | HPSB_INFO("unsolicited response packet received - tcode mismatch"); |
665 | dump_packet("contents", data, 16, -1); | 665 | dump_packet("contents", data, 16, -1); |
666 | return; | 666 | return; |
667 | } | 667 | } |
668 | 668 | ||
669 | __skb_unlink(skb, &host->pending_packet_queue); | 669 | __skb_unlink(skb, &host->pending_packet_queue); |
670 | 670 | ||
@@ -683,27 +683,27 @@ static void handle_packet_response(struct hpsb_host *host, int tcode, | |||
683 | static struct hpsb_packet *create_reply_packet(struct hpsb_host *host, | 683 | static struct hpsb_packet *create_reply_packet(struct hpsb_host *host, |
684 | quadlet_t *data, size_t dsize) | 684 | quadlet_t *data, size_t dsize) |
685 | { | 685 | { |
686 | struct hpsb_packet *p; | 686 | struct hpsb_packet *p; |
687 | 687 | ||
688 | p = hpsb_alloc_packet(dsize); | 688 | p = hpsb_alloc_packet(dsize); |
689 | if (unlikely(p == NULL)) { | 689 | if (unlikely(p == NULL)) { |
690 | /* FIXME - send data_error response */ | 690 | /* FIXME - send data_error response */ |
691 | return NULL; | 691 | return NULL; |
692 | } | 692 | } |
693 | 693 | ||
694 | p->type = hpsb_async; | 694 | p->type = hpsb_async; |
695 | p->state = hpsb_unused; | 695 | p->state = hpsb_unused; |
696 | p->host = host; | 696 | p->host = host; |
697 | p->node_id = data[1] >> 16; | 697 | p->node_id = data[1] >> 16; |
698 | p->tlabel = (data[0] >> 10) & 0x3f; | 698 | p->tlabel = (data[0] >> 10) & 0x3f; |
699 | p->no_waiter = 1; | 699 | p->no_waiter = 1; |
700 | 700 | ||
701 | p->generation = get_hpsb_generation(host); | 701 | p->generation = get_hpsb_generation(host); |
702 | 702 | ||
703 | if (dsize % 4) | 703 | if (dsize % 4) |
704 | p->data[dsize / 4] = 0; | 704 | p->data[dsize / 4] = 0; |
705 | 705 | ||
706 | return p; | 706 | return p; |
707 | } | 707 | } |
708 | 708 | ||
709 | #define PREP_ASYNC_HEAD_RCODE(tc) \ | 709 | #define PREP_ASYNC_HEAD_RCODE(tc) \ |
@@ -714,7 +714,7 @@ static struct hpsb_packet *create_reply_packet(struct hpsb_host *host, | |||
714 | packet->header[2] = 0 | 714 | packet->header[2] = 0 |
715 | 715 | ||
716 | static void fill_async_readquad_resp(struct hpsb_packet *packet, int rcode, | 716 | static void fill_async_readquad_resp(struct hpsb_packet *packet, int rcode, |
717 | quadlet_t data) | 717 | quadlet_t data) |
718 | { | 718 | { |
719 | PREP_ASYNC_HEAD_RCODE(TCODE_READQ_RESPONSE); | 719 | PREP_ASYNC_HEAD_RCODE(TCODE_READQ_RESPONSE); |
720 | packet->header[3] = data; | 720 | packet->header[3] = data; |
@@ -723,7 +723,7 @@ static void fill_async_readquad_resp(struct hpsb_packet *packet, int rcode, | |||
723 | } | 723 | } |
724 | 724 | ||
725 | static void fill_async_readblock_resp(struct hpsb_packet *packet, int rcode, | 725 | static void fill_async_readblock_resp(struct hpsb_packet *packet, int rcode, |
726 | int length) | 726 | int length) |
727 | { | 727 | { |
728 | if (rcode != RCODE_COMPLETE) | 728 | if (rcode != RCODE_COMPLETE) |
729 | length = 0; | 729 | length = 0; |
@@ -743,7 +743,7 @@ static void fill_async_write_resp(struct hpsb_packet *packet, int rcode) | |||
743 | } | 743 | } |
744 | 744 | ||
745 | static void fill_async_lock_resp(struct hpsb_packet *packet, int rcode, int extcode, | 745 | static void fill_async_lock_resp(struct hpsb_packet *packet, int rcode, int extcode, |
746 | int length) | 746 | int length) |
747 | { | 747 | { |
748 | if (rcode != RCODE_COMPLETE) | 748 | if (rcode != RCODE_COMPLETE) |
749 | length = 0; | 749 | length = 0; |
@@ -755,184 +755,184 @@ static void fill_async_lock_resp(struct hpsb_packet *packet, int rcode, int extc | |||
755 | } | 755 | } |
756 | 756 | ||
757 | #define PREP_REPLY_PACKET(length) \ | 757 | #define PREP_REPLY_PACKET(length) \ |
758 | packet = create_reply_packet(host, data, length); \ | 758 | packet = create_reply_packet(host, data, length); \ |
759 | if (packet == NULL) break | 759 | if (packet == NULL) break |
760 | 760 | ||
761 | static void handle_incoming_packet(struct hpsb_host *host, int tcode, | 761 | static void handle_incoming_packet(struct hpsb_host *host, int tcode, |
762 | quadlet_t *data, size_t size, int write_acked) | 762 | quadlet_t *data, size_t size, int write_acked) |
763 | { | 763 | { |
764 | struct hpsb_packet *packet; | 764 | struct hpsb_packet *packet; |
765 | int length, rcode, extcode; | 765 | int length, rcode, extcode; |
766 | quadlet_t buffer; | 766 | quadlet_t buffer; |
767 | nodeid_t source = data[1] >> 16; | 767 | nodeid_t source = data[1] >> 16; |
768 | nodeid_t dest = data[0] >> 16; | 768 | nodeid_t dest = data[0] >> 16; |
769 | u16 flags = (u16) data[0]; | 769 | u16 flags = (u16) data[0]; |
770 | u64 addr; | 770 | u64 addr; |
771 | 771 | ||
772 | /* big FIXME - no error checking is done for an out of bounds length */ | 772 | /* big FIXME - no error checking is done for an out of bounds length */ |
773 | 773 | ||
774 | switch (tcode) { | 774 | switch (tcode) { |
775 | case TCODE_WRITEQ: | 775 | case TCODE_WRITEQ: |
776 | addr = (((u64)(data[1] & 0xffff)) << 32) | data[2]; | 776 | addr = (((u64)(data[1] & 0xffff)) << 32) | data[2]; |
777 | rcode = highlevel_write(host, source, dest, data+3, | 777 | rcode = highlevel_write(host, source, dest, data+3, |
778 | addr, 4, flags); | 778 | addr, 4, flags); |
779 | 779 | ||
780 | if (!write_acked | 780 | if (!write_acked |
781 | && (NODEID_TO_NODE(data[0] >> 16) != NODE_MASK) | 781 | && (NODEID_TO_NODE(data[0] >> 16) != NODE_MASK) |
782 | && (rcode >= 0)) { | 782 | && (rcode >= 0)) { |
783 | /* not a broadcast write, reply */ | 783 | /* not a broadcast write, reply */ |
784 | PREP_REPLY_PACKET(0); | 784 | PREP_REPLY_PACKET(0); |
785 | fill_async_write_resp(packet, rcode); | 785 | fill_async_write_resp(packet, rcode); |
786 | send_packet_nocare(packet); | 786 | send_packet_nocare(packet); |
787 | } | 787 | } |
788 | break; | 788 | break; |
789 | 789 | ||
790 | case TCODE_WRITEB: | 790 | case TCODE_WRITEB: |
791 | addr = (((u64)(data[1] & 0xffff)) << 32) | data[2]; | 791 | addr = (((u64)(data[1] & 0xffff)) << 32) | data[2]; |
792 | rcode = highlevel_write(host, source, dest, data+4, | 792 | rcode = highlevel_write(host, source, dest, data+4, |
793 | addr, data[3]>>16, flags); | 793 | addr, data[3]>>16, flags); |
794 | 794 | ||
795 | if (!write_acked | 795 | if (!write_acked |
796 | && (NODEID_TO_NODE(data[0] >> 16) != NODE_MASK) | 796 | && (NODEID_TO_NODE(data[0] >> 16) != NODE_MASK) |
797 | && (rcode >= 0)) { | 797 | && (rcode >= 0)) { |
798 | /* not a broadcast write, reply */ | 798 | /* not a broadcast write, reply */ |
799 | PREP_REPLY_PACKET(0); | 799 | PREP_REPLY_PACKET(0); |
800 | fill_async_write_resp(packet, rcode); | 800 | fill_async_write_resp(packet, rcode); |
801 | send_packet_nocare(packet); | 801 | send_packet_nocare(packet); |
802 | } | 802 | } |
803 | break; | 803 | break; |
804 | 804 | ||
805 | case TCODE_READQ: | 805 | case TCODE_READQ: |
806 | addr = (((u64)(data[1] & 0xffff)) << 32) | data[2]; | 806 | addr = (((u64)(data[1] & 0xffff)) << 32) | data[2]; |
807 | rcode = highlevel_read(host, source, &buffer, addr, 4, flags); | 807 | rcode = highlevel_read(host, source, &buffer, addr, 4, flags); |
808 | 808 | ||
809 | if (rcode >= 0) { | 809 | if (rcode >= 0) { |
810 | PREP_REPLY_PACKET(0); | 810 | PREP_REPLY_PACKET(0); |
811 | fill_async_readquad_resp(packet, rcode, buffer); | 811 | fill_async_readquad_resp(packet, rcode, buffer); |
812 | send_packet_nocare(packet); | 812 | send_packet_nocare(packet); |
813 | } | 813 | } |
814 | break; | 814 | break; |
815 | 815 | ||
816 | case TCODE_READB: | 816 | case TCODE_READB: |
817 | length = data[3] >> 16; | 817 | length = data[3] >> 16; |
818 | PREP_REPLY_PACKET(length); | 818 | PREP_REPLY_PACKET(length); |
819 | 819 | ||
820 | addr = (((u64)(data[1] & 0xffff)) << 32) | data[2]; | 820 | addr = (((u64)(data[1] & 0xffff)) << 32) | data[2]; |
821 | rcode = highlevel_read(host, source, packet->data, addr, | 821 | rcode = highlevel_read(host, source, packet->data, addr, |
822 | length, flags); | 822 | length, flags); |
823 | 823 | ||
824 | if (rcode >= 0) { | 824 | if (rcode >= 0) { |
825 | fill_async_readblock_resp(packet, rcode, length); | 825 | fill_async_readblock_resp(packet, rcode, length); |
826 | send_packet_nocare(packet); | 826 | send_packet_nocare(packet); |
827 | } else { | 827 | } else { |
828 | hpsb_free_packet(packet); | 828 | hpsb_free_packet(packet); |
829 | } | 829 | } |
830 | break; | 830 | break; |
831 | 831 | ||
832 | case TCODE_LOCK_REQUEST: | 832 | case TCODE_LOCK_REQUEST: |
833 | length = data[3] >> 16; | 833 | length = data[3] >> 16; |
834 | extcode = data[3] & 0xffff; | 834 | extcode = data[3] & 0xffff; |
835 | addr = (((u64)(data[1] & 0xffff)) << 32) | data[2]; | 835 | addr = (((u64)(data[1] & 0xffff)) << 32) | data[2]; |
836 | 836 | ||
837 | PREP_REPLY_PACKET(8); | 837 | PREP_REPLY_PACKET(8); |
838 | 838 | ||
839 | if ((extcode == 0) || (extcode >= 7)) { | 839 | if ((extcode == 0) || (extcode >= 7)) { |
840 | /* let switch default handle error */ | 840 | /* let switch default handle error */ |
841 | length = 0; | 841 | length = 0; |
842 | } | 842 | } |
843 | 843 | ||
844 | switch (length) { | 844 | switch (length) { |
845 | case 4: | 845 | case 4: |
846 | rcode = highlevel_lock(host, source, packet->data, addr, | 846 | rcode = highlevel_lock(host, source, packet->data, addr, |
847 | data[4], 0, extcode,flags); | 847 | data[4], 0, extcode,flags); |
848 | fill_async_lock_resp(packet, rcode, extcode, 4); | 848 | fill_async_lock_resp(packet, rcode, extcode, 4); |
849 | break; | 849 | break; |
850 | case 8: | 850 | case 8: |
851 | if ((extcode != EXTCODE_FETCH_ADD) | 851 | if ((extcode != EXTCODE_FETCH_ADD) |
852 | && (extcode != EXTCODE_LITTLE_ADD)) { | 852 | && (extcode != EXTCODE_LITTLE_ADD)) { |
853 | rcode = highlevel_lock(host, source, | 853 | rcode = highlevel_lock(host, source, |
854 | packet->data, addr, | 854 | packet->data, addr, |
855 | data[5], data[4], | 855 | data[5], data[4], |
856 | extcode, flags); | 856 | extcode, flags); |
857 | fill_async_lock_resp(packet, rcode, extcode, 4); | 857 | fill_async_lock_resp(packet, rcode, extcode, 4); |
858 | } else { | 858 | } else { |
859 | rcode = highlevel_lock64(host, source, | 859 | rcode = highlevel_lock64(host, source, |
860 | (octlet_t *)packet->data, addr, | 860 | (octlet_t *)packet->data, addr, |
861 | *(octlet_t *)(data + 4), 0ULL, | 861 | *(octlet_t *)(data + 4), 0ULL, |
862 | extcode, flags); | 862 | extcode, flags); |
863 | fill_async_lock_resp(packet, rcode, extcode, 8); | 863 | fill_async_lock_resp(packet, rcode, extcode, 8); |
864 | } | 864 | } |
865 | break; | 865 | break; |
866 | case 16: | 866 | case 16: |
867 | rcode = highlevel_lock64(host, source, | 867 | rcode = highlevel_lock64(host, source, |
868 | (octlet_t *)packet->data, addr, | 868 | (octlet_t *)packet->data, addr, |
869 | *(octlet_t *)(data + 6), | 869 | *(octlet_t *)(data + 6), |
870 | *(octlet_t *)(data + 4), | 870 | *(octlet_t *)(data + 4), |
871 | extcode, flags); | 871 | extcode, flags); |
872 | fill_async_lock_resp(packet, rcode, extcode, 8); | 872 | fill_async_lock_resp(packet, rcode, extcode, 8); |
873 | break; | 873 | break; |
874 | default: | 874 | default: |
875 | rcode = RCODE_TYPE_ERROR; | 875 | rcode = RCODE_TYPE_ERROR; |
876 | fill_async_lock_resp(packet, rcode, | 876 | fill_async_lock_resp(packet, rcode, |
877 | extcode, 0); | 877 | extcode, 0); |
878 | } | 878 | } |
879 | 879 | ||
880 | if (rcode >= 0) { | 880 | if (rcode >= 0) { |
881 | send_packet_nocare(packet); | 881 | send_packet_nocare(packet); |
882 | } else { | 882 | } else { |
883 | hpsb_free_packet(packet); | 883 | hpsb_free_packet(packet); |
884 | } | 884 | } |
885 | break; | 885 | break; |
886 | } | 886 | } |
887 | 887 | ||
888 | } | 888 | } |
889 | #undef PREP_REPLY_PACKET | 889 | #undef PREP_REPLY_PACKET |
890 | 890 | ||
891 | 891 | ||
892 | void hpsb_packet_received(struct hpsb_host *host, quadlet_t *data, size_t size, | 892 | void hpsb_packet_received(struct hpsb_host *host, quadlet_t *data, size_t size, |
893 | int write_acked) | 893 | int write_acked) |
894 | { | 894 | { |
895 | int tcode; | 895 | int tcode; |
896 | 896 | ||
897 | if (host->in_bus_reset) { | 897 | if (host->in_bus_reset) { |
898 | HPSB_INFO("received packet during reset; ignoring"); | 898 | HPSB_INFO("received packet during reset; ignoring"); |
899 | return; | 899 | return; |
900 | } | 900 | } |
901 | 901 | ||
902 | dump_packet("received packet", data, size, -1); | 902 | dump_packet("received packet", data, size, -1); |
903 | 903 | ||
904 | tcode = (data[0] >> 4) & 0xf; | 904 | tcode = (data[0] >> 4) & 0xf; |
905 | 905 | ||
906 | switch (tcode) { | 906 | switch (tcode) { |
907 | case TCODE_WRITE_RESPONSE: | 907 | case TCODE_WRITE_RESPONSE: |
908 | case TCODE_READQ_RESPONSE: | 908 | case TCODE_READQ_RESPONSE: |
909 | case TCODE_READB_RESPONSE: | 909 | case TCODE_READB_RESPONSE: |
910 | case TCODE_LOCK_RESPONSE: | 910 | case TCODE_LOCK_RESPONSE: |
911 | handle_packet_response(host, tcode, data, size); | 911 | handle_packet_response(host, tcode, data, size); |
912 | break; | 912 | break; |
913 | 913 | ||
914 | case TCODE_WRITEQ: | 914 | case TCODE_WRITEQ: |
915 | case TCODE_WRITEB: | 915 | case TCODE_WRITEB: |
916 | case TCODE_READQ: | 916 | case TCODE_READQ: |
917 | case TCODE_READB: | 917 | case TCODE_READB: |
918 | case TCODE_LOCK_REQUEST: | 918 | case TCODE_LOCK_REQUEST: |
919 | handle_incoming_packet(host, tcode, data, size, write_acked); | 919 | handle_incoming_packet(host, tcode, data, size, write_acked); |
920 | break; | 920 | break; |
921 | 921 | ||
922 | 922 | ||
923 | case TCODE_ISO_DATA: | 923 | case TCODE_ISO_DATA: |
924 | highlevel_iso_receive(host, data, size); | 924 | highlevel_iso_receive(host, data, size); |
925 | break; | 925 | break; |
926 | 926 | ||
927 | case TCODE_CYCLE_START: | 927 | case TCODE_CYCLE_START: |
928 | /* simply ignore this packet if it is passed on */ | 928 | /* simply ignore this packet if it is passed on */ |
929 | break; | 929 | break; |
930 | 930 | ||
931 | default: | 931 | default: |
932 | HPSB_NOTICE("received packet with bogus transaction code %d", | 932 | HPSB_NOTICE("received packet with bogus transaction code %d", |
933 | tcode); | 933 | tcode); |
934 | break; | 934 | break; |
935 | } | 935 | } |
936 | } | 936 | } |
937 | 937 | ||
938 | 938 | ||
@@ -1126,7 +1126,7 @@ static int __init ieee1394_init(void) | |||
1126 | nodemgr implements functionality required of ieee1394a-2000 | 1126 | nodemgr implements functionality required of ieee1394a-2000 |
1127 | IRMs */ | 1127 | IRMs */ |
1128 | hpsb_disable_irm = 1; | 1128 | hpsb_disable_irm = 1; |
1129 | 1129 | ||
1130 | return 0; | 1130 | return 0; |
1131 | } | 1131 | } |
1132 | 1132 | ||