[people/ms/linux.git] / drivers / w1 / masters / matrox_w1.c

/*
 *	matrox_w1.c
 *
 * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
 *
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#include <asm/types.h>
#include <linux/atomic.h>
#include <asm/io.h>

#include <linux/delay.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/list.h>
#include <linux/interrupt.h>
#include <linux/spinlock.h>
#include <linux/timer.h>
#include <linux/slab.h>
#include <linux/pci_ids.h>
#include <linux/pci.h>

#include "../w1.h"
#include "../w1_int.h"
#include "../w1_log.h"

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Evgeniy Polyakov <johnpol@2ka.mipt.ru>");
MODULE_DESCRIPTION("Driver for transport(Dallas 1-wire prtocol) over VGA DDC(matrox gpio).");

static struct pci_device_id matrox_w1_tbl[] = {
	{ PCI_DEVICE(PCI_VENDOR_ID_MATROX, PCI_DEVICE_ID_MATROX_G400) },
	{ },
};
MODULE_DEVICE_TABLE(pci, matrox_w1_tbl);

static int __devinit matrox_w1_probe(struct pci_dev *, const struct pci_device_id *);
static void __devexit matrox_w1_remove(struct pci_dev *);

static struct pci_driver matrox_w1_pci_driver = {
	.name = "matrox_w1",
	.id_table = matrox_w1_tbl,
	.probe = matrox_w1_probe,
	.remove = __devexit_p(matrox_w1_remove),
};

/*
 * Matrox G400 DDC registers.
 */

#define MATROX_G400_DDC_CLK		(1<<4)
#define MATROX_G400_DDC_DATA		(1<<1)

#define MATROX_BASE			0x3C00
#define MATROX_STATUS			0x1e14

#define MATROX_PORT_INDEX_OFFSET	0x00
#define MATROX_PORT_DATA_OFFSET		0x0A

#define MATROX_GET_CONTROL		0x2A
#define MATROX_GET_DATA			0x2B
#define MATROX_CURSOR_CTL		0x06

struct matrox_device
{
	void __iomem *base_addr;
	void __iomem *port_index;
	void __iomem *port_data;
	u8 data_mask;

	unsigned long phys_addr;
	void __iomem *virt_addr;
	unsigned long found;

	struct w1_bus_master *bus_master;
};

static u8 matrox_w1_read_ddc_bit(void *);
static void matrox_w1_write_ddc_bit(void *, u8);

/*
 * These functions read and write DDC Data bit.
 *
 * Using tristate pins, since i can't find any open-drain pin in whole motherboard.
 * Unfortunately we can't connect to Intel's 82801xx IO controller
 * since we don't know motherboard schema, which has pretty unused(may be not) GPIO.
 *
 * I've heard that PIIX also has open drain pin.
 *
 * Port mapping.
 */
static __inline__ u8 matrox_w1_read_reg(struct matrox_device *dev, u8 reg)
{
	u8 ret;

	writeb(reg, dev->port_index);
	ret = readb(dev->port_data);
	barrier();

	return ret;
}

static __inline__ void matrox_w1_write_reg(struct matrox_device *dev, u8 reg, u8 val)
{
	writeb(reg, dev->port_index);
	writeb(val, dev->port_data);
	wmb();
}

static void matrox_w1_write_ddc_bit(void *data, u8 bit)
{
	u8 ret;
	struct matrox_device *dev = data;

	if (bit)
		bit = 0;
	else
		bit = dev->data_mask;

	ret = matrox_w1_read_reg(dev, MATROX_GET_CONTROL);
	matrox_w1_write_reg(dev, MATROX_GET_CONTROL, ((ret & ~dev->data_mask) | bit));
	matrox_w1_write_reg(dev, MATROX_GET_DATA, 0x00);
}

static u8 matrox_w1_read_ddc_bit(void *data)
{
	u8 ret;
	struct matrox_device *dev = data;

	ret = matrox_w1_read_reg(dev, MATROX_GET_DATA);

	return ret;
}

static void matrox_w1_hw_init(struct matrox_device *dev)
{
	matrox_w1_write_reg(dev, MATROX_GET_DATA, 0xFF);
	matrox_w1_write_reg(dev, MATROX_GET_CONTROL, 0x00);
}

