cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

tc.c (5591B)


      1/*
      2 *	TURBOchannel bus services.
      3 *
      4 *	Copyright (c) Harald Koerfgen, 1998
      5 *	Copyright (c) 2001, 2003, 2005, 2006, 2018  Maciej W. Rozycki
      6 *	Copyright (c) 2005  James Simmons
      7 *
      8 *	This file is subject to the terms and conditions of the GNU
      9 *	General Public License.  See the file "COPYING" in the main
     10 *	directory of this archive for more details.
     11 */
     12#include <linux/compiler.h>
     13#include <linux/dma-mapping.h>
     14#include <linux/errno.h>
     15#include <linux/init.h>
     16#include <linux/ioport.h>
     17#include <linux/kernel.h>
     18#include <linux/list.h>
     19#include <linux/module.h>
     20#include <linux/slab.h>
     21#include <linux/string.h>
     22#include <linux/tc.h>
     23#include <linux/types.h>
     24
     25#include <asm/io.h>
     26
     27static struct tc_bus tc_bus = {
     28	.name = "TURBOchannel",
     29};
     30
     31/*
     32 * Probing for TURBOchannel modules.
     33 */
     34static void __init tc_bus_add_devices(struct tc_bus *tbus)
     35{
     36	resource_size_t slotsize = tbus->info.slot_size << 20;
     37	resource_size_t extslotsize = tbus->ext_slot_size;
     38	resource_size_t slotaddr;
     39	resource_size_t extslotaddr;
     40	resource_size_t devsize;
     41	void __iomem *module;
     42	struct tc_dev *tdev;
     43	int i, slot, err;
     44	u8 pattern[4];
     45	long offset;
     46
     47	for (slot = 0; slot < tbus->num_tcslots; slot++) {
     48		slotaddr = tbus->slot_base + slot * slotsize;
     49		extslotaddr = tbus->ext_slot_base + slot * extslotsize;
     50		module = ioremap(slotaddr, slotsize);
     51		BUG_ON(!module);
     52
     53		offset = TC_OLDCARD;
     54
     55		err = 0;
     56		err |= tc_preadb(pattern + 0, module + offset + TC_PATTERN0);
     57		err |= tc_preadb(pattern + 1, module + offset + TC_PATTERN1);
     58		err |= tc_preadb(pattern + 2, module + offset + TC_PATTERN2);
     59		err |= tc_preadb(pattern + 3, module + offset + TC_PATTERN3);
     60		if (err)
     61			goto out_err;
     62
     63		if (pattern[0] != 0x55 || pattern[1] != 0x00 ||
     64		    pattern[2] != 0xaa || pattern[3] != 0xff) {
     65			offset = TC_NEWCARD;
     66
     67			err = 0;
     68			err |= tc_preadb(pattern + 0,
     69					 module + offset + TC_PATTERN0);
     70			err |= tc_preadb(pattern + 1,
     71					 module + offset + TC_PATTERN1);
     72			err |= tc_preadb(pattern + 2,
     73					 module + offset + TC_PATTERN2);
     74			err |= tc_preadb(pattern + 3,
     75					 module + offset + TC_PATTERN3);
     76			if (err)
     77				goto out_err;
     78		}
     79
     80		if (pattern[0] != 0x55 || pattern[1] != 0x00 ||
     81		    pattern[2] != 0xaa || pattern[3] != 0xff)
     82			goto out_err;
     83
     84		/* Found a board, allocate it an entry in the list */
     85		tdev = kzalloc(sizeof(*tdev), GFP_KERNEL);
     86		if (!tdev) {
     87			pr_err("tc%x: unable to allocate tc_dev\n", slot);
     88			goto out_err;
     89		}
     90		dev_set_name(&tdev->dev, "tc%x", slot);
     91		tdev->bus = tbus;
     92		tdev->dev.parent = &tbus->dev;
     93		tdev->dev.bus = &tc_bus_type;
     94		tdev->slot = slot;
     95
     96		/* TURBOchannel has 34-bit DMA addressing (16GiB space). */
     97		tdev->dma_mask = DMA_BIT_MASK(34);
     98		tdev->dev.dma_mask = &tdev->dma_mask;
     99		tdev->dev.coherent_dma_mask = DMA_BIT_MASK(34);
    100
    101		for (i = 0; i < 8; i++) {
    102			tdev->firmware[i] =
    103				readb(module + offset + TC_FIRM_VER + 4 * i);
    104			tdev->vendor[i] =
    105				readb(module + offset + TC_VENDOR + 4 * i);
    106			tdev->name[i] =
    107				readb(module + offset + TC_MODULE + 4 * i);
    108		}
    109		tdev->firmware[8] = 0;
    110		tdev->vendor[8] = 0;
    111		tdev->name[8] = 0;
    112
    113		pr_info("%s: %s %s %s\n", dev_name(&tdev->dev), tdev->vendor,
    114			tdev->name, tdev->firmware);
    115
    116		devsize = readb(module + offset + TC_SLOT_SIZE);
    117		devsize <<= 22;
    118		if (devsize <= slotsize) {
    119			tdev->resource.start = slotaddr;
    120			tdev->resource.end = slotaddr + devsize - 1;
    121		} else if (devsize <= extslotsize) {
    122			tdev->resource.start = extslotaddr;
    123			tdev->resource.end = extslotaddr + devsize - 1;
    124		} else {
    125			pr_err("%s: Cannot provide slot space "
    126			       "(%ldMiB required, up to %ldMiB supported)\n",
    127			       dev_name(&tdev->dev), (long)(devsize >> 20),
    128			       (long)(max(slotsize, extslotsize) >> 20));
    129			kfree(tdev);
    130			goto out_err;
    131		}
    132		tdev->resource.name = tdev->name;
    133		tdev->resource.flags = IORESOURCE_MEM;
    134
    135		tc_device_get_irq(tdev);
    136
    137		if (device_register(&tdev->dev)) {
    138			put_device(&tdev->dev);
    139			goto out_err;
    140		}
    141		list_add_tail(&tdev->node, &tbus->devices);
    142
    143out_err:
    144		iounmap(module);
    145	}
    146}
    147
    148/*
    149 * The main entry.
    150 */
    151static int __init tc_init(void)
    152{
    153	/* Initialize the TURBOchannel bus */
    154	if (tc_bus_get_info(&tc_bus))
    155		goto out_err;
    156
    157	INIT_LIST_HEAD(&tc_bus.devices);
    158	dev_set_name(&tc_bus.dev, "tc");
    159	if (device_register(&tc_bus.dev))
    160		goto out_err_device;
    161
    162	if (tc_bus.info.slot_size) {
    163		unsigned int tc_clock = tc_get_speed(&tc_bus) / 100000;
    164
    165		pr_info("tc: TURBOchannel rev. %d at %d.%d MHz "
    166			"(with%s parity)\n", tc_bus.info.revision,
    167			tc_clock / 10, tc_clock % 10,
    168			tc_bus.info.parity ? "" : "out");
    169
    170		tc_bus.resource[0].start = tc_bus.slot_base;
    171		tc_bus.resource[0].end = tc_bus.slot_base +
    172					 (tc_bus.info.slot_size << 20) *
    173					 tc_bus.num_tcslots - 1;
    174		tc_bus.resource[0].name = tc_bus.name;
    175		tc_bus.resource[0].flags = IORESOURCE_MEM;
    176		if (request_resource(&iomem_resource,
    177				     &tc_bus.resource[0]) < 0) {
    178			pr_err("tc: Cannot reserve resource\n");
    179			goto out_err_device;
    180		}
    181		if (tc_bus.ext_slot_size) {
    182			tc_bus.resource[1].start = tc_bus.ext_slot_base;
    183			tc_bus.resource[1].end = tc_bus.ext_slot_base +
    184						 tc_bus.ext_slot_size *
    185						 tc_bus.num_tcslots - 1;
    186			tc_bus.resource[1].name = tc_bus.name;
    187			tc_bus.resource[1].flags = IORESOURCE_MEM;
    188			if (request_resource(&iomem_resource,
    189					     &tc_bus.resource[1]) < 0) {
    190				pr_err("tc: Cannot reserve resource\n");
    191				goto out_err_resource;
    192			}
    193		}
    194
    195		tc_bus_add_devices(&tc_bus);
    196	}
    197
    198	return 0;
    199
    200out_err_resource:
    201	release_resource(&tc_bus.resource[0]);
    202out_err_device:
    203	put_device(&tc_bus.dev);
    204out_err:
    205	return 0;
    206}
    207
    208subsys_initcall(tc_init);