mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-24 23:34:40 +07:00
dcc7d3446a
Cypress' HyperBus is Low Signal Count, High Performance Double Data Rate Bus interface between a host system master and one or more slave interfaces. HyperBus is used to connect microprocessor, microcontroller, or ASIC devices with random access NOR flash memory (called HyperFlash) or self refresh DRAM (called HyperRAM). Its a 8-bit data bus (DQ[7:0]) with Read-Write Data Strobe (RWDS) signal and either Single-ended clock(3.0V parts) or Differential clock (1.8V parts). It uses ChipSelect lines to select b/w multiple slaves. At bus level, it follows a separate protocol described in HyperBus specification[1]. HyperFlash follows CFI AMD/Fujitsu Extended Command Set (0x0002) similar to that of existing parallel NORs. Since HyperBus is x8 DDR bus, its equivalent to x16 parallel NOR flash with respect to bits per clock cycle. But HyperBus operates at >166MHz frequencies. HyperRAM provides direct random read/write access to flash memory array. But, HyperBus memory controllers seem to abstract implementation details and expose a simple MMIO interface to access connected flash. Add support for registering HyperFlash devices with MTD framework. MTD maps framework along with CFI chip support framework are used to support communicating with flash. Framework is modelled along the lines of spi-nor framework. HyperBus memory controller (HBMC) drivers calls hyperbus_register_device() to register a single HyperFlash device. HyperFlash core parses MMIO access information from DT, sets up the map_info struct, probes CFI flash and registers it with MTD framework. Some HBMC masters need calibration/training sequence[3] to be carried out, in order for DLL inside the controller to lock, by reading a known string/pattern. This is done by repeatedly reading CFI Query Identification String. Calibration needs to be done before trying to detect flash as part of CFI flash probe. HyperRAM is not supported at the moment. HyperBus specification can be found at[1] HyperFlash datasheet can be found at[2] [1] https://www.cypress.com/file/213356/download [2] https://www.cypress.com/file/213346/download [3] http://www.ti.com/lit/ug/spruid7b/spruid7b.pdf Table 12-5741. HyperFlash Access Sequence Signed-off-by: Vignesh Raghavendra <vigneshr@ti.com> Signed-off-by: Miquel Raynal <miquel.raynal@bootlin.com>
154 lines
3.6 KiB
C
154 lines
3.6 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
//
|
|
// Copyright (C) 2019 Texas Instruments Incorporated - http://www.ti.com/
|
|
// Author: Vignesh Raghavendra <vigneshr@ti.com>
|
|
|
|
#include <linux/err.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/mtd/hyperbus.h>
|
|
#include <linux/mtd/map.h>
|
|
#include <linux/mtd/mtd.h>
|
|
#include <linux/of.h>
|
|
#include <linux/of_address.h>
|
|
#include <linux/types.h>
|
|
|
|
static struct hyperbus_device *map_to_hbdev(struct map_info *map)
|
|
{
|
|
return container_of(map, struct hyperbus_device, map);
|
|
}
|
|
|
|
static map_word hyperbus_read16(struct map_info *map, unsigned long addr)
|
|
{
|
|
struct hyperbus_device *hbdev = map_to_hbdev(map);
|
|
struct hyperbus_ctlr *ctlr = hbdev->ctlr;
|
|
map_word read_data;
|
|
|
|
read_data.x[0] = ctlr->ops->read16(hbdev, addr);
|
|
|
|
return read_data;
|
|
}
|
|
|
|
static void hyperbus_write16(struct map_info *map, map_word d,
|
|
unsigned long addr)
|
|
{
|
|
struct hyperbus_device *hbdev = map_to_hbdev(map);
|
|
struct hyperbus_ctlr *ctlr = hbdev->ctlr;
|
|
|
|
ctlr->ops->write16(hbdev, addr, d.x[0]);
|
|
}
|
|
|
|
static void hyperbus_copy_from(struct map_info *map, void *to,
|
|
unsigned long from, ssize_t len)
|
|
{
|
|
struct hyperbus_device *hbdev = map_to_hbdev(map);
|
|
struct hyperbus_ctlr *ctlr = hbdev->ctlr;
|
|
|
|
ctlr->ops->copy_from(hbdev, to, from, len);
|
|
}
|
|
|
|
static void hyperbus_copy_to(struct map_info *map, unsigned long to,
|
|
const void *from, ssize_t len)
|
|
{
|
|
struct hyperbus_device *hbdev = map_to_hbdev(map);
|
|
struct hyperbus_ctlr *ctlr = hbdev->ctlr;
|
|
|
|
ctlr->ops->copy_to(hbdev, to, from, len);
|
|
}
|
|
|
|
int hyperbus_register_device(struct hyperbus_device *hbdev)
|
|
{
|
|
const struct hyperbus_ops *ops;
|
|
struct hyperbus_ctlr *ctlr;
|
|
struct device_node *np;
|
|
struct map_info *map;
|
|
struct resource res;
|
|
struct device *dev;
|
|
int ret;
|
|
|
|
if (!hbdev || !hbdev->np || !hbdev->ctlr || !hbdev->ctlr->dev) {
|
|
pr_err("hyperbus: please fill all the necessary fields!\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
np = hbdev->np;
|
|
ctlr = hbdev->ctlr;
|
|
if (!of_device_is_compatible(np, "cypress,hyperflash"))
|
|
return -ENODEV;
|
|
|
|
hbdev->memtype = HYPERFLASH;
|
|
|
|
ret = of_address_to_resource(np, 0, &res);
|
|
if (ret)
|
|
return ret;
|
|
|
|
dev = ctlr->dev;
|
|
map = &hbdev->map;
|
|
map->size = resource_size(&res);
|
|
map->virt = devm_ioremap_resource(dev, &res);
|
|
if (IS_ERR(map->virt))
|
|
return PTR_ERR(map->virt);
|
|
|
|
map->name = dev_name(dev);
|
|
map->bankwidth = 2;
|
|
map->device_node = np;
|
|
|
|
simple_map_init(map);
|
|
ops = ctlr->ops;
|
|
if (ops) {
|
|
if (ops->read16)
|
|
map->read = hyperbus_read16;
|
|
if (ops->write16)
|
|
map->write = hyperbus_write16;
|
|
if (ops->copy_to)
|
|
map->copy_to = hyperbus_copy_to;
|
|
if (ops->copy_from)
|
|
map->copy_from = hyperbus_copy_from;
|
|
|
|
if (ops->calibrate && !ctlr->calibrated) {
|
|
ret = ops->calibrate(hbdev);
|
|
if (!ret) {
|
|
dev_err(dev, "Calibration failed\n");
|
|
return -ENODEV;
|
|
}
|
|
ctlr->calibrated = true;
|
|
}
|
|
}
|
|
|
|
hbdev->mtd = do_map_probe("cfi_probe", map);
|
|
if (!hbdev->mtd) {
|
|
dev_err(dev, "probing of hyperbus device failed\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
hbdev->mtd->dev.parent = dev;
|
|
mtd_set_of_node(hbdev->mtd, np);
|
|
|
|
ret = mtd_device_register(hbdev->mtd, NULL, 0);
|
|
if (ret) {
|
|
dev_err(dev, "failed to register mtd device\n");
|
|
map_destroy(hbdev->mtd);
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(hyperbus_register_device);
|
|
|
|
int hyperbus_unregister_device(struct hyperbus_device *hbdev)
|
|
{
|
|
int ret = 0;
|
|
|
|
if (hbdev && hbdev->mtd) {
|
|
ret = mtd_device_unregister(hbdev->mtd);
|
|
map_destroy(hbdev->mtd);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(hyperbus_unregister_device);
|
|
|
|
MODULE_DESCRIPTION("HyperBus Framework");
|
|
MODULE_LICENSE("GPL v2");
|
|
MODULE_AUTHOR("Vignesh Raghavendra <vigneshr@ti.com>");
|