hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Staging: hv: Use the probe function in struct hv_driver 

Use the newly introduced probe function.

Signed-off-by: K. Y. Srinivasan <kys@microsoft.com>
Signed-off-by: Haiyang Zhang <haiyangz@microsoft.com>
Signed-off-by: Abhishek Kane <v-abkane@microsoft.com>
Signed-off-by: Hank Janssen <hjanssen@microsoft.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
This commit is contained in:
K. Y. Srinivasan 2011-04-29 13:45:10 -07:00 committed by Greg Kroah-Hartman
parent db1c19691c
commit 9efd21e1f5
5 changed files with 37 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
drivers/staging/hv/blkvsc_drv.c
View File

@ -140,7 +140,7 @@ MODULE_PARM_DESC(ring_size, "Ring buffer size (in bytes)");
* There is a circular dependency involving blkvsc_probe()
* and block_ops.
*/
static int blkvsc_probe(struct device *dev);
static int blkvsc_probe(struct hv_device *dev);
static int blk_vsc_on_device_add(struct hv_device *device,
void *additional_info)
@ -882,7 +882,7 @@ static int blkvsc_drv_init(void)
drv->driver.name = storvsc_drv_obj->base.name;
drv->driver.probe = blkvsc_probe;
drv->probe = blkvsc_probe;
drv->driver.remove = blkvsc_remove;
drv->driver.shutdown = blkvsc_shutdown;
@ -937,11 +937,10 @@ static void blkvsc_drv_exit(void)
/*
* blkvsc_probe - Add a new device for this driver
*/
static int blkvsc_probe(struct device *device)
static int blkvsc_probe(struct hv_device *dev)
{
struct storvsc_driver_object *storvsc_drv_obj =
drv_to_stordrv(device->driver);
struct hv_device *device_obj = device_to_hv_device(device);
drv_to_stordrv(dev->device.driver);
struct block_device_context *blkdev = NULL;
struct storvsc_device_info device_info;
@ -961,7 +960,7 @@ static int blkvsc_probe(struct device *device)
spin_lock_init(&blkdev->lock);
blkdev->request_pool = kmem_cache_create(dev_name(&device_obj->device),
blkdev->request_pool = kmem_cache_create(dev_name(&dev->device),
sizeof(struct blkvsc_request), 0,
SLAB_HWCACHE_ALIGN, NULL);
if (!blkdev->request_pool) {
@ -971,17 +970,17 @@ static int blkvsc_probe(struct device *device)
/* Call to the vsc driver to add the device */
ret = storvsc_drv_obj->base.dev_add(device_obj, &device_info);
ret = storvsc_drv_obj->base.dev_add(dev, &device_info);
if (ret != 0)
goto cleanup;
blkdev->device_ctx = device_obj;
blkdev->device_ctx = dev;
/* this identified the device 0 or 1 */
blkdev->target = device_info.target_id;
/* this identified the ide ctrl 0 or 1 */
blkdev->path = device_info.path_id;
dev_set_drvdata(device, blkdev);
dev_set_drvdata(&dev->device, blkdev);
ret = stor_vsc_get_major_info(&device_info, &major_info);
@ -1041,7 +1040,7 @@ static int blkvsc_probe(struct device *device)
return ret;
remove:
storvsc_drv_obj->base.dev_rm(device_obj);
storvsc_drv_obj->base.dev_rm(dev);
cleanup:
if (blkdev) {

11
drivers/staging/hv/hv_mouse.c
View File

@ -832,23 +832,22 @@ static void mousevsc_hid_close(struct hid_device *hid)
{
}
static int mousevsc_probe(struct device *device)
static int mousevsc_probe(struct hv_device *dev)
{
int ret = 0;
struct mousevsc_drv_obj *mousevsc_drv_obj =
drv_to_mousedrv(device->driver);
drv_to_mousedrv(dev->device.driver);
struct hv_device *device_obj = device_to_hv_device(device);
struct input_device_context *input_dev_ctx;
input_dev_ctx = kmalloc(sizeof(struct input_device_context),
GFP_KERNEL);
dev_set_drvdata(device, input_dev_ctx);
dev_set_drvdata(&dev->device, input_dev_ctx);
/* Call to the vsc driver to add the device */
ret = mousevsc_drv_obj->base.dev_add(device_obj, NULL);
ret = mousevsc_drv_obj->base.dev_add(dev, NULL);
if (ret != 0) {
DPRINT_ERR(INPUTVSC_DRV, "unable to add input vsc device");
@ -1023,7 +1022,7 @@ static int __init mousevsc_init(void)
drv->driver.name = input_drv_obj->base.name;
drv->driver.probe = mousevsc_probe;
drv->probe = mousevsc_probe;
drv->driver.remove = mousevsc_remove;
/* The driver belongs to vmbus */

19
drivers/staging/hv/netvsc_drv.c
View File

@ -340,11 +340,10 @@ static void netvsc_send_garp(struct work_struct *w)
}
static int netvsc_probe(struct device *device)
static int netvsc_probe(struct hv_device *dev)
{
struct netvsc_driver *net_drv_obj =
drv_to_netvscdrv(device->driver);
struct hv_device *device_obj = device_to_hv_device(device);
drv_to_netvscdrv(dev->device.driver);
struct net_device *net = NULL;
struct net_device_context *net_device_ctx;
struct netvsc_device_info device_info;
@ -361,16 +360,16 @@ static int netvsc_probe(struct device *device)
netif_carrier_off(net);
net_device_ctx = netdev_priv(net);
net_device_ctx->device_ctx = device_obj;
net_device_ctx->device_ctx = dev;
net_device_ctx->avail = ring_size;
dev_set_drvdata(device, net);
dev_set_drvdata(&dev->device, net);
INIT_WORK(&net_device_ctx->work, netvsc_send_garp);
/* Notify the netvsc driver of the new device */
ret = net_drv_obj->base.dev_add(device_obj, &device_info);
ret = net_drv_obj->base.dev_add(dev, &device_info);
if (ret != 0) {
free_netdev(net);
dev_set_drvdata(device, NULL);
dev_set_drvdata(&dev->device, NULL);
netdev_err(net, "unable to add netvsc device (ret %d)\n", ret);
return ret;
@ -397,12 +396,12 @@ static int netvsc_probe(struct device *device)
net->features = NETIF_F_SG;
SET_ETHTOOL_OPS(net, &ethtool_ops);
SET_NETDEV_DEV(net, device);
SET_NETDEV_DEV(net, &dev->device);
ret = register_netdev(net);
if (ret != 0) {
/* Remove the device and release the resource */
net_drv_obj->base.dev_rm(device_obj);
net_drv_obj->base.dev_rm(dev);
free_netdev(net);
}
@ -501,7 +500,7 @@ static int netvsc_drv_init(int (*drv_init)(struct hv_driver *drv))
drv->driver.name = net_drv_obj->base.name;
drv->driver.probe = netvsc_probe;
drv->probe = netvsc_probe;
drv->driver.remove = netvsc_remove;
/* The driver belongs to vmbus */

23
drivers/staging/hv/storvsc_drv.c
View File

@ -123,7 +123,7 @@ static int stor_vsc_initialize(struct hv_driver *driver)
}
/* Static decl */
static int storvsc_probe(struct device *dev);
static int storvsc_probe(struct hv_device *dev);
static int storvsc_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scmnd);
static int storvsc_device_alloc(struct scsi_device *);
static int storvsc_device_configure(struct scsi_device *);
@ -213,7 +213,7 @@ static int storvsc_drv_init(void)
drv->driver.name = storvsc_drv_obj->base.name;
drv->driver.probe = storvsc_probe;
drv->probe = storvsc_probe;
drv->driver.remove = storvsc_remove;
/* The driver belongs to vmbus */
@ -320,12 +320,11 @@ static void storvsc_drv_exit(void)
/*
* storvsc_probe - Add a new device for this driver
*/
static int storvsc_probe(struct device *device)
static int storvsc_probe(struct hv_device *device)
{
int ret;
struct storvsc_driver_object *storvsc_drv_obj =
drv_to_stordrv(device->driver);
struct hv_device *device_obj = device_to_hv_device(device);
drv_to_stordrv(device->device.driver);
struct Scsi_Host *host;
struct host_device_context *host_device_ctx;
struct storvsc_device_info device_info;
@ -340,16 +339,16 @@ static int storvsc_probe(struct device *device)
return -ENOMEM;
}
dev_set_drvdata(device, host);
dev_set_drvdata(&device->device, host);
host_device_ctx = (struct host_device_context *)host->hostdata;
memset(host_device_ctx, 0, sizeof(struct host_device_context));
host_device_ctx->port = host->host_no;
host_device_ctx->device_ctx = device_obj;
host_device_ctx->device_ctx = device;
host_device_ctx->request_pool =
kmem_cache_create(dev_name(&device_obj->device),
kmem_cache_create(dev_name(&device->device),
sizeof(struct storvsc_cmd_request), 0,
SLAB_HWCACHE_ALIGN, NULL);
@ -360,8 +359,8 @@ static int storvsc_probe(struct device *device)
device_info.port_number = host->host_no;
/* Call to the vsc driver to add the device */
ret = storvsc_drv_obj->base.dev_add(device_obj,
(void *)&device_info);
ret = storvsc_drv_obj->base.dev_add(device, (void *)&device_info);
if (ret != 0) {
DPRINT_ERR(STORVSC_DRV, "unable to add scsi vsc device");
kmem_cache_destroy(host_device_ctx->request_pool);
@ -381,11 +380,11 @@ static int storvsc_probe(struct device *device)
host->max_channel = STORVSC_MAX_CHANNELS - 1;
/* Register the HBA and start the scsi bus scan */
ret = scsi_add_host(host, device);
ret = scsi_add_host(host, &device->device);
if (ret != 0) {
DPRINT_ERR(STORVSC_DRV, "unable to add scsi host device");
storvsc_drv_obj->base.dev_rm(device_obj);
storvsc_drv_obj->base.dev_rm(device);
kmem_cache_destroy(host_device_ctx->request_pool);
scsi_host_put(host);

6
drivers/staging/hv/vmbus_drv.c
View File

@ -319,10 +319,10 @@ static int vmbus_probe(struct device *child_device)
int ret = 0;
struct hv_driver *drv =
drv_to_hv_drv(child_device->driver);
struct hv_device *dev = device_to_hv_device(child_device);
/* Let the specific open-source driver handles the probe if it can */
if (drv->driver.probe) {
ret = drv->driver.probe(child_device);
if (drv->probe) {
ret = drv->probe(dev);
if (ret != 0)
pr_err("probe failed for device %s (%d)\n",
dev_name(child_device), ret);