linux SPI驱动——spidev之driver（六）

{

intstatus;

/*Claimour256reserveddevicenumbers.Thenregisteraclass

*thatwillkeyudev/mdevtoadd/remove/devnodes.Last,register

*thedriverwhichmanagesthosedevicenumbers.

*/

BUILD_BUG_ON(N_SPI_MINORS>256);

/*注册spi字符设备*/

status=register_chrdev(SPIDEV_MAJOR,"spi",&spidev_fops);

if(status<0){

returnstatus;

}

/*为该设备创建一个classspidev*/

spidev_class=class_create(THIS_MODULE,"spidev");

if(IS_ERR(spidev_class)){

unregister_chrdev(SPIDEV_MAJOR,spidev_spi_driver.driver.name);

returnPTR_ERR(spidev_class);

}

/*register匹配到device,最终调用prob函数*/

status=spi_register_driver(&spidev_spi_driver);

if(status<0){

class_destroy(spidev_class);

unregister_chrdev(SPIDEV_MAJOR,spidev_spi_driver.driver.name);

}

returnstatus;

}

module_init(spidev_init);

staticvoid__exitspidev_exit(void)

{

spi_unregister_driver(&spidev_spi_driver);

class_destroy(spidev_class);

unregister_chrdev(SPIDEV_MAJOR,spidev_spi_driver.driver.name);

}

module_exit(spidev_exit);

MODULE_AUTHOR("AndreaPaterniani,<a.paterniani@swapp-eng.it>");

MODULE_DESCRIPTION("UsermodeSPIdeviceinterface");

MODULE_LICENSE("GPL");

MODULE_ALIAS("spi:spidev");

staticint__devinitspidev_probe(structspi_device*spi)

structspidev_data*spidev;

intstatus;

unsignedlongminor;

/*Allocatedriverdata*/

spidev=kzalloc(sizeof(*spidev),GFP_KERNEL);

if(!spidev)

return-ENOMEM;

/*Initializethedriverdata*/

spidev->spi=spi;

spin_lock_init(&spidev->spi_lock);

mutex_init(&spidev->buf_lock);

INIT_LIST_HEAD(&spidev->device_entry);

/*Ifwecanallocateaminornumber,hookupthisdevice.

*Reusingminorsisfinesolongasudevormdevisworking.

*/

mutex_lock(&device_list_lock);

minor=find_first_zero_bit(minors,N_SPI_MINORS);

if(minor<N_SPI_MINORS){

structdevice*dev;

spidev->devt=MKDEV(SPIDEV_MAJOR,minor);

dev=device_create(spidev_class,&spi->dev,spidev->devt,

spidev,"spidev%d.%d",

spi->master->bus_num,spi->chip_select);

status=IS_ERR(dev)?PTR_ERR(dev):0;

}else{

dev_dbg(&spi->dev,"nominornumberavailable!\n");

status=-ENODEV;

}

if(status==0){

set_bit(minor,minors);

list_add(&spidev->device_entry,&device_list);

}

mutex_unlock(&device_list_lock);

if(status==0)

spi_set_drvdata(spi,spidev);

else

kfree(spidev);

returnstatus;

}

intspi_register_driver(structspi_driver*sdrv)

sdrv->driver.bus=&spi_bus_type;

if(sdrv->probe)

sdrv->driver.probe=spi_drv_probe;

if(sdrv->remove)

sdrv->driver.remove=spi_drv_remove;

if(sdrv->shutdown)

sdrv->driver.shutdown=spi_drv_shutdown;

returndriver_register(&sdrv->driver);

}

staticintspi_drv_probe(structdevice*dev)

conststructspi_driver*sdrv=to_spi_driver(dev->driver);

returnsdrv->probe(to_spi_device(dev));

}

{

intret;

structdevice_driver*other;

BUG_ON(!drv->bus->p);

if((drv->bus->probe&&drv->probe)||

(drv->bus->remove&&drv->remove)||

(drv->bus->shutdown&&drv->shutdown))

printk(KERN_WARNING"Driver'%s'needsupdating-pleaseuse"

"bus_typemethods\n",drv->name);

other=driver_find(drv->name,drv->bus);

if(other){

put_driver(other);

printk(KERN_ERR"Error:Driver'%s'isalreadyregistered,"

"aborting...\n",drv->name);

return-EBUSY;

}

ret=bus_add_driver(drv);

if(ret)

returnret;

ret=driver_add_groups(drv,drv->groups);

if(ret)

bus_remove_driver(drv);

returnret;

}

{

returnbus_for_each_dev(drv->bus,NULL,drv,__driver_attach);

}

intbus_for_each_dev(structbus_type*bus,structdevice*start,

{

structklist_iteri;

structdevice*dev;

interror=0;

if(!bus)

return-EINVAL;

klist_iter_init_node(&bus->p->klist_devices,&i,

(start?&start->p->knode_bus:NULL));

while((dev=next_device(&i))&&!error)

error=fn(dev,data);

klist_iter_exit(&i);

returnerror;

}

staticint__driver_attach(structdevice*dev,void*data)

structdevice_driver*drv=data;

if(!driver_match_device(drv,dev))

return0;

if(dev->parent)/*NeededforUSB*/

device_lock(dev->parent);

device_lock(dev);

if(!dev->driver)

driver_probe_device(drv,dev);

device_unlock(dev);

if(dev->parent)

device_unlock(dev->parent);

return0;

}

{

intret=0;

if(!device_is_registered(dev))

return-ENODEV;

pr_debug("bus:'%s':%s:matcheddevice%swithdriver%s\n",

drv->bus->name,__func__,dev_name(dev),drv->name);

pm_runtime_get_noresume(dev);

pm_runtime_barrier(dev);

pm_runtime_put_sync(dev);

returnret;

}