drivers/thunderbolt/eeprom.c

18 static int tb_eeprom_ctl_write(struct tb_switch *sw, struct tb_eeprom_ctl *ctl)
20 	return tb_sw_write(sw, ctl, TB_CFG_SWITCH, sw->cap_plug_events + ROUTER_CS_4, 1);
26 static int tb_eeprom_ctl_read(struct tb_switch *sw, struct tb_eeprom_ctl *ctl)
28 	return tb_sw_read(sw, ctl, TB_CFG_SWITCH, sw->cap_plug_events + ROUTER_CS_4, 1);
42 static int tb_eeprom_active(struct tb_switch *sw, bool enable)
45 	int res = tb_eeprom_ctl_read(sw, &ctl);
50 		res = tb_eeprom_ctl_write(sw, &ctl);
54 		return tb_eeprom_ctl_write(sw, &ctl);
57 		res = tb_eeprom_ctl_write(sw, &ctl);
61 		return tb_eeprom_ctl_write(sw, &ctl);
71 static int tb_eeprom_transfer(struct tb_switch *sw, struct tb_eeprom_ctl *ctl,
76 		res = tb_eeprom_ctl_write(sw, ctl);
81 	res = tb_eeprom_ctl_write(sw, ctl);
85 		res = tb_eeprom_ctl_read(sw, ctl);
90 	return tb_eeprom_ctl_write(sw, ctl);
96 static int tb_eeprom_out(struct tb_switch *sw, u8 val)
100 	int res = tb_eeprom_ctl_read(sw, &ctl);
105 		res = tb_eeprom_transfer(sw, &ctl, TB_EEPROM_OUT);
116 static int tb_eeprom_in(struct tb_switch *sw, u8 *val)
120 	int res = tb_eeprom_ctl_read(sw, &ctl);
126 		res = tb_eeprom_transfer(sw, &ctl, TB_EEPROM_IN);
137 static int tb_eeprom_get_drom_offset(struct tb_switch *sw, u16 *offset)
142 	if (!sw->cap_plug_events) {
143 		tb_sw_warn(sw, "no TB_CAP_PLUG_EVENTS, cannot read eeprom\n");
146 	res = tb_sw_read(sw, &cap, TB_CFG_SWITCH, sw->cap_plug_events,
152 		tb_sw_warn(sw, "no NVM\n");
157 		tb_sw_warn(sw, "drom offset is larger than 0xffff: %#x\n",
168 static int tb_eeprom_read_n(struct tb_switch *sw, u16 offset, u8 *val,
174 	res = tb_eeprom_get_drom_offset(sw, &drom_offset);
180 	res = tb_eeprom_active(sw, true);
183 	res = tb_eeprom_out(sw, 3);
186 	res = tb_eeprom_out(sw, offset >> 8);
189 	res = tb_eeprom_out(sw, offset);
193 		res = tb_eeprom_in(sw, val + i);
197 	return tb_eeprom_active(sw, false);
296  * @sw: Router whose UID to read
299  * Does not use the cached copy in sw->drom. Used during resume to check switch
302 int tb_drom_read_uid_only(struct tb_switch *sw, u64 *uid)
309 	res = tb_eeprom_read_n(sw, 0, data, 9);
315 		tb_sw_warn(sw, "uid crc8 mismatch (expected: %#x, got: %#x)\n",
324 static int tb_drom_parse_entry_generic(struct tb_switch *sw,
333 		sw->vendor_name = kstrndup(entry->data,
335 		if (!sw->vendor_name)
340 		sw->device_name = kstrndup(entry->data,
342 		if (!sw->device_name)
349 		if (!sw->vendor && !sw->device) {
350 			sw->vendor = desc->idVendor;
351 			sw->device = desc->idProduct;
360 static int tb_drom_parse_entry_port(struct tb_switch *sw,
371 	if (header->index > sw->config.max_port_number) {
372 		dev_info_once(&sw->dev, "ignoring unnecessary extra entries in DROM\n");
376 	port = &sw->ports[header->index];
389 			tb_sw_warn(sw,
397 				&port->sw->ports[entry->dual_link_port_nr];
405  * Drom must have been copied to sw->drom.
407 static int tb_drom_parse_entries(struct tb_switch *sw, size_t header_size)
409 	struct tb_drom_header *header = (void *) sw->drom;
415 		struct tb_drom_entry_header *entry = (void *) (sw->drom + pos);
418 			tb_sw_warn(sw, "DROM buffer overrun\n");
424 			res = tb_drom_parse_entry_generic(sw, entry);
427 			res = tb_drom_parse_entry_port(sw, entry);
439  * tb_drom_copy_efi - copy drom supplied by EFI to sw->drom if present
441 static int tb_drom_copy_efi(struct tb_switch *sw, u16 *size)
443 	struct device *dev = &sw->tb->nhi->pdev->dev;
450 	sw->drom = kmalloc(len, GFP_KERNEL);
451 	if (!sw->drom)
454 	res = device_property_read_u8_array(dev, "ThunderboltDROM", sw->drom,
459 	*size = ((struct tb_drom_header *)sw->drom)->data_len +
467 	kfree(sw->drom);
468 	sw->drom = NULL;
472 static int tb_drom_copy_nvm(struct tb_switch *sw, u16 *size)
477 	if (!sw->dma_port)
480 	ret = tb_eeprom_get_drom_offset(sw, &drom_offset);
487 	ret = dma_port_flash_read(sw->dma_port, drom_offset + 14, size,
494 	sw->drom = kzalloc(*size, GFP_KERNEL);
495 	if (!sw->drom)
498 	ret = dma_port_flash_read(sw->dma_port, drom_offset, sw->drom, *size);
506 	tb_drom_read_uid_only(sw, &sw->uid);
510 	kfree(sw->drom);
511 	sw->drom = NULL;
515 static int usb4_copy_drom(struct tb_switch *sw, u16 *size)
519 	ret = usb4_switch_drom_read(sw, 14, size, sizeof(*size));
525 	sw->drom = kzalloc(*size, GFP_KERNEL);
526 	if (!sw->drom)
529 	ret = usb4_switch_drom_read(sw, 0, sw->drom, *size);
531 		kfree(sw->drom);
532 		sw->drom = NULL;
538 static int tb_drom_bit_bang(struct tb_switch *sw, u16 *size)
542 	ret = tb_eeprom_read_n(sw, 14, (u8 *)size, 2);
549 	tb_sw_dbg(sw, "reading DROM (length: %#x)\n", *size);
551 		tb_sw_warn(sw, "DROM too small, aborting\n");
555 	sw->drom = kzalloc(*size, GFP_KERNEL);
556 	if (!sw->drom)
559 	ret = tb_eeprom_read_n(sw, 0, sw->drom, *size);
566 	kfree(sw->drom);
567 	sw->drom = NULL;
571 static int tb_drom_parse_v1(struct tb_switch *sw)
574 		(const struct tb_drom_header *)sw->drom;
579 		tb_sw_warn(sw,
584 	if (!sw->uid)
585 		sw->uid = header->uid;
586 	sw->vendor = header->vendor_id;
587 	sw->device = header->model_id;
589 	crc = tb_crc32(sw->drom + TB_DROM_DATA_START, header->data_len);
591 		tb_sw_warn(sw,
596 	return tb_drom_parse_entries(sw, TB_DROM_HEADER_SIZE);
599 static int usb4_drom_parse(struct tb_switch *sw)
602 		(const struct tb_drom_header *)sw->drom;
605 	crc = tb_crc32(sw->drom + TB_DROM_DATA_START, header->data_len);
607 		tb_sw_warn(sw,
612 	return tb_drom_parse_entries(sw, USB4_DROM_HEADER_SIZE);
615 static int tb_drom_parse(struct tb_switch *sw, u16 size)
617 	const struct tb_drom_header *header = (const void *)sw->drom;
621 		tb_sw_warn(sw, "DROM size mismatch\n");
626 	tb_sw_dbg(sw, "DROM version: %d\n", header->device_rom_revision);
630 		ret = usb4_drom_parse(sw);
633 		tb_sw_warn(sw, "DROM device_rom_revision %#x unknown\n",
637 		ret = tb_drom_parse_v1(sw);
642 		tb_sw_warn(sw, "parsing DROM failed\n");
649 	kfree(sw->drom);
650 	sw->drom = NULL;
655 static int tb_drom_host_read(struct tb_switch *sw)
659 	if (tb_switch_is_usb4(sw)) {
660 		usb4_switch_read_uid(sw, &sw->uid);
661 		if (!usb4_copy_drom(sw, &size))
662 			return tb_drom_parse(sw, size);
664 		if (!tb_drom_copy_efi(sw, &size))
665 			return tb_drom_parse(sw, size);
667 		if (!tb_drom_copy_nvm(sw, &size))
668 			return tb_drom_parse(sw, size);
670 		tb_drom_read_uid_only(sw, &sw->uid);
676 static int tb_drom_device_read(struct tb_switch *sw)
681 	if (tb_switch_is_usb4(sw)) {
682 		usb4_switch_read_uid(sw, &sw->uid);
683 		ret = usb4_copy_drom(sw, &size);
685 		ret = tb_drom_bit_bang(sw, &size);
691 	return tb_drom_parse(sw, size);
695  * tb_drom_read() - Copy DROM to sw->drom and parse it
696  * @sw: Router whose DROM to read and parse
699  * populates the fields in @sw accordingly. Can be called for any router
704 int tb_drom_read(struct tb_switch *sw)
706 	if (sw->drom)
709 	if (!tb_route(sw))
710 		return tb_drom_host_read(sw);
711 	return tb_drom_device_read(sw);