static int __devinit matrox_w1_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{
	struct matrox_device *dev;
	int err;

	assert(pdev != NULL);
	assert(ent != NULL);

	if (pdev->vendor != PCI_VENDOR_ID_MATROX || pdev->device != PCI_DEVICE_ID_MATROX_G400)
		return -ENODEV;

	dev = kzalloc(sizeof(struct matrox_device) +
		       sizeof(struct w1_bus_master), GFP_KERNEL);
	if (!dev) {
		dev_err(&pdev->dev,
			"%s: Failed to create new matrox_device object.\n",
			__func__);
		return -ENOMEM;
	}


	dev->bus_master = (struct w1_bus_master *)(dev + 1);

	/*
	 * True for G400, for some other we need resource 0, see drivers/video/matrox/matroxfb_base.c
	 */

	dev->phys_addr = pci_resource_start(pdev, 1);

	dev->virt_addr = ioremap_nocache(dev->phys_addr, 16384);
	if (!dev->virt_addr) {
		dev_err(&pdev->dev, "%s: failed to ioremap(0x%lx, %d).\n",
			__func__, dev->phys_addr, 16384);
		err = -EIO;
		goto err_out_free_device;
	}

	dev->base_addr = dev->virt_addr + MATROX_BASE;
	dev->port_index = dev->base_addr + MATROX_PORT_INDEX_OFFSET;
	dev->port_data = dev->base_addr + MATROX_PORT_DATA_OFFSET;
	dev->data_mask = (MATROX_G400_DDC_DATA);

	matrox_w1_hw_init(dev);

	dev->bus_master->data = dev;
	dev->bus_master->read_bit = &matrox_w1_read_ddc_bit;
	dev->bus_master->write_bit = &matrox_w1_write_ddc_bit;

	err = w1_add_master_device(dev->bus_master);
	if (err)
		goto err_out_free_device;

	pci_set_drvdata(pdev, dev);

	dev->found = 1;

	dev_info(&pdev->dev, "Matrox G400 GPIO transport layer for 1-wire.\n");

	return 0;

err_out_free_device:
	if (dev->virt_addr)
		iounmap(dev->virt_addr);
	kfree(dev);

	return err;
}

static void __devexit matrox_w1_remove(struct pci_dev *pdev)
{
	struct matrox_device *dev = pci_get_drvdata(pdev);

	assert(dev != NULL);

	if (dev->found) {
		w1_remove_master_device(dev->bus_master);
		iounmap(dev->virt_addr);
	}
	kfree(dev);
}

static int __init matrox_w1_init(void)
{
	return pci_register_driver(&matrox_w1_pci_driver);
}

static void __exit matrox_w1_fini(void)
{
	pci_unregister_driver(&matrox_w1_pci_driver);
}

module_init(matrox_w1_init);
module_exit(matrox_w1_fini);
Commit	Line	Data
1da177e4	1	/*
7785925d	2	* matrox_w1.c
1da177e4 LT	3	*
1da177e4 LT	4	* Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
7785925d	5	*
1da177e4 LT	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	20	*/
	21
1da177e4	22	#include <asm/types.h>
60063497	23	#include <linux/atomic.h>
1da177e4 LT	24	#include <asm/io.h>
	25
	26	#include <linux/delay.h>
	27	#include <linux/kernel.h>
	28	#include <linux/module.h>
	29	#include <linux/list.h>
	30	#include <linux/interrupt.h>
	31	#include <linux/spinlock.h>
	32	#include <linux/timer.h>
	33	#include <linux/slab.h>
	34	#include <linux/pci_ids.h>
	35	#include <linux/pci.h>
1da177e4	36
bd529cfb EP	37	#include "../w1.h"
	38	#include "../w1_int.h"
	39	#include "../w1_log.h"
