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

map_ram.c (3744B)

      1/*
      2 * Common code to handle map devices which are simple RAM
      3 * (C) 2000 Red Hat. GPL'd.
      4 */
      5
      6#include <linux/module.h>
      7#include <linux/types.h>
      8#include <linux/kernel.h>
      9#include <asm/io.h>
     10#include <asm/byteorder.h>
     11#include <linux/errno.h>
     12#include <linux/slab.h>
     13#include <linux/init.h>
     14#include <linux/mtd/mtd.h>
     15#include <linux/mtd/map.h>
     16
     17
     18static int mapram_read (struct mtd_info *, loff_t, size_t, size_t *, u_char *);
     19static int mapram_write (struct mtd_info *, loff_t, size_t, size_t *, const u_char *);
     20static int mapram_erase (struct mtd_info *, struct erase_info *);
     21static void mapram_nop (struct mtd_info *);
     22static struct mtd_info *map_ram_probe(struct map_info *map);
     23static int mapram_point (struct mtd_info *mtd, loff_t from, size_t len,
     24			 size_t *retlen, void **virt, resource_size_t *phys);
     25static int mapram_unpoint(struct mtd_info *mtd, loff_t from, size_t len);
     26
     27
     28static struct mtd_chip_driver mapram_chipdrv = {
     29	.probe	= map_ram_probe,
     30	.name	= "map_ram",
     31	.module	= THIS_MODULE
     32};
     33
     34static struct mtd_info *map_ram_probe(struct map_info *map)
     35{
     36	struct mtd_info *mtd;
     37
     38	/* Check the first byte is RAM */
     39#if 0
     40	map_write8(map, 0x55, 0);
     41	if (map_read8(map, 0) != 0x55)
     42		return NULL;
     43
     44	map_write8(map, 0xAA, 0);
     45	if (map_read8(map, 0) != 0xAA)
     46		return NULL;
     47
     48	/* Check the last byte is RAM */
     49	map_write8(map, 0x55, map->size-1);
     50	if (map_read8(map, map->size-1) != 0x55)
     51		return NULL;
     52
     53	map_write8(map, 0xAA, map->size-1);
     54	if (map_read8(map, map->size-1) != 0xAA)
     55		return NULL;
     56#endif
     57	/* OK. It seems to be RAM. */
     58
     59	mtd = kzalloc(sizeof(*mtd), GFP_KERNEL);
     60	if (!mtd)
     61		return NULL;
     62
     63	map->fldrv = &mapram_chipdrv;
     64	mtd->priv = map;
     65	mtd->name = map->name;
     66	mtd->type = MTD_RAM;
     67	mtd->size = map->size;
     68	mtd->_erase = mapram_erase;
     69	mtd->_read = mapram_read;
     70	mtd->_write = mapram_write;
     71	mtd->_panic_write = mapram_write;
     72	mtd->_point = mapram_point;
     73	mtd->_sync = mapram_nop;
     74	mtd->_unpoint = mapram_unpoint;
     75	mtd->flags = MTD_CAP_RAM;
     76	mtd->writesize = 1;
     77
     78	mtd->erasesize = PAGE_SIZE;
     79 	while(mtd->size & (mtd->erasesize - 1))
     80		mtd->erasesize >>= 1;
     81
     82	__module_get(THIS_MODULE);
     83	return mtd;
     84}
     85
     86static int mapram_point(struct mtd_info *mtd, loff_t from, size_t len,
     87			size_t *retlen, void **virt, resource_size_t *phys)
     88{
     89	struct map_info *map = mtd->priv;
     90
     91	if (!map->virt)
     92		return -EINVAL;
     93	*virt = map->virt + from;
     94	if (phys)
     95		*phys = map->phys + from;
     96	*retlen = len;
     97	return 0;
     98}
     99
    100static int mapram_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
    101{
    102	return 0;
    103}
    104
    105static int mapram_read (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf)
    106{
    107	struct map_info *map = mtd->priv;
    108
    109	map_copy_from(map, buf, from, len);
    110	*retlen = len;
    111	return 0;
    112}
    113
    114static int mapram_write (struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf)
    115{
    116	struct map_info *map = mtd->priv;
    117
    118	map_copy_to(map, to, buf, len);
    119	*retlen = len;
    120	return 0;
    121}
    122
    123static int mapram_erase (struct mtd_info *mtd, struct erase_info *instr)
    124{
    125	/* Yeah, it's inefficient. Who cares? It's faster than a _real_
    126	   flash erase. */
    127	struct map_info *map = mtd->priv;
    128	map_word allff;
    129	unsigned long i;
    130
    131	allff = map_word_ff(map);
    132	for (i=0; i<instr->len; i += map_bankwidth(map))
    133		map_write(map, allff, instr->addr + i);
    134	return 0;
    135}
    136
    137static void mapram_nop(struct mtd_info *mtd)
    138{
    139	/* Nothing to see here */
    140}
    141
    142static int __init map_ram_init(void)
    143{
    144	register_mtd_chip_driver(&mapram_chipdrv);
    145	return 0;
    146}
    147
    148static void __exit map_ram_exit(void)
    149{
    150	unregister_mtd_chip_driver(&mapram_chipdrv);
    151}
    152
    153module_init(map_ram_init);
    154module_exit(map_ram_exit);
    155
    156MODULE_LICENSE("GPL");
    157MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
    158MODULE_DESCRIPTION("MTD chip driver for RAM chips");