firewire: Use lib/ implementation of CRC ITU-T.

With the CRC ITU-T implementation available in lib/ we can use that instead.

This also fixes a bug in the topology map crc computation.

Signed-off-by: Kristian Hoegsberg <[e-mail]>
Signed-off-by: Stefan Richter <[e-mail]> (fixed Kconfig)

drivers/firewire/Kconfig

···
 config FIREWIRE
 	tristate "IEEE 1394 (FireWire) support (JUJU alternative stack, experimental)"
 	depends on EXPERIMENTAL
+	select CRC_ITU_T
 	help
 	  IEEE 1394 describes a high performance serial bus, which is also
 	  known as FireWire(tm) or i.Link(tm) and is used for connecting all

drivers/firewire/fw-card.c

···
 #include <linux/errno.h>
 #include <linux/device.h>
 #include <linux/rwsem.h>
+#include <linux/crc-itu-t.h>
 #include "fw-transaction.h"
 #include "fw-topology.h"
 #include "fw-device.h"
 
-/* The lib/crc16.c implementation uses the standard (0x8005)
- * polynomial, but we need the ITU-T (or CCITT) polynomial (0x1021).
- * The implementation below works on an array of host-endian u32
- * words, assuming they'll be transmited msb first. */
-u16
-crc16_itu_t(const u32 *buffer, size_t length)
+int fw_compute_block_crc(u32 *block)
 {
-	int shift, i;
-	u32 data;
-	u16 sum, crc = 0;
+	__be32 be32_block[256];
+	int i, length;
 
-	for (i = 0; i < length; i++) {
-		data = *buffer++;
-		for (shift = 28; shift >= 0; shift -= 4 ) {
-			sum = ((crc >> 12) ^ (data >> shift)) & 0xf;
-			crc = (crc << 4) ^ (sum << 12) ^ (sum << 5) ^ (sum);
-		}
-		crc &= 0xffff;
-	}
+	length = (*block >> 16) & 0xff;
+	for (i = 0; i < length; i++)
+		be32_block[i] = cpu_to_be32(block[i + 1]);
+	*block |= crc_itu_t(0, (u8 *) be32_block, length * 4);
 
-	return crc;
+	return length;
 }
 
 static DECLARE_RWSEM(card_rwsem);
···
 	 * assumes that CRC length and info length are identical for
 	 * the bus info block, which is always the case for this
 	 * implementation. */
-	for (i = 0; i < j; i += length + 1) {
-		length = (config_rom[i] >> 16) & 0xff;
-		config_rom[i] |= crc16_itu_t(&config_rom[i + 1], length);
-	}
+	for (i = 0; i < j; i += length + 1)
+		length = fw_compute_block_crc(config_rom + i);
 
 	*config_rom_length = j;
 

drivers/firewire/fw-topology.c

···
 update_topology_map(struct fw_card *card, u32 *self_ids, int self_id_count)
 {
 	int node_count;
-	u32 crc;
 
 	card->topology_map[1]++;
 	node_count = (card->root_node->node_id & 0x3f) + 1;
 	card->topology_map[2] = (node_count << 16) | self_id_count;
-	crc = crc16_itu_t(card->topology_map + 1, self_id_count + 2);
-	card->topology_map[0] = ((self_id_count + 2) << 16) | crc;
+	card->topology_map[0] = (self_id_count + 2) << 16;
 	memcpy(&card->topology_map[3], self_ids, self_id_count * 4);
+	fw_compute_block_crc(card->topology_map);
 }
 
 void

drivers/firewire/fw-topology.h

···
 void
 fw_destroy_nodes(struct fw_card *card);
 
-u16
-crc16_itu_t(const u32 *buffer, size_t length);
+int
+fw_compute_block_crc(u32 *block);
+
 
 #endif /* __fw_topology_h */