aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/gianfar_mii.h
blob: d527cf2f9c1d7f47398eaac003b361e79428b38b (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
/* 
 * drivers/net/gianfar_mii.h
 *
 * Gianfar Ethernet Driver -- MII Management Bus Implementation
 * Driver for the MDIO bus controller in the Gianfar register space
 *
 * Author: Andy Fleming
 * Maintainer: Kumar Gala
 *
 * Copyright (c) 2002-2004 Freescale Semiconductor, Inc.
 *
 * 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.
 *
 */
#ifndef __GIANFAR_MII_H
#define __GIANFAR_MII_H

#define MIIMIND_BUSY            0x00000001
#define MIIMIND_NOTVALID        0x00000004

#define MII_READ_COMMAND       0x00000001

#define GFAR_SUPPORTED (SUPPORTED_10baseT_Half \
		| SUPPORTED_10baseT_Full \
		| SUPPORTED_100baseT_Half \
		| SUPPORTED_100baseT_Full \
		| SUPPORTED_Autoneg \
		| SUPPORTED_MII)

struct gfar_mii {
	u32	miimcfg;	/* 0x.520 - MII Management Config Register */
	u32	miimcom;	/* 0x.524 - MII Management Command Register */
	u32	miimadd;	/* 0x.528 - MII Management Address Register */
	u32	miimcon;	/* 0x.52c - MII Management Control Register */
	u32	miimstat;	/* 0x.530 - MII Management Status Register */
	u32	miimind;	/* 0x.534 - MII Management Indicator Register */
};

