The structure describes per-device data, not per driver data. Convention
seems to be to use the _device suffix for this kind of structure.
Signed-off-by: Grant Likely <[EMAIL PROTECTED]>
---
drivers/usb/c67x00/c67x00-drv.c | 102 +++++++-------
drivers/usb/c67x00/c67x00-drv.h | 10 +-
drivers/usb/c67x00/c67x00-hcd.c | 4 +-
drivers/usb/c67x00/c67x00-hub.c | 2 +-
drivers/usb/c67x00/c67x00-ll-hpi.c | 266 ++++++++++++++++++------------------
drivers/usb/c67x00/c67x00-ll-hpi.h | 28 ++--
drivers/usb/c67x00/c67x00-sched.c | 10 +-
7 files changed, 211 insertions(+), 211 deletions(-)
diff --git a/drivers/usb/c67x00/c67x00-drv.c b/drivers/usb/c67x00/c67x00-drv.c
index 2737344..fe29734 100644
--- a/drivers/usb/c67x00/c67x00-drv.c
+++ b/drivers/usb/c67x00/c67x00-drv.c
@@ -51,7 +51,7 @@ static struct platform_driver c67x00_driver;
/* --------------------------------------------------------------------------
*/
static void setup_sie(struct c67x00_sie *sie,
- struct c67x00_drv *drv, int sie_num)
+ struct c67x00_device *dev, int sie_num)
{
static unsigned int id = 0;
@@ -61,9 +61,9 @@ static void setup_sie(struct c67x00_sie *sie,
/* driver used in hub.c: hub_port_init */
sie->pdev->dev.driver = &c67x00_driver.driver;
spin_lock_init(&sie->lock);
- sie->drv = drv;
+ sie->dev = dev;
sie->sie_num = sie_num;
- sie->mode = c67x00_sie_config(drv->pdata->sie_config, sie_num);
+ sie->mode = c67x00_sie_config(dev->pdata->sie_config, sie_num);
}
static void teardown_sie(struct c67x00_sie *sie)
@@ -76,7 +76,7 @@ static void teardown_sie(struct c67x00_sie *sie)
static void probe_sie(struct c67x00_sie *sie)
{
- switch (c67x00_sie_config(sie->drv->pdata->sie_config, sie->sie_num)) {
+ switch (c67x00_sie_config(sie->dev->pdata->sie_config, sie->sie_num)) {
case C67X00_SIE_HOST:
usb_hcd_c67x00_probe(sie);
break;
@@ -93,7 +93,7 @@ static void probe_sie(struct c67x00_sie *sie)
default:
dev_err(sie_dev(sie),
"Unsupported configuration: 0x%x for SIE %d\n",
- c67x00_sie_config(sie->drv->pdata->sie_config,
+ c67x00_sie_config(sie->dev->pdata->sie_config,
sie->sie_num), sie->sie_num);
break;
}
@@ -101,7 +101,7 @@ static void probe_sie(struct c67x00_sie *sie)
static void remove_sie(struct c67x00_sie *sie)
{
- switch (c67x00_sie_config(sie->drv->pdata->sie_config, sie->sie_num)) {
+ switch (c67x00_sie_config(sie->dev->pdata->sie_config, sie->sie_num)) {
case C67X00_SIE_HOST:
usb_hcd_c67x00_remove(sie);
break;
@@ -117,36 +117,36 @@ static void remove_sie(struct c67x00_sie *sie)
/* --------------------------------------------------------------------------
*/
-static irqreturn_t c67x00_irq(int irq, void *__drv)
+static irqreturn_t c67x00_irq(int irq, void *__dev)
{
- struct c67x00_drv *drv = __drv;
+ struct c67x00_device *dev = __dev;
int i, count = 8;
- drv->int_status = c67x00_hpi_status(drv);
- if (!drv->int_status)
+ dev->int_status = c67x00_hpi_status(dev);
+ if (!dev->int_status)
return IRQ_NONE;
- while (drv->int_status != 0 && (count-- >= 0)) {
- c67x00_ll_irq(drv);
+ while (dev->int_status != 0 && (count-- >= 0)) {
+ c67x00_ll_irq(dev);
for (i = 0; i < C67X00_SIES; i++) {
- spin_lock(&drv->sie[i].lock);
- if (drv->int_status & SIEMSG_FLAG(i)) {
+ spin_lock(&dev->sie[i].lock);
+ if (dev->int_status & SIEMSG_FLAG(i)) {
u16 msg;
- msg = c67x00_ll_get_siemsg(drv, i);
- if (drv->sie[i].msg_received)
- drv->sie[i].msg_received(&drv->sie[i],
+ msg = c67x00_ll_get_siemsg(dev, i);
+ if (dev->sie[i].msg_received)
+ dev->sie[i].msg_received(&dev->sie[i],
msg);
}
- if (drv->sie[i].irq)
- drv->sie[i].irq(irq, &drv->sie[i]);
- spin_unlock(&drv->sie[i].lock);
+ if (dev->sie[i].irq)
+ dev->sie[i].irq(irq, &dev->sie[i]);
+ spin_unlock(&dev->sie[i].lock);
}
- drv->int_status = c67x00_hpi_status(drv);
+ dev->int_status = c67x00_hpi_status(dev);
}
- if (drv->int_status)
- dev_warn(&drv->pdev->dev, "Not all interrupts handled! "
- "status = 0x%04x\n", drv->int_status);
+ if (dev->int_status)
+ dev_warn(&dev->pdev->dev, "Not all interrupts handled! "
+ "status = 0x%04x\n", dev->int_status);
return IRQ_HANDLED;
}
@@ -155,7 +155,7 @@ static irqreturn_t c67x00_irq(int irq, void *__drv)
static int __devinit usb_c67x00_drv_probe(struct platform_device *pdev)
{
- struct c67x00_drv *drv;
+ struct c67x00_device *dev;
struct c67x00_platform_data *pdata;
struct resource *res, *res2;
int ret, i;
@@ -172,8 +172,8 @@ static int __devinit usb_c67x00_drv_probe(struct
platform_device *pdev)
if (!pdata)
return -ENODEV;
- drv = kzalloc(sizeof(*drv), GFP_KERNEL);
- if (!drv)
+ dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+ if (!dev)
return -ENOMEM;
if (!request_mem_region(res->start, res->end - res->start + 1,
@@ -182,82 +182,82 @@ static int __devinit usb_c67x00_drv_probe(struct
platform_device *pdev)
ret = -EBUSY;
goto request_mem_failed;
}
- drv->hpi.base = ioremap(res->start, res->end - res->start + 1);
- if (!drv->hpi.base) {
+ dev->hpi.base = ioremap(res->start, res->end - res->start + 1);
+ if (!dev->hpi.base) {
dev_err(&pdev->dev, "Unable to map HPI registers\n");
ret = -EIO;
goto map_failed;
}
- spin_lock_init(&drv->hw_lock);
- drv->hpi.regstep = pdata->hpi_regstep;
- drv->pdata = pdev->dev.platform_data;
- drv->pdev = pdev;
+ spin_lock_init(&dev->hw_lock);
+ dev->hpi.regstep = pdata->hpi_regstep;
+ dev->pdata = pdev->dev.platform_data;
+ dev->pdev = pdev;
for (i = 0; i < C67X00_SIES; i++)
- setup_sie(&drv->sie[i], drv, i);
+ setup_sie(&dev->sie[i], dev, i);
- c67x00_ll_init(drv);
- c67x00_ll_hpi_reg_init(drv);
+ c67x00_ll_init(dev);
+ c67x00_ll_hpi_reg_init(dev);
dev_info(&pdev->dev, "USB OTG controller, p:0x%x, v:0x%p, irq:%i\n",
- res->start, drv->hpi.base, res2->start);
+ res->start, dev->hpi.base, res2->start);
- ret = request_irq(res2->start, c67x00_irq, 0, pdev->name, drv);
+ ret = request_irq(res2->start, c67x00_irq, 0, pdev->name, dev);
if (ret) {
dev_err(&pdev->dev, "Cannot claim IRQ\n");
goto request_irq_failed;
}
- ret = c67x00_ll_reset(drv);
+ ret = c67x00_ll_reset(dev);
if (ret) {
dev_err(&pdev->dev, "Device reset failed\n");
goto reset_failed;
}
for (i = 0; i < C67X00_SIES; i++)
- probe_sie(&drv->sie[i]);
+ probe_sie(&dev->sie[i]);
- platform_set_drvdata(pdev, drv);
+ platform_set_drvdata(pdev, dev);
return 0;
reset_failed:
- free_irq(res2->start, drv);
+ free_irq(res2->start, dev);
request_irq_failed:
- iounmap(drv->hpi.base);
+ iounmap(dev->hpi.base);
map_failed:
release_mem_region(res->start, res->end - res->start + 1);
request_mem_failed:
- kfree(drv);
+ kfree(dev);
return ret;
}
static int __devexit usb_c67x00_drv_remove(struct platform_device *pdev)
{
- struct c67x00_drv *drv = platform_get_drvdata(pdev);
+ struct c67x00_device *dev = platform_get_drvdata(pdev);
struct resource *res;
int i;
for (i = 0; i < C67X00_SIES; i++) {
- remove_sie(&drv->sie[i]);
- teardown_sie(&drv->sie[i]);
+ remove_sie(&dev->sie[i]);
+ teardown_sie(&dev->sie[i]);
}
- c67x00_ll_release(drv);
+ c67x00_ll_release(dev);
res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
if (res)
- free_irq(res->start, drv);
+ free_irq(res->start, dev);
- iounmap(drv->hpi.base);
+ iounmap(dev->hpi.base);
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (res)
release_mem_region(res->start, res->end - res->start + 1);
- kfree(drv);
+ kfree(dev);
return 0;
}
diff --git a/drivers/usb/c67x00/c67x00-drv.h b/drivers/usb/c67x00/c67x00-drv.h
index 8e7b99c..d29f4ad 100644
--- a/drivers/usb/c67x00/c67x00-drv.h
+++ b/drivers/usb/c67x00/c67x00-drv.h
@@ -31,7 +31,7 @@
#include <linux/workqueue.h>
#include "c67x00-ll-hpi.h"
-struct c67x00_drv;
+struct c67x00_device;
/**
* struct c67x00_sie - Common data associated with an SIE
@@ -40,7 +40,7 @@ struct c67x00_drv;
* @pdev: platform device associated with this SIE, created in c67x00-drv.c
* @irq: subdriver depenent irq handler, set NULL when not used
* @msg_received: called when an SIEmsg has been received
- * @drv: link to common driver structure
+ * @dev: link to common driver structure
* @sie_num: SIE number on chip, starting from 0
* @mode: SIE mode (host/peripheral/otg/not used)
*
@@ -57,7 +57,7 @@ struct c67x00_sie {
void (*msg_received) (struct c67x00_sie * sie, u16 msg);
/* Read only: */
- struct c67x00_drv *drv;
+ struct c67x00_device *dev;
int sie_num;
int mode;
};
@@ -73,7 +73,7 @@ struct c67x00_hpi {
#define C67X00_PORTS 2
/**
- * struct c67x00_drv - Common data structure associated with a c67x00 instance
+ * struct c67x00_device - Common data structure associated with a c67x00
instance
* @hpi: hpi addresses
* @sie: array of sie's on this chip
* @pdata: configuration provided by the platform
@@ -81,7 +81,7 @@ struct c67x00_hpi {
* @int_status: interrupt status register, only valid in_interrupt()
* @lcp: lcp dependent data
*/
-struct c67x00_drv {
+struct c67x00_device {
struct c67x00_hpi hpi;
struct c67x00_sie sie[C67X00_SIES];
struct platform_device *pdev;
diff --git a/drivers/usb/c67x00/c67x00-hcd.c b/drivers/usb/c67x00/c67x00-hcd.c
index 357e34f..d5458ea 100644
--- a/drivers/usb/c67x00/c67x00-hcd.c
+++ b/drivers/usb/c67x00/c67x00-hcd.c
@@ -51,9 +51,9 @@ static irqreturn_t c67x00_hcd_irq(struct usb_hcd *hcd)
{
struct c67x00_hcd *c67x00 = hcd_to_c67x00_hcd(hcd);
struct c67x00_sie *sie = c67x00->sie;
- struct c67x00_drv *drv = sie->drv;
+ struct c67x00_device *dev = sie->dev;
int host = sie->sie_num;
- if (drv->int_status & SOFEOP_FLG(host)) {
+ if (dev->int_status & SOFEOP_FLG(host)) {
c67x00_ll_husb_clear_status(sie, SOF_EOP_IRQ_FLG);
c67x00_sched_sofeop(c67x00);
return IRQ_HANDLED;
diff --git a/drivers/usb/c67x00/c67x00-hub.c b/drivers/usb/c67x00/c67x00-hub.c
index 91ad898..2518106 100644
--- a/drivers/usb/c67x00/c67x00-hub.c
+++ b/drivers/usb/c67x00/c67x00-hub.c
@@ -50,7 +50,7 @@ static void reset_host_port(struct c67x00_sie *sie, int port)
c67x00_ll_husb_reset_port(sie, port);
spin_unlock_irqrestore(&c67x00->lock, flags);
- c67x00_ll_set_husb_eot(sie->drv, DEFAULT_EOT);
+ c67x00_ll_set_husb_eot(sie->dev, DEFAULT_EOT);
}
/* --------------------------------------------------------------------------
*/
diff --git a/drivers/usb/c67x00/c67x00-ll-hpi.c
b/drivers/usb/c67x00/c67x00-ll-hpi.c
index 868736a..052f35d 100644
--- a/drivers/usb/c67x00/c67x00-ll-hpi.c
+++ b/drivers/usb/c67x00/c67x00-ll-hpi.c
@@ -65,250 +65,250 @@
/* These functions could also be implemented with SPI of HSS.
* This is currently not supported */
-static inline u16 hpi_read_reg(struct c67x00_drv *drv, int reg)
+static inline u16 hpi_read_reg(struct c67x00_device *dev, int reg)
{
- return __raw_readw(drv->hpi.base + reg * drv->hpi.regstep);
+ return __raw_readw(dev->hpi.base + reg * dev->hpi.regstep);
}
-static inline void hpi_write_reg(struct c67x00_drv *drv, int reg, u16 value)
+static inline void hpi_write_reg(struct c67x00_device *dev, int reg, u16 value)
{
- __raw_writew(value, drv->hpi.base + reg * drv->hpi.regstep);
+ __raw_writew(value, dev->hpi.base + reg * dev->hpi.regstep);
}
-static inline u16 hpi_read_word_nolock(struct c67x00_drv *drv, u16 reg)
+static inline u16 hpi_read_word_nolock(struct c67x00_device *dev, u16 reg)
{
- hpi_write_reg(drv, HPI_ADDR, reg);
- return hpi_read_reg(drv, HPI_DATA);
+ hpi_write_reg(dev, HPI_ADDR, reg);
+ return hpi_read_reg(dev, HPI_DATA);
}
-static inline u16 hpi_read_word(struct c67x00_drv *drv, u16 reg)
+static inline u16 hpi_read_word(struct c67x00_device *dev, u16 reg)
{
u16 value;
unsigned long flags;
- spin_lock_irqsave(&drv->hw_lock, flags);
- value = hpi_read_word_nolock(drv, reg);
- spin_unlock_irqrestore(&drv->hw_lock, flags);
+ spin_lock_irqsave(&dev->hw_lock, flags);
+ value = hpi_read_word_nolock(dev, reg);
+ spin_unlock_irqrestore(&dev->hw_lock, flags);
return value;
}
-static inline void hpi_write_word_nolock(struct c67x00_drv *drv, u16 reg,
+static inline void hpi_write_word_nolock(struct c67x00_device *dev, u16 reg,
u16 value)
{
- hpi_write_reg(drv, HPI_ADDR, reg);
- hpi_write_reg(drv, HPI_DATA, value);
+ hpi_write_reg(dev, HPI_ADDR, reg);
+ hpi_write_reg(dev, HPI_DATA, value);
}
-static inline void hpi_write_word(struct c67x00_drv *drv, u16 reg, u16 value)
+static inline void hpi_write_word(struct c67x00_device *dev, u16 reg, u16
value)
{
unsigned long flags;
- spin_lock_irqsave(&drv->hw_lock, flags);
- hpi_write_word_nolock(drv, reg, value);
- spin_unlock_irqrestore(&drv->hw_lock, flags);
+ spin_lock_irqsave(&dev->hw_lock, flags);
+ hpi_write_word_nolock(dev, reg, value);
+ spin_unlock_irqrestore(&dev->hw_lock, flags);
}
/*
* Only data is little endian, addr has cpu endianess
*/
-static inline void hpi_write_words_le16(struct c67x00_drv *drv, u16 addr,
+static inline void hpi_write_words_le16(struct c67x00_device *dev, u16 addr,
u16 * data, u16 count)
{
unsigned long flags;
int i;
- spin_lock_irqsave(&drv->hw_lock, flags);
+ spin_lock_irqsave(&dev->hw_lock, flags);
- hpi_write_reg(drv, HPI_ADDR, addr);
+ hpi_write_reg(dev, HPI_ADDR, addr);
for (i = 0; i < count; i++)
- hpi_write_reg(drv, HPI_DATA, cpu_to_le16(*data++));
+ hpi_write_reg(dev, HPI_DATA, cpu_to_le16(*data++));
- spin_unlock_irqrestore(&drv->hw_lock, flags);
+ spin_unlock_irqrestore(&dev->hw_lock, flags);
}
/*
* Only data is little endian, addr has cpu endianess
*/
-static inline void hpi_read_words_le16(struct c67x00_drv *drv, u16 addr,
+static inline void hpi_read_words_le16(struct c67x00_device *dev, u16 addr,
u16 * data, u16 count)
{
unsigned long flags;
int i;
- spin_lock_irqsave(&drv->hw_lock, flags);
- hpi_write_reg(drv, HPI_ADDR, addr);
+ spin_lock_irqsave(&dev->hw_lock, flags);
+ hpi_write_reg(dev, HPI_ADDR, addr);
for (i = 0; i < count; i++)
- *data++ = le16_to_cpu(hpi_read_reg(drv, HPI_DATA));
+ *data++ = le16_to_cpu(hpi_read_reg(dev, HPI_DATA));
- spin_unlock_irqrestore(&drv->hw_lock, flags);
+ spin_unlock_irqrestore(&dev->hw_lock, flags);
}
-static inline void hpi_set_bits(struct c67x00_drv *drv, u16 reg, u16 mask)
+static inline void hpi_set_bits(struct c67x00_device *dev, u16 reg, u16 mask)
{
u16 value;
unsigned long flags;
- spin_lock_irqsave(&drv->hw_lock, flags);
- value = hpi_read_word_nolock(drv, reg);
- hpi_write_word_nolock(drv, reg, value | mask);
- spin_unlock_irqrestore(&drv->hw_lock, flags);
+ spin_lock_irqsave(&dev->hw_lock, flags);
+ value = hpi_read_word_nolock(dev, reg);
+ hpi_write_word_nolock(dev, reg, value | mask);
+ spin_unlock_irqrestore(&dev->hw_lock, flags);
}
-static inline void hpi_clear_bits(struct c67x00_drv *drv, u16 reg, u16 mask)
+static inline void hpi_clear_bits(struct c67x00_device *dev, u16 reg, u16 mask)
{
u16 value;
unsigned long flags;
- spin_lock_irqsave(&drv->hw_lock, flags);
- value = hpi_read_word_nolock(drv, reg);
- hpi_write_word_nolock(drv, reg, value & ~mask);
- spin_unlock_irqrestore(&drv->hw_lock, flags);
+ spin_lock_irqsave(&dev->hw_lock, flags);
+ value = hpi_read_word_nolock(dev, reg);
+ hpi_write_word_nolock(dev, reg, value & ~mask);
+ spin_unlock_irqrestore(&dev->hw_lock, flags);
}
-static inline u16 hpi_recv_mbox(struct c67x00_drv *drv)
+static inline u16 hpi_recv_mbox(struct c67x00_device *dev)
{
u16 value;
unsigned long flags;
- spin_lock_irqsave(&drv->hw_lock, flags);
- value = hpi_read_reg(drv, HPI_MAILBOX);
- spin_unlock_irqrestore(&drv->hw_lock, flags);
+ spin_lock_irqsave(&dev->hw_lock, flags);
+ value = hpi_read_reg(dev, HPI_MAILBOX);
+ spin_unlock_irqrestore(&dev->hw_lock, flags);
return value;
}
-static inline u16 hpi_send_mbox(struct c67x00_drv *drv, u16 value)
+static inline u16 hpi_send_mbox(struct c67x00_device *dev, u16 value)
{
unsigned long flags;
- spin_lock_irqsave(&drv->hw_lock, flags);
- hpi_write_reg(drv, HPI_MAILBOX, value);
- spin_unlock_irqrestore(&drv->hw_lock, flags);
+ spin_lock_irqsave(&dev->hw_lock, flags);
+ hpi_write_reg(dev, HPI_MAILBOX, value);
+ spin_unlock_irqrestore(&dev->hw_lock, flags);
return value;
}
-u16 c67x00_hpi_status(struct c67x00_drv * drv)
+u16 c67x00_hpi_status(struct c67x00_device * dev)
{
u16 value;
unsigned long flags;
- spin_lock_irqsave(&drv->hw_lock, flags);
- value = hpi_read_reg(drv, HPI_STATUS);
- spin_unlock_irqrestore(&drv->hw_lock, flags);
+ spin_lock_irqsave(&dev->hw_lock, flags);
+ value = hpi_read_reg(dev, HPI_STATUS);
+ spin_unlock_irqrestore(&dev->hw_lock, flags);
return value;
}
-void c67x00_ll_hpi_reg_init(struct c67x00_drv *drv)
+void c67x00_ll_hpi_reg_init(struct c67x00_device *dev)
{
int i;
- hpi_recv_mbox(drv);
- c67x00_hpi_status(drv);
- hpi_write_word(drv, HPI_IRQ_ROUTING_REG, 0);
+ hpi_recv_mbox(dev);
+ c67x00_hpi_status(dev);
+ hpi_write_word(dev, HPI_IRQ_ROUTING_REG, 0);
for (i=0; i<C67X00_SIES; i++) {
- hpi_write_word(drv, SIEMSG_REG(i), 0);
- hpi_read_word(drv, SIEMSG_REG(i));
+ hpi_write_word(dev, SIEMSG_REG(i), 0);
+ hpi_read_word(dev, SIEMSG_REG(i));
}
}
void c67x00_ll_hpi_enable_sofeop(struct c67x00_sie *sie)
{
- hpi_set_bits(sie->drv, HPI_IRQ_ROUTING_REG,
+ hpi_set_bits(sie->dev, HPI_IRQ_ROUTING_REG,
SOFEOP_TO_HPI_EN(sie->sie_num));
}
void c67x00_ll_hpi_disable_sofeop(struct c67x00_sie *sie)
{
- hpi_clear_bits(sie->drv, HPI_IRQ_ROUTING_REG,
+ hpi_clear_bits(sie->dev, HPI_IRQ_ROUTING_REG,
SOFEOP_TO_HPI_EN(sie->sie_num));
}
/* --------------------------------------------------------------------------
*/
/* Transactions */
-static inline void ll_start(struct c67x00_drv *drv)
+static inline void ll_start(struct c67x00_device *dev)
{
- INIT_COMPLETION(drv->lcp.msg_received);
- mutex_lock(&drv->lcp.mutex);
+ INIT_COMPLETION(dev->lcp.msg_received);
+ mutex_lock(&dev->lcp.mutex);
}
-static inline u16 ll_recv_msg(struct c67x00_drv *drv)
+static inline u16 ll_recv_msg(struct c67x00_device *dev)
{
u16 res;
- res = wait_for_completion_timeout(&drv->lcp.msg_received, 5 * HZ);
- INIT_COMPLETION(drv->lcp.msg_received);
+ res = wait_for_completion_timeout(&dev->lcp.msg_received, 5 * HZ);
+ INIT_COMPLETION(dev->lcp.msg_received);
WARN_ON(!res);
return (res == 0) ? -EIO : 0;
}
-static inline void ll_release(struct c67x00_drv *drv)
+static inline void ll_release(struct c67x00_device *dev)
{
- mutex_unlock(&drv->lcp.mutex);
+ mutex_unlock(&dev->lcp.mutex);
}
/* --------------------------------------------------------------------------
*/
/* General functions */
-u16 c67x00_ll_get_siemsg(struct c67x00_drv *drv, int sie)
+u16 c67x00_ll_get_siemsg(struct c67x00_device *dev, int sie)
{
- return hpi_read_word(drv, SIEMSG_REG(sie));
+ return hpi_read_word(dev, SIEMSG_REG(sie));
}
-void c67x00_ll_set_siemsg(struct c67x00_drv *drv, int sie, u16 val)
+void c67x00_ll_set_siemsg(struct c67x00_device *dev, int sie, u16 val)
{
- hpi_write_word(drv, SIEMSG_REG(sie), val);
+ hpi_write_word(dev, SIEMSG_REG(sie), val);
}
u16 c67x00_ll_get_usb_ctl(struct c67x00_sie *sie)
{
- return hpi_read_word(sie->drv, USB_CTL_REG(sie->sie_num));
+ return hpi_read_word(sie->dev, USB_CTL_REG(sie->sie_num));
}
/* --------------------------------------------------------------------------
*/
/* Host specific functions */
-void c67x00_ll_set_husb_eot(struct c67x00_drv *drv, u16 value)
+void c67x00_ll_set_husb_eot(struct c67x00_device *dev, u16 value)
{
- ll_start(drv);
- hpi_write_word(drv, HUSB_pEOT, value);
- ll_release(drv);
+ ll_start(dev);
+ hpi_write_word(dev, HUSB_pEOT, value);
+ ll_release(dev);
}
static inline void c67x00_ll_husb_sie_init(struct c67x00_sie *sie)
{
- struct c67x00_drv *drv = sie->drv;
+ struct c67x00_device *dev = sie->dev;
struct lcp_int_data data;
int rc;
- rc = c67x00_comm_exec_int(drv, HUSB_SIE_INIT_INT(sie->sie_num), &data);
+ rc = c67x00_comm_exec_int(dev, HUSB_SIE_INIT_INT(sie->sie_num), &data);
BUG_ON(rc); /* No return path for error code; crash spectacularly */
}
void c67x00_ll_husb_reset(struct c67x00_sie *sie, int port)
{
- struct c67x00_drv *drv = sie->drv;
+ struct c67x00_device *dev = sie->dev;
struct lcp_int_data data;
int rc;
data.regs[0] = 50; /* Reset USB port for 50ms */
data.regs[1] = port | (sie->sie_num << 1);
- rc = c67x00_comm_exec_int(drv, HUSB_RESET_INT, &data);
+ rc = c67x00_comm_exec_int(dev, HUSB_RESET_INT, &data);
BUG_ON(rc); /* No return path for error code; crash spectacularly */
}
void c67x00_ll_husb_set_current_td(struct c67x00_sie *sie, u16 addr)
{
- hpi_write_word(sie->drv, HUSB_SIE_pCurrentTDPtr(sie->sie_num), addr);
+ hpi_write_word(sie->dev, HUSB_SIE_pCurrentTDPtr(sie->sie_num), addr);
}
u16 c67x00_ll_husb_get_current_td(struct c67x00_sie *sie)
{
- return hpi_read_word(sie->drv, HUSB_SIE_pCurrentTDPtr(sie->sie_num));
+ return hpi_read_word(sie->dev, HUSB_SIE_pCurrentTDPtr(sie->sie_num));
}
/**
@@ -316,28 +316,28 @@ u16 c67x00_ll_husb_get_current_td(struct c67x00_sie *sie)
*/
void c67x00_ll_husb_clear_status(struct c67x00_sie *sie, u16 bits)
{
- hpi_write_word(sie->drv, HOST_STAT_REG(sie->sie_num), bits);
+ hpi_write_word(sie->dev, HOST_STAT_REG(sie->sie_num), bits);
}
u16 c67x00_ll_husb_get_status(struct c67x00_sie *sie)
{
- return hpi_read_word(sie->drv, HOST_STAT_REG(sie->sie_num));
+ return hpi_read_word(sie->dev, HOST_STAT_REG(sie->sie_num));
}
u16 c67x00_ll_husb_get_frame(struct c67x00_sie * sie)
{
- return hpi_read_word(sie->drv, HOST_FRAME_REG(sie->sie_num));
+ return hpi_read_word(sie->dev, HOST_FRAME_REG(sie->sie_num));
}
void c67x00_ll_husb_init_host_port(struct c67x00_sie *sie)
{
/* Set port into host mode */
- hpi_set_bits(sie->drv, USB_CTL_REG(sie->sie_num), HOST_MODE);
+ hpi_set_bits(sie->dev, USB_CTL_REG(sie->sie_num), HOST_MODE);
c67x00_ll_husb_sie_init(sie);
/* Clear interrupts */
c67x00_ll_husb_clear_status(sie, HOST_STAT_MASK);
/* Check */
- if (!(hpi_read_word(sie->drv, USB_CTL_REG(sie->sie_num)) & HOST_MODE))
+ if (!(hpi_read_word(sie->dev, USB_CTL_REG(sie->sie_num)) & HOST_MODE))
dev_warn(sie_dev(sie),
"SIE %d not set to host mode\n", sie->sie_num);
}
@@ -348,94 +348,94 @@ void c67x00_ll_husb_reset_port(struct c67x00_sie *sie,
int port)
c67x00_ll_husb_clear_status(sie, PORT_CONNECT_CHANGE(port));
/* Enable interrupts */
- hpi_set_bits(sie->drv, HPI_IRQ_ROUTING_REG,
+ hpi_set_bits(sie->dev, HPI_IRQ_ROUTING_REG,
SOFEOP_TO_CPU_EN(sie->sie_num));
- hpi_set_bits(sie->drv, HOST_IRQ_EN_REG(sie->sie_num),
+ hpi_set_bits(sie->dev, HOST_IRQ_EN_REG(sie->sie_num),
SOF_EOP_IRQ_EN | DONE_IRQ_EN);
/* Enable pull down transistors */
- hpi_set_bits(sie->drv, USB_CTL_REG(sie->sie_num), PORT_RES_EN(port));
+ hpi_set_bits(sie->dev, USB_CTL_REG(sie->sie_num), PORT_RES_EN(port));
}
/* --------------------------------------------------------------------------
*/
void c67x00_ll_susb_init(struct c67x00_sie *sie)
{
- struct c67x00_drv *drv = sie->drv;
+ struct c67x00_device *dev = sie->dev;
struct lcp_int_data data;
int rc;
data.regs[1] = 1; /* full speed */
data.regs[2] = sie->sie_num + 1;
- rc = c67x00_comm_exec_int(drv, SUSB_INIT_INT, &data);
+ rc = c67x00_comm_exec_int(dev, SUSB_INIT_INT, &data);
BUG_ON(rc); /* No return path for error code; crash spectacularly */
- hpi_clear_bits(drv, HPI_IRQ_ROUTING_REG,
+ hpi_clear_bits(dev, HPI_IRQ_ROUTING_REG,
SOFEOP_TO_HPI_EN(sie->sie_num));
- hpi_set_bits(drv, HPI_IRQ_ROUTING_REG, SOFEOP_TO_CPU_EN(sie->sie_num));
+ hpi_set_bits(dev, HPI_IRQ_ROUTING_REG, SOFEOP_TO_CPU_EN(sie->sie_num));
}
/* --------------------------------------------------------------------------
*/
-void c67x00_ll_irq(struct c67x00_drv *drv)
+void c67x00_ll_irq(struct c67x00_device *dev)
{
- if ((drv->int_status & MBX_OUT_FLG) == 0)
+ if ((dev->int_status & MBX_OUT_FLG) == 0)
return;
- drv->lcp.last_msg = hpi_recv_mbox(drv);
- complete(&drv->lcp.msg_received);
+ dev->lcp.last_msg = hpi_recv_mbox(dev);
+ complete(&dev->lcp.msg_received);
}
/* --------------------------------------------------------------------------
*/
-u16 c67x00_comm_read_ctrl_reg(struct c67x00_drv * drv, u16 addr)
+u16 c67x00_comm_read_ctrl_reg(struct c67x00_device * dev, u16 addr)
{
unsigned long msg, res;
int rc;
- ll_start(drv);
- hpi_write_word(drv, COMM_CTRL_REG_ADDR, addr);
- hpi_send_mbox(drv, COMM_READ_CTRL_REG);
- rc = ll_recv_msg(drv);
+ ll_start(dev);
+ hpi_write_word(dev, COMM_CTRL_REG_ADDR, addr);
+ hpi_send_mbox(dev, COMM_READ_CTRL_REG);
+ rc = ll_recv_msg(dev);
BUG_ON(rc); /* No return path for error code; crash spectacularly */
- msg = drv->lcp.last_msg;
+ msg = dev->lcp.last_msg;
if (msg != COMM_ACK) {
- dev_warn(&drv->pdev->dev, "COMM_READ_CTRL_REG didn't ACK!\n");
+ dev_warn(&dev->pdev->dev, "COMM_READ_CTRL_REG didn't ACK!\n");
res = 0;
} else {
- res = hpi_read_word(drv, COMM_CTRL_REG_DATA);
+ res = hpi_read_word(dev, COMM_CTRL_REG_DATA);
}
- ll_release(drv);
+ ll_release(dev);
return res;
}
-int c67x00_comm_exec_int(struct c67x00_drv *drv, u16 nr,
+int c67x00_comm_exec_int(struct c67x00_device *dev, u16 nr,
struct lcp_int_data *data)
{
int i, rc;
- ll_start(drv);
- hpi_write_word(drv, COMM_INT_NUM, nr);
+ ll_start(dev);
+ hpi_write_word(dev, COMM_INT_NUM, nr);
for (i = 0; i < COMM_REGS; i++)
- hpi_write_word(drv, COMM_R(i), data->regs[i]);
- hpi_send_mbox(drv, COMM_EXEC_INT);
- rc = ll_recv_msg(drv);
- ll_release(drv);
+ hpi_write_word(dev, COMM_R(i), data->regs[i]);
+ hpi_send_mbox(dev, COMM_EXEC_INT);
+ rc = ll_recv_msg(dev);
+ ll_release(dev);
return rc;
}
/* --------------------------------------------------------------------------
*/
-int c67x00_ll_reset(struct c67x00_drv *drv)
+int c67x00_ll_reset(struct c67x00_device *dev)
{
int rc;
- ll_start(drv);
- hpi_send_mbox(drv, COMM_RESET);
- rc = ll_recv_msg(drv);
- ll_release(drv);
+ ll_start(dev);
+ hpi_send_mbox(dev, COMM_RESET);
+ rc = ll_recv_msg(dev);
+ ll_release(dev);
return rc;
}
@@ -446,12 +446,12 @@ int c67x00_ll_reset(struct c67x00_drv *drv)
* c67x00_write_mem_le16 - write into c67x00 memory
* Only data is little endian, addr has cpu endianess.
*/
-void c67x00_write_mem_le16(struct c67x00_drv *drv, u16 addr,
+void c67x00_write_mem_le16(struct c67x00_device *dev, u16 addr,
int len, char *data)
{
/* Sanity check */
if (addr + len > 0xffff) {
- dev_err(&drv->pdev->dev,
+ dev_err(&dev->pdev->dev,
"Trying to write beyond writable region!\n");
return;
}
@@ -459,23 +459,23 @@ void c67x00_write_mem_le16(struct c67x00_drv *drv, u16
addr,
if (addr & 0x01) {
/* unaligned access */
u16 tmp;
- tmp = hpi_read_word(drv, addr - 1);
+ tmp = hpi_read_word(dev, addr - 1);
tmp = (tmp & 0x00ff) | (*data++ << 8);
- hpi_write_word(drv, addr - 1, tmp);
+ hpi_write_word(dev, addr - 1, tmp);
addr++;
len--;
}
- hpi_write_words_le16(drv, addr, (u16 *) data, len / 2);
+ hpi_write_words_le16(dev, addr, (u16 *) data, len / 2);
data += len & ~0x01;
addr += len & ~0x01;
len &= 0x01;
if (len) {
u16 tmp;
- tmp = hpi_read_word(drv, addr);
+ tmp = hpi_read_word(dev, addr);
tmp = (tmp & 0xff00) | (*data++);
- hpi_write_word(drv, addr, tmp);
+ hpi_write_word(dev, addr, tmp);
addr++;
len--;
}
@@ -486,25 +486,25 @@ void c67x00_write_mem_le16(struct c67x00_drv *drv, u16
addr,
* c67x00_read_mem_le16 - read from c67x00 memory
* Only data is little endian, addr has cpu endianess.
*/
-void c67x00_read_mem_le16(struct c67x00_drv *drv, u16 addr, int len, char
*data)
+void c67x00_read_mem_le16(struct c67x00_device *dev, u16 addr, int len, char
*data)
{
if (addr & 0x01) {
/* unaligned access */
u16 tmp;
- tmp = hpi_read_word(drv, addr - 1);
+ tmp = hpi_read_word(dev, addr - 1);
*data++ = (tmp >> 8) & 0x00ff;
addr++;
len--;
}
- hpi_read_words_le16(drv, addr, (u16 *) data, len / 2);
+ hpi_read_words_le16(dev, addr, (u16 *) data, len / 2);
data += len & ~0x01;
addr += len & ~0x01;
len &= 0x01;
if (len) {
u16 tmp;
- tmp = hpi_read_word(drv, addr);
+ tmp = hpi_read_word(dev, addr);
*data++ = tmp & 0x00ff;
addr++;
len--;
@@ -513,12 +513,12 @@ void c67x00_read_mem_le16(struct c67x00_drv *drv, u16
addr, int len, char *data)
/* --------------------------------------------------------------------------
*/
-void c67x00_ll_init(struct c67x00_drv *drv)
+void c67x00_ll_init(struct c67x00_device *dev)
{
- mutex_init(&drv->lcp.mutex);
- init_completion(&drv->lcp.msg_received);
+ mutex_init(&dev->lcp.mutex);
+ init_completion(&dev->lcp.msg_received);
}
-void c67x00_ll_release(struct c67x00_drv *drv)
+void c67x00_ll_release(struct c67x00_device *dev)
{
}
diff --git a/drivers/usb/c67x00/c67x00-ll-hpi.h
b/drivers/usb/c67x00/c67x00-ll-hpi.h
index 3f84348..b3b8512 100644
--- a/drivers/usb/c67x00/c67x00-ll-hpi.h
+++ b/drivers/usb/c67x00/c67x00-ll-hpi.h
@@ -28,7 +28,7 @@
#include <linux/mutex.h>
struct c67x00_sie;
-struct c67x00_drv;
+struct c67x00_device;
struct lcp {
/* Internal use only */
@@ -46,22 +46,22 @@ struct lcp_int_data {
/* ------------------------------------------------------------------------- */
/* HPI */
-u16 c67x00_hpi_status(struct c67x00_drv *drv);
-void c67x00_ll_hpi_reg_init(struct c67x00_drv *drv);
+u16 c67x00_hpi_status(struct c67x00_device *dev);
+void c67x00_ll_hpi_reg_init(struct c67x00_device *dev);
void c67x00_ll_hpi_enable_sofeop(struct c67x00_sie *sie);
void c67x00_ll_hpi_disable_sofeop(struct c67x00_sie *sie);
/* --------------------------------------------------------------------------
*/
/* General functions */
-u16 c67x00_ll_get_siemsg(struct c67x00_drv *drv, int sie);
-void c67x00_ll_set_siemsg(struct c67x00_drv *drv, int sie, u16 val);
+u16 c67x00_ll_get_siemsg(struct c67x00_device *dev, int sie);
+void c67x00_ll_set_siemsg(struct c67x00_device *dev, int sie, u16 val);
u16 c67x00_ll_get_usb_ctl(struct c67x00_sie *sie);
/* ------------------------------------------------------------------------- */
/* Host specific functions */
-void c67x00_ll_set_husb_eot(struct c67x00_drv *drv, u16 value);
+void c67x00_ll_set_husb_eot(struct c67x00_device *dev, u16 value);
void c67x00_ll_husb_reset(struct c67x00_sie *sie, int port);
void c67x00_ll_husb_set_current_td(struct c67x00_sie *sie, u16 addr);
u16 c67x00_ll_husb_get_current_td(struct c67x00_sie *sie);
@@ -78,21 +78,21 @@ void c67x00_ll_susb_init(struct c67x00_sie *sie);
/* ------------------------------------------------------------------------- */
-void c67x00_write_mem_le16(struct c67x00_drv *drv, u16 addr,
+void c67x00_write_mem_le16(struct c67x00_device *dev, u16 addr,
int len, char *data);
-void c67x00_read_mem_le16(struct c67x00_drv *drv, u16 addr,
+void c67x00_read_mem_le16(struct c67x00_device *dev, u16 addr,
int len, char *data);
-u16 c67x00_comm_read_ctrl_reg(struct c67x00_drv *drv, u16 addr);
+u16 c67x00_comm_read_ctrl_reg(struct c67x00_device *dev, u16 addr);
-int c67x00_comm_exec_int(struct c67x00_drv *drv, u16 nr,
+int c67x00_comm_exec_int(struct c67x00_device *dev, u16 nr,
struct lcp_int_data *data);
/* Called by c67x00_irq to handle lcp interrupts */
-void c67x00_ll_irq(struct c67x00_drv *drv);
+void c67x00_ll_irq(struct c67x00_device *dev);
-void c67x00_ll_init(struct c67x00_drv *drv);
-void c67x00_ll_release(struct c67x00_drv *drv);
-int c67x00_ll_reset(struct c67x00_drv *drv);
+void c67x00_ll_init(struct c67x00_device *dev);
+void c67x00_ll_release(struct c67x00_device *dev);
+int c67x00_ll_reset(struct c67x00_device *dev);
#endif /* _USB_C67X00_LL_HPI_H */
diff --git a/drivers/usb/c67x00/c67x00-sched.c
b/drivers/usb/c67x00/c67x00-sched.c
index 3a870cf..d408f2f 100644
--- a/drivers/usb/c67x00/c67x00-sched.c
+++ b/drivers/usb/c67x00/c67x00-sched.c
@@ -858,18 +858,18 @@ static void send_td(struct c67x00_hcd *c67x00, struct
c67x00_td *td)
int len = td_length(td);
if (len && ((td->pid_ep & TD_PIDEPMASK_PID) != TD_PID_IN))
- c67x00_write_mem_le16(c67x00->sie->drv,
+ c67x00_write_mem_le16(c67x00->sie->dev,
td_ly_base_addr(td), len, td->data);
#ifdef DEBUG_PATTERN
else { /* write known patterns into memories */
memset(td->data, NON_RECEIVED_PATTERN, len);
- c67x00_write_mem_le16(c67x00->sie->drv,
+ c67x00_write_mem_le16(c67x00->sie->dev,
td_ly_base_addr(td), len, td->data);
memset(td->data, UNREAD_PATTERN, len);
}
#endif /* DEBUG_PATTERN */
- c67x00_write_mem_le16(c67x00->sie->drv,
+ c67x00_write_mem_le16(c67x00->sie->dev,
td->td_addr, CY_TD_SIZE, (char *)td);
}
@@ -878,11 +878,11 @@ static void send_td(struct c67x00_hcd *c67x00, struct
c67x00_td *td)
*/
static inline void parse_td(struct c67x00_hcd *c67x00, struct c67x00_td *td)
{
- c67x00_read_mem_le16(c67x00->sie->drv,
+ c67x00_read_mem_le16(c67x00->sie->dev,
td->td_addr, CY_TD_SIZE, (char *)td);
if (usb_pipein(td->pipe) && td_actual_bytes(td))
- c67x00_read_mem_le16(c67x00->sie->drv, td_ly_base_addr(td),
+ c67x00_read_mem_le16(c67x00->sie->dev, td_ly_base_addr(td),
td_actual_bytes(td), td->data);
}
--
1.4.4.2
-------------------------------------------------------------------------
This SF.net email is sponsored by DB2 Express
Download DB2 Express C - the FREE version of DB2 express and take
control of your XML. No limits. Just data. Click to get it now.
http://sourceforge.net/powerbar/db2/
_______________________________________________
linux-usb-devel@lists.sourceforge.net
To unsubscribe, use the last form field at:
https://lists.sourceforge.net/lists/listinfo/linux-usb-devel