1da177e4 LT	40
	41	MODULE_LICENSE("GPL");
	42	MODULE_AUTHOR("Evgeniy Polyakov <johnpol@2ka.mipt.ru>");
	43	MODULE_DESCRIPTION("Driver for transport(Dallas 1-wire prtocol) over VGA DDC(matrox gpio).");
	44
	45	static struct pci_device_id matrox_w1_tbl[] = {
	46	{ PCI_DEVICE(PCI_VENDOR_ID_MATROX, PCI_DEVICE_ID_MATROX_G400) },
	47	{ },
	48	};
	49	MODULE_DEVICE_TABLE(pci, matrox_w1_tbl);
	50
	51	static int __devinit matrox_w1_probe(struct pci_dev , const struct pci_device_id );
	52	static void __devexit matrox_w1_remove(struct pci_dev *);
	53
	54	static struct pci_driver matrox_w1_pci_driver = {
	55	.name = "matrox_w1",
	56	.id_table = matrox_w1_tbl,
	57	.probe = matrox_w1_probe,
	58	.remove = __devexit_p(matrox_w1_remove),
	59	};
	60
7785925d	61	/*
1da177e4 LT	62	* Matrox G400 DDC registers.
	63	*/
	64
	65	#define MATROX_G400_DDC_CLK (1<<4)
	66	#define MATROX_G400_DDC_DATA (1<<1)
	67
	68	#define MATROX_BASE 0x3C00
	69	#define MATROX_STATUS 0x1e14
	70
	71	#define MATROX_PORT_INDEX_OFFSET 0x00
	72	#define MATROX_PORT_DATA_OFFSET 0x0A
	73
	74	#define MATROX_GET_CONTROL 0x2A
	75	#define MATROX_GET_DATA 0x2B
	76	#define MATROX_CURSOR_CTL 0x06
	77
	78	struct matrox_device
	79	{
	80	void __iomem *base_addr;
	81	void __iomem *port_index;
	82	void __iomem *port_data;
	83	u8 data_mask;
	84
	85	unsigned long phys_addr;
	86	void __iomem *virt_addr;
	87	unsigned long found;
	88
	89	struct w1_bus_master *bus_master;
	90	};
	91
ccd69940 EP	92	static u8 matrox_w1_read_ddc_bit(void *);
ccd69940 EP	93	static void matrox_w1_write_ddc_bit(void *, u8);
1da177e4 LT	94
	95	/*
	96	* These functions read and write DDC Data bit.
	97	*
	98	* Using tristate pins, since i can't find any open-drain pin in whole motherboard.
	99	* Unfortunately we can't connect to Intel's 82801xx IO controller
c30fe7f7	100	* since we don't know motherboard schema, which has pretty unused(may be not) GPIO.
1da177e4 LT	101	*
	102	* I've heard that PIIX also has open drain pin.
	103	*
	104	* Port mapping.
	105	*/
	106	static __inline__ u8 matrox_w1_read_reg(struct matrox_device *dev, u8 reg)
	107	{
	108	u8 ret;
	109
	110	writeb(reg, dev->port_index);
	111	ret = readb(dev->port_data);
	112	barrier();
	113
	114	return ret;
	115	}
	116
	117	static __inline__ void matrox_w1_write_reg(struct matrox_device *dev, u8 reg, u8 val)
	118	{
	119	writeb(reg, dev->port_index);
	120	writeb(val, dev->port_data);
	121	wmb();
	122	}
	123
ccd69940	124	static void matrox_w1_write_ddc_bit(void *data, u8 bit)
1da177e4 LT	125	{
1da177e4 LT	126	u8 ret;
ccd69940	127	struct matrox_device *dev = data;
1da177e4 LT	128
	129	if (bit)
	130	bit = 0;
	131	else
	132	bit = dev->data_mask;
	133
	134	ret = matrox_w1_read_reg(dev, MATROX_GET_CONTROL);
	135	matrox_w1_write_reg(dev, MATROX_GET_CONTROL, ((ret & ~dev->data_mask) \| bit));
	136	matrox_w1_write_reg(dev, MATROX_GET_DATA, 0x00);
	137	}
	138
