mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-15 07:04:44 +00:00
614a895fc6
Rationale:
Reduces attack surface on kernel devs opening the links for MITM
as HTTPS traffic is much harder to manipulate.
Deterministic algorithm:
For each file:
If not .svg:
For each line:
If doesn't contain `\bxmlns\b`:
For each link, `\bhttp://[^# \t\r\n]*(?:\w|/)`:
If neither `\bgnu\.org/license`, nor `\bmozilla\.org/MPL\b`:
If both the HTTP and HTTPS versions
return 200 OK and serve the same content:
Replace HTTP with HTTPS.
Signed-off-by: Alexander A. Klimov <grandmaster@al2klimov.de>
Signed-off-by: Richard Weinberger <richard@nod.at>
144 lines
3.4 KiB
C
144 lines
3.4 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
//
|
|
// Copyright (C) 2019 Texas Instruments Incorporated - https://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/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 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")) {
|
|
dev_err(ctlr->dev, "\"cypress,hyperflash\" compatible missing\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
hbdev->memtype = HYPERFLASH;
|
|
|
|
dev = ctlr->dev;
|
|
map = &hbdev->map;
|
|
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>");
|