int gfar_mdio_read(struct mii_bus *bus, int mii_id, int regnum);
int gfar_mdio_write(struct mii_bus *bus, int mii_id, int regnum, u16 value);
int __init gfar_mdio_init(void);
void __exit gfar_mdio_exit(void);
#endif /* GIANFAR_PHY_H */
class="hl com"> * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include <linux/kernel.h> #include <linux/module.h> #include <linux/i2c.h> #include <linux/input.h> #include <linux/slab.h> #include <linux/irq.h> #include <linux/interrupt.h> #include <linux/jiffies.h> #include <linux/delay.h> /* Address for each register */ #define CHIP_ID 0x00 #define QT1070_CHIP_ID 0x2E #define FW_VERSION 0x01 #define QT1070_FW_VERSION 0x15 #define DET_STATUS 0x02 #define KEY_STATUS 0x03 /* Calibrate */ #define CALIBRATE_CMD 0x38 #define QT1070_CAL_TIME 200 /* Reset */ #define RESET 0x39 #define QT1070_RESET_TIME 255 /* AT42QT1070 support up to 7 keys */ static const unsigned short qt1070_key2code[] = { KEY_0, KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, }; struct qt1070_data { struct i2c_client *client; struct input_dev *input; unsigned int irq; unsigned short keycodes[ARRAY_SIZE(qt1070_key2code)]; u8 last_keys; }; static int qt1070_read(struct i2c_client *client, u8 reg) { int ret; ret = i2c_smbus_read_byte_data(client, reg); if (ret < 0) dev_err(&client->dev, "can not read register, returned %d\n", ret); return ret; } static int qt1070_write(struct i2c_client *client, u8 reg, u8 data) { int ret; ret = i2c_smbus_write_byte_data(client, reg, data); if (ret < 0) dev_err(&client->dev, "can not write register, returned %d\n", ret); return ret; } static bool qt1070_identify(struct i2c_client *client) { int id, ver; /* Read Chip ID */ id = qt1070_read(client, CHIP_ID); if (id != QT1070_CHIP_ID) { dev_err(&client->dev, "ID %d not supported\n", id); return false; } /* Read firmware version */ ver = qt1070_read(client, FW_VERSION); if (ver < 0) { dev_err(&client->dev, "could not read the firmware version\n"); return false; } dev_info(&client->dev, "AT42QT1070 firmware version %x\n", ver); return true; } static irqreturn_t qt1070_interrupt(int irq, void *dev_id) { struct qt1070_data *data = dev_id; struct i2c_client *client = data->client; struct input_dev *input = data->input; int i; u8 new_keys, keyval, mask = 0x01; /* Read the detected status register, thus clearing interrupt */ qt1070_read(client, DET_STATUS); /* Read which key changed */ new_keys = qt1070_read(client, KEY_STATUS); for (i = 0; i < ARRAY_SIZE(qt1070_key2code); i++) { keyval = new_keys & mask; if ((data->last_keys & mask) != keyval) input_report_key(input, data->keycodes[i], keyval); mask <<= 1; } input_sync(input); data->last_keys = new_keys; return IRQ_HANDLED; } static int qt1070_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct qt1070_data *data; struct input_dev *input; int i; int err; err = i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE); if (!err) { dev_err(&client->dev, "%s adapter not supported\n", dev_driver_string(&client->adapter->dev)); return -ENODEV; } if (!client->irq) { dev_err(&client->dev, "please assign the irq to this device\n"); return -EINVAL; } /* Identify the qt1070 chip */ if (!qt1070_identify(client)) return -ENODEV; data = kzalloc(sizeof(struct qt1070_data), GFP_KERNEL); input = input_allocate_device(); if (!data || !input) { dev_err(&client->dev, "insufficient memory\n"); err = -ENOMEM; goto err_free_mem; } data->client = client; data->input = input; data->irq = client->irq; input->name = "AT42QT1070 QTouch Sensor"; input->dev.parent = &client->dev; input->id.bustype = BUS_I2C; /* Add the keycode */ input->keycode = data->keycodes; input->keycodesize = sizeof(data->keycodes[0]); input->keycodemax = ARRAY_SIZE(qt1070_key2code); __set_bit(EV_KEY, input->evbit); for (i = 0; i < ARRAY_SIZE(qt1070_key2code); i++) { data->keycodes[i] = qt1070_key2code[i]; __set_bit(qt1070_key2code[i], input->keybit); } /* Calibrate device */ qt1070_write(client, CALIBRATE_CMD, 1); msleep(QT1070_CAL_TIME); /* Soft reset */ qt1070_write(client, RESET, 1); msleep(QT1070_RESET_TIME); err = request_threaded_irq(client->irq, NULL, qt1070_interrupt, IRQF_TRIGGER_NONE | IRQF_ONESHOT, client->dev.driver->name, data); if (err) { dev_err(&client->dev, "fail to request irq\n"); goto err_free_mem; } /* Register the input device */ err = input_register_device(data->input); if (err) { dev_err(&client->dev, "Failed to register input device\n"); goto err_free_irq; } i2c_set_clientdata(client, data); /* Read to clear the chang line */ qt1070_read(client, DET_STATUS); return 0; err_free_irq: free_irq(client->irq, data); err_free_mem: input_free_device(input); kfree(data); return err; } static int qt1070_remove(struct i2c_client *client) { struct qt1070_data *data = i2c_get_clientdata(client); /* Release IRQ */ free_irq(client->irq, data); input_unregister_device(data->input); kfree(data); return 0; } #ifdef CONFIG_PM_SLEEP static int qt1070_suspend(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); struct qt1070_data *data = i2c_get_clientdata(client); if (device_may_wakeup(dev)) enable_irq_wake(data->irq); return 0; } static int qt1070_resume(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); struct qt1070_data *data = i2c_get_clientdata(client); if (device_may_wakeup(dev)) disable_irq_wake(data->irq); return 0; } #endif static SIMPLE_DEV_PM_OPS(qt1070_pm_ops, qt1070_suspend, qt1070_resume); static const struct i2c_device_id qt1070_id[] = { { "qt1070", 0 }, { }, }; MODULE_DEVICE_TABLE(i2c, qt1070_id); static struct i2c_driver qt1070_driver = { .driver = { .name = "qt1070", .owner = THIS_MODULE, .pm = &qt1070_pm_ops, }, .id_table = qt1070_id, .probe = qt1070_probe, .remove = qt1070_remove, }; module_i2c_driver(qt1070_driver); MODULE_AUTHOR("Bo Shen <voice.shen@atmel.com>"); MODULE_DESCRIPTION("Driver for AT42QT1070 QTouch sensor"); MODULE_LICENSE("GPL");