AuxXxilium/linux_dsm_epyc7002
1
0
Fork 0
mirror of https://github.com/AuxXxilium/linux_dsm_epyc7002.git synced 2024-12-27 11:35:07 +07:00
Code Issues Actions Packages Projects Releases Wiki Activity
0ef1905ecf
linux_dsm_epyc7002/drivers/usb/phy/phy-isp1301.c
Suzuki K Poulose 418e3ea157 bus_find_device: Unify the match callback with class_find_device 
There is an arbitrary difference between the prototypes of
bus_find_device() and class_find_device() preventing their callers
from passing the same pair of data and match() arguments to both of
them, which is the const qualifier used in the prototype of
class_find_device().  If that qualifier is also used in the
bus_find_device() prototype, it will be possible to pass the same
match() callback function to both bus_find_device() and
class_find_device(), which will allow some optimizations to be made in
order to avoid code duplication going forward.  Also with that, constify
the "data" parameter as it is passed as a const to the match function.

For this reason, change the prototype of bus_find_device() to match
the prototype of class_find_device() and adjust its callers to use the
const qualifier in accordance with the new prototype of it.

Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Andrew Lunn <andrew@lunn.ch>
Cc: Andreas Noever <andreas.noever@gmail.com>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Bjorn Helgaas <bhelgaas@google.com>
Cc: Corey Minyard <minyard@acm.org>
Cc: Christian Borntraeger <borntraeger@de.ibm.com>
Cc: David Kershner <david.kershner@unisys.com>
Cc: "David S. Miller" <davem@davemloft.net>
Cc: David Airlie <airlied@linux.ie>
Cc: Felipe Balbi <balbi@kernel.org>
Cc: Frank Rowand <frowand.list@gmail.com>
Cc: Grygorii Strashko <grygorii.strashko@ti.com>
Cc: Harald Freudenberger <freude@linux.ibm.com>
Cc: Hartmut Knaack <knaack.h@gmx.de>
Cc: Heiko Stuebner <heiko@sntech.de>
Cc: Jason Gunthorpe <jgg@ziepe.ca>
Cc: Jonathan Cameron <jic23@kernel.org>
Cc: "James E.J. Bottomley" <jejb@linux.ibm.com>
Cc: Len Brown <lenb@kernel.org>
Cc: Mark Brown <broonie@kernel.org>
Cc: Michael Ellerman <mpe@ellerman.id.au>
Cc: Michael Jamet <michael.jamet@intel.com>
Cc: "Martin K. Petersen" <martin.petersen@oracle.com>
Cc: Peter Oberparleiter <oberpar@linux.ibm.com>
Cc: Sebastian Ott <sebott@linux.ibm.com>
Cc: Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
Cc: Yehezkel Bernat <YehezkelShB@gmail.com>
Cc: rafael@kernel.org
Acked-by: Corey Minyard <minyard@acm.org>
Acked-by: David Kershner <david.kershner@unisys.com>
Acked-by: Mark Brown <broonie@kernel.org>
Acked-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
Acked-by: Wolfram Sang <wsa@the-dreams.de> # for the I2C parts
Acked-by: Rob Herring <robh@kernel.org>
Signed-off-by: Suzuki K Poulose <suzuki.poulose@arm.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2019-06-24 05:22:31 +02:00

169 lines
4.0 KiB
C
Raw Blame History

