Release 4.7 drivers/mtd/maps/pci.c

/*
 *  linux/drivers/mtd/maps/pci.c
 *
 *  Copyright (C) 2001 Russell King, All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * Generic PCI memory map driver.  We support the following boards:
 *  - Intel IQ80310 ATU.
 *  - Intel EBSA285 (blank rom programming mode). Tested working 27/09/2001
 */
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/pci.h>
#include <linux/slab.h>

#include <linux/mtd/mtd.h>
#include <linux/mtd/map.h>
#include <linux/mtd/partitions.h>

struct map_pci_info;


struct mtd_pci_info {
	
int  (*init)(struct pci_dev *dev, struct map_pci_info *map);
	
void (*exit)(struct pci_dev *dev, struct map_pci_info *map);
	
unsigned long (*translate)(struct map_pci_info *map, unsigned long ofs);
	
const char *map_name;
};


struct map_pci_info {
	
struct map_info map;
	
void __iomem *base;
	
void (*exit)(struct pci_dev *dev, struct map_pci_info *map);
	
unsigned long (*translate)(struct map_pci_info *map, unsigned long ofs);
	
struct pci_dev *dev;
};



static map_word mtd_pci_read8(struct map_info *_map, unsigned long ofs)
{
	struct map_pci_info *map = (struct map_pci_info *)_map;
	map_word val;
	val.x[0]= readb(map->base + map->translate(map, ofs));
	return val;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david woodhouse
david woodhouse
31
55.36%
1
50.00%
russell king
russell king
25
44.64%
1
50.00%
Total
56
100.00%
2
100.00%



static map_word mtd_pci_read32(struct map_info *_map, unsigned long ofs)
{
	struct map_pci_info *map = (struct map_pci_info *)_map;
	map_word val;
	val.x[0] = readl(map->base + map->translate(map, ofs));
	return val;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david woodhouse
david woodhouse
35
62.50%
1
50.00%
russell king
russell king
21
37.50%
1
50.00%
Total
56
100.00%
2
100.00%



static void mtd_pci_copyfrom(struct map_info *_map, void *to, unsigned long from, ssize_t len)
{
	struct map_pci_info *map = (struct map_pci_info *)_map;
	memcpy_fromio(to, map->base + map->translate(map, from), len);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david woodhouse
david woodhouse
28
51.85%
1
50.00%
russell king
russell king
26
48.15%
1
50.00%
Total
54
100.00%
2
100.00%



static void mtd_pci_write8(struct map_info *_map, map_word val, unsigned long ofs)
{
	struct map_pci_info *map = (struct map_pci_info *)_map;
	writeb(val.x[0], map->base + map->translate(map, ofs));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david woodhouse
david woodhouse
50
94.34%
1
50.00%
russell king
russell king
3
5.66%
1
50.00%
Total
53
100.00%
2
100.00%



static void mtd_pci_write32(struct map_info *_map, map_word val, unsigned long ofs)
{
	struct map_pci_info *map = (struct map_pci_info *)_map;
	writel(val.x[0], map->base + map->translate(map, ofs));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david woodhouse
david woodhouse
51
96.23%
1
33.33%
art haas
art haas
1
1.89%
1
33.33%
russell king
russell king
1
1.89%
1
33.33%
Total
53
100.00%
3
100.00%



static void mtd_pci_copyto(struct map_info *_map, unsigned long to, const void *from, ssize_t len)
{
	struct map_pci_info *map = (struct map_pci_info *)_map;
	memcpy_toio(map->base + map->translate(map, to), from, len);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david woodhouse
david woodhouse
55
100.00%
1
100.00%
Total
55
100.00%
1
100.00%


static const struct map_info mtd_pci_map = {
	.phys =		NO_XIP,
	.copy_from =	mtd_pci_copyfrom,
	.copy_to =	mtd_pci_copyto,
};

/*
 * Intel IOP80310 Flash driver
 */


static int

intel_iq80310_init(struct pci_dev *dev, struct map_pci_info *map)
{
	u32 win_base;

	map->map.bankwidth = 1;
	map->map.read = mtd_pci_read8,
	map->map.write = mtd_pci_write8,

	map->map.size     = 0x00800000;
	map->base         = ioremap_nocache(pci_resource_start(dev, 0),
					    pci_resource_len(dev, 0));

	if (!map->base)
		return -ENOMEM;

	/*
         * We want to base the memory window at Xscale
         * bus address 0, not 0x1000.
         */
	pci_read_config_dword(dev, 0x44, &win_base);
	pci_write_config_dword(dev, 0x44, 0);

	map->map.map_priv_2 = win_base;

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
russell king
russell king
57
50.00%
1
50.00%
david woodhouse
david woodhouse
57
50.00%
1
50.00%
Total
114
100.00%
2
100.00%


static void

intel_iq80310_exit(struct pci_dev *dev, struct map_pci_info *map)
{
	if (map->base)
		iounmap(map->base);
	pci_write_config_dword(dev, 0x44, map->map.map_priv_2);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
russell king
russell king
35
83.33%
1
50.00%
david woodhouse
david woodhouse
7
16.67%
1
50.00%
Total
42
100.00%
2
100.00%


static unsigned long

intel_iq80310_translate(struct map_pci_info *map, unsigned long ofs)
{
	unsigned long page_addr = ofs & 0x00400000;

	/*
         * This mundges the flash location so we avoid
         * the first 80 bytes (they appear to read nonsense).
         */
	if (page_addr) {
		writel(0x00000008, map->base + 0x1558);
		writel(0x00000000, map->base + 0x1550);
	} else {
		writel(0x00000007, map->base + 0x1558);
		writel(0x00800000, map->base + 0x1550);
		ofs += 0x00800000;
	}

	return ofs;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david woodhouse
david woodhouse
65
76.47%
1
50.00%
russell king
russell king
20
23.53%
1
50.00%
Total
85
100.00%
2
100.00%


static struct mtd_pci_info intel_iq80310_info = {
	.init =		intel_iq80310_init,
	.exit =		intel_iq80310_exit,
	.translate =	intel_iq80310_translate,
	.map_name =	"cfi_probe",
};

/*
 * Intel DC21285 driver
 */


static int

intel_dc21285_init(struct pci_dev *dev, struct map_pci_info *map)
{
	unsigned long base, len;

	base = pci_resource_start(dev, PCI_ROM_RESOURCE);
	len  = pci_resource_len(dev, PCI_ROM_RESOURCE);

	if (!len || !base) {
		/*
                 * No ROM resource
                 */
		base = pci_resource_start(dev, 2);
		len  = pci_resource_len(dev, 2);

		/*
                 * We need to re-allocate PCI BAR2 address range to the
                 * PCI ROM BAR, and disable PCI BAR2.
                 */
	} else {
		/*
                 * Hmm, if an address was allocated to the ROM resource, but
                 * not enabled, should we be allocating a new resource for it
                 * or simply enabling it?
                 */
		pci_enable_rom(dev);
		printk("%s: enabling expansion ROM\n", pci_name(dev));
	}

	if (!len || !base)
		return -ENXIO;

	map->map.bankwidth = 4;
	map->map.read = mtd_pci_read32,
	map->map.write = mtd_pci_write32,
	map->map.size     = len;
	map->base         = ioremap_nocache(base, len);

	if (!map->base)
		return -ENOMEM;

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david woodhouse
david woodhouse
118
74.68%
1
33.33%
russell king
russell king
39
24.68%
1
33.33%
alan cox
alan cox
1
0.63%
1
33.33%
Total
158
100.00%
3
100.00%


static void

intel_dc21285_exit(struct pci_dev *dev, struct map_pci_info *map)
{
	if (map->base)
		iounmap(map->base);

	/*
         * We need to undo the PCI BAR2/PCI ROM BAR address alteration.
         */
	pci_disable_rom(dev);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
russell king
russell king
18
51.43%
1
33.33%
david woodhouse
david woodhouse
16
45.71%
1
33.33%
alan cox
alan cox
1
2.86%
1
33.33%
Total
35
100.00%
3
100.00%


static unsigned long

intel_dc21285_translate(struct map_pci_info *map, unsigned long ofs)
{
	return ofs & 0x00ffffc0 ? ofs : (ofs ^ (1 << 5));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david woodhouse
david woodhouse
21
63.64%
1
50.00%
russell king
russell king
12
36.36%
1
50.00%
Total
33
100.00%
2
100.00%


static struct mtd_pci_info intel_dc21285_info = {
	.init =		intel_dc21285_init,
	.exit =		intel_dc21285_exit,
	.translate =	intel_dc21285_translate,
	.map_name =	"jedec_probe",
};

/*
 * PCI device ID table
 */


static struct pci_device_id mtd_pci_ids[] = {
	{
		.vendor =	PCI_VENDOR_ID_INTEL,
		.device =	0x530d,
		.subvendor =	PCI_ANY_ID,
		.subdevice =	PCI_ANY_ID,
		.class =	PCI_CLASS_MEMORY_OTHER << 8,
		.class_mask =	0xffff00,
		.driver_data =	(unsigned long)&intel_iq80310_info,
        },
	{
		.vendor =	PCI_VENDOR_ID_DEC,
		.device =	PCI_DEVICE_ID_DEC_21285,
		.subvendor =	0,	/* DC21285 defaults to 0 on reset */
		.subdevice =	0,	/* DC21285 defaults to 0 on reset */
		.driver_data =	(unsigned long)&intel_dc21285_info,
        },
	{ 0, }
};

/*
 * Generic code follows.
 */



static int mtd_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
{
	struct mtd_pci_info *info = (struct mtd_pci_info *)id->driver_data;
	struct map_pci_info *map = NULL;
	struct mtd_info *mtd = NULL;
	int err;

	err = pci_enable_device(dev);
	if (err)
		goto out;

	err = pci_request_regions(dev, "pci mtd");
	if (err)
		goto out;

	map = kmalloc(sizeof(*map), GFP_KERNEL);
	err = -ENOMEM;
	if (!map)
		goto release;

	map->map       = mtd_pci_map;
	map->map.name  = pci_name(dev);
	map->dev       = dev;
	map->exit      = info->exit;
	map->translate = info->translate;

	err = info->init(dev, map);
	if (err)
		goto release;

	mtd = do_map_probe(info->map_name, &map->map);
	err = -ENODEV;
	if (!mtd)
		goto release;

	mtd->owner = THIS_MODULE;
	mtd_device_register(mtd, NULL, 0);

	pci_set_drvdata(dev, mtd);

	return 0;

release:
	if (map) {
		map->exit(dev, map);
		kfree(map);
	}

	pci_release_regions(dev);
out:
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
russell king
russell king
236
96.33%
1
25.00%
jamie iles
jamie iles
5
2.04%
1
25.00%
randy dunlap
randy dunlap
3
1.22%
1
25.00%
david woodhouse
david woodhouse
1
0.41%
1
25.00%
Total
245
100.00%
4
100.00%



static void mtd_pci_remove(struct pci_dev *dev)
{
	struct mtd_info *mtd = pci_get_drvdata(dev);
	struct map_pci_info *map = mtd->priv;

	mtd_device_unregister(mtd);
	map_destroy(mtd);
	map->exit(dev, map);
	kfree(map);

	pci_release_regions(dev);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
russell king
russell king
58
98.31%
1
50.00%
jamie iles
jamie iles
1
1.69%
1
50.00%
Total
59
100.00%
2
100.00%


static struct pci_driver mtd_pci_driver = {
	.name =		"MTD PCI",
	.probe =	mtd_pci_probe,
	.remove =	mtd_pci_remove,
	.id_table =	mtd_pci_ids,
};


module_pci_driver(mtd_pci_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>");
MODULE_DESCRIPTION("Generic PCI map driver");
MODULE_DEVICE_TABLE(pci, mtd_pci_ids);
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
russell king
russell king
760
51.98%
1
8.33%
david woodhouse
david woodhouse
646
44.19%
4
33.33%
art haas
art haas
39
2.67%
1
8.33%
jamie iles
jamie iles
6
0.41%
1
8.33%
randy dunlap
randy dunlap
3
0.21%
1
8.33%
tim schmielau
tim schmielau
3
0.21%
1
8.33%
axel lin
axel lin
2
0.14%
1
8.33%
alan cox
alan cox
2
0.14%
1
8.33%
adrian bunk
adrian bunk
1
0.07%
1
8.33%
greg kroah-hartman
greg kroah-hartman
0.00%
0
0.00%
Total
1462
100.00%
12
100.00%
  
Directory: drivers/mtd/maps

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.