ccd69940	139	static u8 matrox_w1_read_ddc_bit(void *data)
1da177e4 LT	140	{
1da177e4 LT	141	u8 ret;
ccd69940	142	struct matrox_device *dev = data;
1da177e4 LT	143
	144	ret = matrox_w1_read_reg(dev, MATROX_GET_DATA);
	145
	146	return ret;
	147	}
	148
	149	static void matrox_w1_hw_init(struct matrox_device *dev)
	150	{
	151	matrox_w1_write_reg(dev, MATROX_GET_DATA, 0xFF);
	152	matrox_w1_write_reg(dev, MATROX_GET_CONTROL, 0x00);
	153	}
	154
	155	static int __devinit matrox_w1_probe(struct pci_dev pdev, const struct pci_device_id ent)
	156	{
	157	struct matrox_device *dev;
	158	int err;
	159
	160	assert(pdev != NULL);
	161	assert(ent != NULL);
	162
	163	if (pdev->vendor != PCI_VENDOR_ID_MATROX \|\| pdev->device != PCI_DEVICE_ID_MATROX_G400)
	164	return -ENODEV;
	165
dd00cc48	166	dev = kzalloc(sizeof(struct matrox_device) +
1da177e4 LT	167	sizeof(struct w1_bus_master), GFP_KERNEL);
	168	if (!dev) {
	169	dev_err(&pdev->dev,
	170	"%s: Failed to create new matrox_device object.\n",
	171	__func__);
	172	return -ENOMEM;
	173	}
	174
1da177e4 LT	175
	176	dev->bus_master = (struct w1_bus_master *)(dev + 1);
	177
7785925d EP	178	/*
7785925d EP	179	* True for G400, for some other we need resource 0, see drivers/video/matrox/matroxfb_base.c
1da177e4 LT	180	*/
	181
	182	dev->phys_addr = pci_resource_start(pdev, 1);
	183
	184	dev->virt_addr = ioremap_nocache(dev->phys_addr, 16384);
	185	if (!dev->virt_addr) {
	186	dev_err(&pdev->dev, "%s: failed to ioremap(0x%lx, %d).\n",
	187	__func__, dev->phys_addr, 16384);
	188	err = -EIO;
	189	goto err_out_free_device;
	190	}
	191
	192	dev->base_addr = dev->virt_addr + MATROX_BASE;
	193	dev->port_index = dev->base_addr + MATROX_PORT_INDEX_OFFSET;
	194	dev->port_data = dev->base_addr + MATROX_PORT_DATA_OFFSET;
	195	dev->data_mask = (MATROX_G400_DDC_DATA);
	196
	197	matrox_w1_hw_init(dev);
	198
ccd69940	199	dev->bus_master->data = dev;
1da177e4 LT	200	dev->bus_master->read_bit = &matrox_w1_read_ddc_bit;
	201	dev->bus_master->write_bit = &matrox_w1_write_ddc_bit;
	202
	203	err = w1_add_master_device(dev->bus_master);
	204	if (err)
	205	goto err_out_free_device;
	206
	207	pci_set_drvdata(pdev, dev);
	208
	209	dev->found = 1;
	210
	211	dev_info(&pdev->dev, "Matrox G400 GPIO transport layer for 1-wire.\n");
	212
	213	return 0;
	214
	215	err_out_free_device:
e45413eb AL	216	if (dev->virt_addr)
e45413eb AL	217	iounmap(dev->virt_addr);
1da177e4 LT	218	kfree(dev);
	219
	220	return err;
	221	}
	222
	223	static void __devexit matrox_w1_remove(struct pci_dev *pdev)
	224	{
	225	struct matrox_device *dev = pci_get_drvdata(pdev);
	226
	227	assert(dev != NULL);
	228
	229	if (dev->found) {
	230	w1_remove_master_device(dev->bus_master);
	231	iounmap(dev->virt_addr);
	232	}
	233	kfree(dev);
	234	}
	235
	236	static int __init matrox_w1_init(void)
	237	{
	238	return pci_register_driver(&matrox_w1_pci_driver);
	239	}
	240
	241	static void __exit matrox_w1_fini(void)
	242	{
	243	pci_unregister_driver(&matrox_w1_pci_driver);
	244	}
	245
	246	module_init(matrox_w1_init);
	247	module_exit(matrox_w1_fini);