// SPDX-License-Identifier: GPL-2.0
/*
* NXP ISP1301 USB transceiver driver
*
* Copyright (C) 2012 Roland Stigge
*
* Author: Roland Stigge <stigge@antcom.de>
*/
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/i2c.h>
#include <linux/usb/phy.h>
#include <linux/usb/isp1301.h>
#define DRV_NAME "isp1301"
struct isp1301 {
struct usb_phy phy;
struct mutex mutex;
struct i2c_client *client;
};
#define phy_to_isp(p) (container_of((p), struct isp1301, phy))
static const struct i2c_device_id isp1301_id[] = {
{ "isp1301", 0 },
{ }
};
MODULE_DEVICE_TABLE(i2c, isp1301_id);
static const struct of_device_id isp1301_of_match[] = {
{.compatible = "nxp,isp1301" },
{ },
};
MODULE_DEVICE_TABLE(of, isp1301_of_match);
static struct i2c_client *isp1301_i2c_client;
static int __isp1301_write(struct isp1301 *isp, u8 reg, u8 value, u8 clear)
{
return i2c_smbus_write_byte_data(isp->client, reg | clear, value);
}
static int isp1301_write(struct isp1301 *isp, u8 reg, u8 value)
{
return __isp1301_write(isp, reg, value, 0);
}
static int isp1301_clear(struct isp1301 *isp, u8 reg, u8 value)
{
return __isp1301_write(isp, reg, value, ISP1301_I2C_REG_CLEAR_ADDR);
}
static int isp1301_phy_init(struct usb_phy *phy)
{
struct isp1301 *isp = phy_to_isp(phy);
/* Disable transparent UART mode first */
isp1301_clear(isp, ISP1301_I2C_MODE_CONTROL_1, MC1_UART_EN);
isp1301_clear(isp, ISP1301_I2C_MODE_CONTROL_1, ~MC1_SPEED_REG);
isp1301_write(isp, ISP1301_I2C_MODE_CONTROL_1, MC1_SPEED_REG);
isp1301_clear(isp, ISP1301_I2C_MODE_CONTROL_2, ~0);
isp1301_write(isp, ISP1301_I2C_MODE_CONTROL_2, (MC2_BI_DI | MC2_PSW_EN
| MC2_SPD_SUSP_CTRL));
isp1301_clear(isp, ISP1301_I2C_OTG_CONTROL_1, ~0);
isp1301_write(isp, ISP1301_I2C_MODE_CONTROL_1, MC1_DAT_SE0);
isp1301_write(isp, ISP1301_I2C_OTG_CONTROL_1, (OTG1_DM_PULLDOWN
| OTG1_DP_PULLDOWN));
isp1301_clear(isp, ISP1301_I2C_OTG_CONTROL_1, (OTG1_DM_PULLUP
| OTG1_DP_PULLUP));
/* mask all interrupts */
isp1301_clear(isp, ISP1301_I2C_INTERRUPT_LATCH, ~0);
isp1301_clear(isp, ISP1301_I2C_INTERRUPT_FALLING, ~0);
isp1301_clear(isp, ISP1301_I2C_INTERRUPT_RISING, ~0);
return 0;
}
static int isp1301_phy_set_vbus(struct usb_phy *phy, int on)
{
struct isp1301 *isp = phy_to_isp(phy);
if (on)
isp1301_write(isp, ISP1301_I2C_OTG_CONTROL_1, OTG1_VBUS_DRV);
else
isp1301_clear(isp, ISP1301_I2C_OTG_CONTROL_1, OTG1_VBUS_DRV);
return 0;
}
static int isp1301_probe(struct i2c_client *client,
const struct i2c_device_id *i2c_id)
{
struct isp1301 *isp;
struct usb_phy *phy;
isp = devm_kzalloc(&client->dev, sizeof(*isp), GFP_KERNEL);
if (!isp)
return -ENOMEM;
isp->client = client;
mutex_init(&isp->mutex);
phy = &isp->phy;
phy->dev = &client->dev;
phy->label = DRV_NAME;
phy->init = isp1301_phy_init;
phy->set_vbus = isp1301_phy_set_vbus;
phy->type = USB_PHY_TYPE_USB2;
i2c_set_clientdata(client, isp);
usb_add_phy_dev(phy);
isp1301_i2c_client = client;
return 0;
}
static int isp1301_remove(struct i2c_client *client)
{
struct isp1301 *isp = i2c_get_clientdata(client);
usb_remove_phy(&isp->phy);
isp1301_i2c_client = NULL;
return 0;
}
static struct i2c_driver isp1301_driver = {
.driver = {
.name = DRV_NAME,
.of_match_table = isp1301_of_match,
},
.probe = isp1301_probe,
.remove = isp1301_remove,
.id_table = isp1301_id,
};
module_i2c_driver(isp1301_driver);
static int match(struct device *dev, const void *data)
{
const struct device_node *node = (const struct device_node *)data;
return (dev->of_node == node) &&
(dev->driver == &isp1301_driver.driver);
}
struct i2c_client *isp1301_get_client(struct device_node *node)
{
if (node) { /* reference of ISP1301 I2C node via DT */
struct device *dev = bus_find_device(&i2c_bus_type, NULL,
node, match);
if (!dev)
return NULL;
return to_i2c_client(dev);
} else { /* non-DT: only one ISP1301 chip supported */
return isp1301_i2c_client;
}
}
EXPORT_SYMBOL_GPL(isp1301_get_client);
MODULE_AUTHOR("Roland Stigge <stigge@antcom.de>");
MODULE_DESCRIPTION("NXP ISP1301 USB transceiver driver");
MODULE_LICENSE("GPL");
Reference in New Issue View Git Blame Copy Permalink