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

hyperbus-core.c (3455B)

      1// SPDX-License-Identifier: GPL-2.0
      2//
      3// Copyright (C) 2019 Texas Instruments Incorporated - https://www.ti.com/
      4// Author: Vignesh Raghavendra <vigneshr@ti.com>
      5
      6#include <linux/err.h>
      7#include <linux/kernel.h>
      8#include <linux/module.h>
      9#include <linux/mtd/hyperbus.h>
     10#include <linux/mtd/map.h>
     11#include <linux/mtd/mtd.h>
     12#include <linux/of.h>
     13#include <linux/types.h>
     14
     15static struct hyperbus_device *map_to_hbdev(struct map_info *map)
     16{
     17	return container_of(map, struct hyperbus_device, map);
     18}
     19
     20static map_word hyperbus_read16(struct map_info *map, unsigned long addr)
     21{
     22	struct hyperbus_device *hbdev = map_to_hbdev(map);
     23	struct hyperbus_ctlr *ctlr = hbdev->ctlr;
     24	map_word read_data;
     25
     26	read_data.x[0] = ctlr->ops->read16(hbdev, addr);
     27
     28	return read_data;
     29}
     30
     31static void hyperbus_write16(struct map_info *map, map_word d,
     32			     unsigned long addr)
     33{
     34	struct hyperbus_device *hbdev = map_to_hbdev(map);
     35	struct hyperbus_ctlr *ctlr = hbdev->ctlr;
     36
     37	ctlr->ops->write16(hbdev, addr, d.x[0]);
     38}
     39
     40static void hyperbus_copy_from(struct map_info *map, void *to,
     41			       unsigned long from, ssize_t len)
     42{
     43	struct hyperbus_device *hbdev = map_to_hbdev(map);
     44	struct hyperbus_ctlr *ctlr = hbdev->ctlr;
     45
     46	ctlr->ops->copy_from(hbdev, to, from, len);
     47}
     48
     49static void hyperbus_copy_to(struct map_info *map, unsigned long to,
     50			     const void *from, ssize_t len)
     51{
     52	struct hyperbus_device *hbdev = map_to_hbdev(map);
     53	struct hyperbus_ctlr *ctlr = hbdev->ctlr;
     54
     55	ctlr->ops->copy_to(hbdev, to, from, len);
     56}
     57
     58int hyperbus_register_device(struct hyperbus_device *hbdev)
     59{
     60	const struct hyperbus_ops *ops;
     61	struct hyperbus_ctlr *ctlr;
     62	struct device_node *np;
     63	struct map_info *map;
     64	struct device *dev;
     65	int ret;
     66
     67	if (!hbdev || !hbdev->np || !hbdev->ctlr || !hbdev->ctlr->dev) {
     68		pr_err("hyperbus: please fill all the necessary fields!\n");
     69		return -EINVAL;
     70	}
     71
     72	np = hbdev->np;
     73	ctlr = hbdev->ctlr;
     74	if (!of_device_is_compatible(np, "cypress,hyperflash")) {
     75		dev_err(ctlr->dev, "\"cypress,hyperflash\" compatible missing\n");
     76		return -ENODEV;
     77	}
     78
     79	hbdev->memtype = HYPERFLASH;
     80
     81	dev = ctlr->dev;
     82	map = &hbdev->map;
     83	map->name = dev_name(dev);
     84	map->bankwidth = 2;
     85	map->device_node = np;
     86
     87	simple_map_init(map);
     88	ops = ctlr->ops;
     89	if (ops) {
     90		if (ops->read16)
     91			map->read = hyperbus_read16;
     92		if (ops->write16)
     93			map->write = hyperbus_write16;
     94		if (ops->copy_to)
     95			map->copy_to = hyperbus_copy_to;
     96		if (ops->copy_from)
     97			map->copy_from = hyperbus_copy_from;
     98
     99		if (ops->calibrate && !ctlr->calibrated) {
    100			ret = ops->calibrate(hbdev);
    101			if (!ret) {
    102				dev_err(dev, "Calibration failed\n");
    103				return -ENODEV;
    104			}
    105			ctlr->calibrated = true;
    106		}
    107	}
    108
    109	hbdev->mtd = do_map_probe("cfi_probe", map);
    110	if (!hbdev->mtd) {
    111		dev_err(dev, "probing of hyperbus device failed\n");
    112		return -ENODEV;
    113	}
    114
    115	hbdev->mtd->dev.parent = dev;
    116	mtd_set_of_node(hbdev->mtd, np);
    117
    118	ret = mtd_device_register(hbdev->mtd, NULL, 0);
    119	if (ret) {
    120		dev_err(dev, "failed to register mtd device\n");
    121		map_destroy(hbdev->mtd);
    122		return ret;
    123	}
    124
    125	return 0;
    126}
    127EXPORT_SYMBOL_GPL(hyperbus_register_device);
    128
    129int hyperbus_unregister_device(struct hyperbus_device *hbdev)
    130{
    131	int ret = 0;
    132
    133	if (hbdev && hbdev->mtd) {
    134		ret = mtd_device_unregister(hbdev->mtd);
    135		map_destroy(hbdev->mtd);
    136	}
    137
    138	return ret;
    139}
    140EXPORT_SYMBOL_GPL(hyperbus_unregister_device);
    141
    142MODULE_DESCRIPTION("HyperBus Framework");
    143MODULE_LICENSE("GPL v2");
    144MODULE_AUTHOR("Vignesh Raghavendra <vigneshr@ti.com>");