static fm_s32 fm_cdev_setup(struct fm *fm)
{
fm_s32 ret = 0;
struct fm_platform *plat = &fm->platform;
#ifdef FM_DEV_STATIC_ALLOC
/*static allocate chrdev*/
plat->dev_t = MKDEV(FM_major, 0);
ret = register_chrdev_region(plat->dev_t, 1, FM_NAME);
if (ret) {
WCN_DBG(FM_ERR | MAIN, "%s():fail to register chrdev\n", __func__);
return ret;
}
#endif
#ifndef FM_DEV_STATIC_ALLOC
ret = alloc_chrdev_region(&plat->dev_t, 0, 1, FM_NAME);
if (ret) {
WCN_DBG(FM_ALT | MAIN, "alloc dev_t failed\n");
return ret;
}
#endif
WCN_DBG(FM_NTC | MAIN, "alloc %s:%d:%d\n", FM_NAME, MAJOR(plat->dev_t), MINOR(plat->dev_t));
cdev_init(&plat->cdev, &fm_ops);
plat->cdev.owner = THIS_MODULE;
plat->cdev.ops = &fm_ops;
ret = cdev_add(&plat->cdev, plat->dev_t, 1);
if (ret) {
WCN_DBG(FM_ALT | MAIN, "add dev_t failed\n");
return ret;
}
//#ifndef FM_DEV_STATIC_ALLOC
plat->cls = class_create(THIS_MODULE, FM_NAME);
if (IS_ERR(plat->cls)) {
ret = PTR_ERR(plat->cls);
WCN_DBG(FM_ALT | MAIN, "class_create err:%d\n", ret);
return ret;
}
plat->dev = device_create(plat->cls, NULL, plat->dev_t, NULL, FM_NAME);
//#endif
return ret;
}
static int BT_init(void)
{
dev_t dev = MKDEV(BT_major, 0);
int alloc_ret = 0;
int cdev_err = 0;
/*static allocate chrdev*/
alloc_ret = register_chrdev_region(dev, 1, BT_DRIVER_NAME);
if (alloc_ret) {
BT_ERR_FUNC("fail to register chrdev\n");
return alloc_ret;
}
cdev_init(&BT_cdev, &BT_fops);
BT_cdev.owner = THIS_MODULE;
cdev_err = cdev_add(&BT_cdev, dev, BT_devs);
if (cdev_err)
goto error;
BT_INFO_FUNC("%s driver(major %d) installed.\n", BT_DRIVER_NAME, BT_major);
#if WMT_CREATE_NODE_DYNAMIC
bt_class = class_create(THIS_MODULE,"stpbt");
if(IS_ERR(bt_class))
goto error;
bt_dev = device_create(bt_class,NULL,dev,NULL,"stpbt");
if(IS_ERR(bt_dev))
goto error;
#endif
retflag = 0;
mtk_wcn_stp_register_event_cb(BT_TASK_INDX, NULL);
/* init wait queue */
init_waitqueue_head(&(inq));
return 0;
error:
#if WMT_CREATE_NODE_DYNAMIC
if(!(IS_ERR(bt_dev)))
device_destroy(bt_class,dev);
if(!(IS_ERR(bt_class)))
{
class_destroy(bt_class);
bt_class = NULL;
}
#endif
if (cdev_err == 0)
cdev_del(&BT_cdev);
if (alloc_ret == 0)
unregister_chrdev_region(dev, BT_devs);
return -1;
}
static int __init bootkey_init(void)
{
// Setup devno and lasterr
devno = MKDEV(BOOTKEY_MAJOR, BOOTKEY_MINOR);
int lasterr = 0;
printk(KERN_ALERT "BOOT_KEY interrupt module inserted.\n");
// Requesting GPIO
lasterr = gpio_request(BOOT_GPIO, "bootkey");
if (lasterr < 0)
{
printk(KERN_ALERT "Error requesting gpio: %d for GPIO %d\n", lasterr, BOOT_GPIO);
goto err_exit;
}
// GPIO direction
lasterr = gpio_direction_input(BOOT_GPIO);
if (lasterr < 0)
{
printk(KERN_ALERT "Error changing gpio direction: %d for GPIO %d\n", lasterr, BOOT_GPIO);
goto err_gpiofree;
}
// Registering char device number regions (static)
lasterr = register_chrdev_region(devno, BOOTKEY_NO, "bootkey");
if (lasterr < 0)
{
printk(KERN_ALERT "Error registering char device: %d\n", lasterr);
goto err_gpiofree;
}
// Init char device
cdevStruct = cdev_alloc();
cdev_init(cdevStruct, &bootkey_fops);
// Add char device
lasterr = cdev_add(cdevStruct, devno, BOOTKEY_NO);
if (lasterr < 0)
{
printk(KERN_ALERT "Error adding char device: %d\n", lasterr);
goto err_unregister_chrdev;
}
// All succesful
return 0;
// Proper cleanup
err_unregister_chrdev:
unregister_chrdev_region(devno, BOOTKEY_NO);
err_gpiofree:
gpio_free(BOOT_GPIO);
err_exit:
return lasterr;
}
static int rmidev_init_device(struct rmidev_data *data)
{
dev_t dev_no;
int retval;
struct device *device_ptr;
if (rmidev_major_num) {
dev_no = MKDEV(rmidev_major_num, 0);
retval = register_chrdev_region(dev_no, 1, CHAR_DEVICE_NAME);
} else {
retval = alloc_chrdev_region(&dev_no, 0, 1, CHAR_DEVICE_NAME);
/* let kernel allocate a major for us */
rmidev_major_num = MAJOR(dev_no);
dev_info(&data->pdev->dev, "Major number of rmidev: %d\n",
rmidev_major_num);
}
if (retval < 0) {
dev_err(&data->pdev->dev,
"Failed to register or allocate char dev, code %d.\n",
retval);
goto exit;
} else {
dev_info(&data->pdev->dev, "Allocated rmidev %d %d.\n",
MAJOR(dev_no), MINOR(dev_no));
}
mutex_init(&data->file_mutex);
cdev_init(&data->main_dev, &rmidev_fops);
retval = cdev_add(&data->main_dev, dev_no, 1);
if (retval) {
dev_err(&data->pdev->dev, "Error %d adding rmi_char_dev.\n",
retval);
rmidev_device_cleanup(data);
goto exit;
}
dev_set_name(&data->pdev->dev, "rmidev%d", MINOR(dev_no));
data->device_class = rmidev_device_class;
device_ptr = device_create(
data->device_class,
NULL, dev_no, NULL,
CHAR_DEVICE_NAME"%d",
MINOR(dev_no));
if (IS_ERR(device_ptr)) {
dev_err(&data->pdev->dev,
"Failed to create rmi device.\n");
rmidev_device_cleanup(data);
retval = -ENODEV;
}
exit:
return retval;
}
static int __init l2_drv_init(void)
{
int result;
dev_t dev = MKDEV(l2_drv_major, 0);
/*
* Register your major, and accept a dynamic number.
*/
if (l2_drv_major)
{
result = register_chrdev_region(dev, l2_drv_devs, "l2_drv");
}
else
{
result = alloc_chrdev_region(&dev, 0, l2_drv_devs, "l2_drv");
l2_drv_major = MAJOR(dev);
}
if (result < 0)
{
L2_DBG(KERN_ERR, "get chrdev_region fail l2_drv_major %d result %d\r\n", l2_drv_major, result);
return result;
}
/*
* allocate the devices -- we can't have them static, as the number
* can be specified at load time
*/
memset(&l2_drv_dev_data, 0, sizeof (l2_drv_dev_data));
sema_init(&l2_drv_dev_data.sem,1);
l2_drv_setup_cdev(&l2_drv_dev_data, 0);
l2_drv_devclass = class_create(THIS_MODULE, L2_DEV_NAME);
device_create(l2_drv_devclass, NULL, dev, NULL, L2_DEV_NAME);
// class_device_create(l2_drv_devclass, NULL, dev, NULL, L2_DEV_NAME);
L2_DBG(KERN_NOTICE, L2_DEV_NAME " Init Done\r\n");
igs_drv_init();
// L2_bl2k_drv_init();
//l2_drv_evt_init();
// l2_drv_evtDev_BufInit();
l2_drv_dbg_sysfs_init();
//BGM_init_mv_pack();
//extern void kerpthread_test();
// kerpthread_test();
return 0; /* succeed */
}
int scull_init_module(void)
{
int result, i;
dev_t dev = 0;
/*
* Get a range of minor numbers to work with, asking for a dynamic
* major unless directed otherwise at load time.
*/
if (scull_major) {
dev = MKDEV(scull_major, scull_minor);
result = register_chrdev_region(dev, scull_nr_devs, "scull");
} else {
result = alloc_chrdev_region(&dev, scull_minor, scull_nr_devs,
"scull");
scull_major = MAJOR(dev);
}
if (result < 0) {
printk(KERN_WARNING "scull: can't get major %d\n", scull_major);
return result;
}
/*
* allocate the devices -- we can't have them static, as the number
* can be specified at load time
*/
scull_devices = kmalloc(scull_nr_devs * sizeof(struct scull_dev), GFP_KERNEL);
if (!scull_devices) {
result = -ENOMEM;
goto fail; /* Make this more graceful */
}
memset(scull_devices, 0, scull_nr_devs * sizeof(struct scull_dev));
/* Initialize each device. */
for (i = 0; i < scull_nr_devs; i++) {
scull_devices[i].quantum = scull_quantum;
scull_devices[i].qset = scull_qset;
init_MUTEX(&scull_devices[i].sem);
scull_setup_cdev(&scull_devices[i], i);
}
/* At this point call the init function for any friend device */
dev = MKDEV(scull_major, scull_minor + scull_nr_devs);
dev += scull_p_init(dev);
#ifdef SCULL_DEBUG /* only when debugging */
scull_create_proc();
#endif
return 0; /* succeed */
fail:
scull_cleanup_module();
return result;
}
int hello_probe(struct platform_device *pdev)
{
int ret;
//platform_get_resource(struct platform_device *dev,unsigned int type,unsigned int num);
// 描述设备的结构体 资源的类型
struct resource *memres = platform_get_resource(pdev,IORESOURCE_MEM,0);//从pdev中获取第num个类型为type的资源，num默认从0开始
struct resource *irqres = platform_get_resource(pdev,IORESOURCE_IRQ,0);
if( memres==NULL || irqres == NULL)//判断资源是否合法
{
printk("get resource fail\n" );
return -ENOMEM;
}
clk = clk_get(NULL,"adc"); //获得时钟
clk_enable(clk);//使能时钟
adccon = ioremap(memres->start,memres->end - memres->start);//物理地址到虚拟地址的映射
if(adccon == NULL)
{
printk("ioremap fail\n");
return -ENOMEM;
}
ret = request_irq(irqres->start,adc_func,IRQF_DISABLED,"adc",NULL);//注册中断
if(0 != ret)
{
printk("request_irq fail\n");
return -ENOMEM;
}
init_waitqueue_head(&myread);//初始化读等待头队列
writel(0,ADC_MUTEX + adccon);//选择0通道
writel((1<<16 | 1<<14 |0xff<<6),adccon); //1<<16设置为12位精度 1<<14使能预分频 oxff<<6 预分频
devno = MKDEV(MAJOR,MINOR);//申请设备号
ret = register_chrdev_region(devno,1,"hello12");//注册设备号
if(0 != ret)
{
printk("register_chrdev_region error \n");
return -ENOMEM;
}
cdev_init(&cdev,&hello_file_operations);//初始化设备
ret = cdev_add(&cdev,devno,1);//注册设备
if(0 != ret)
{
printk("cdev_add error \n");
goto err1;
}
printk("hello_probe\n");
return 0;
err1:
unregister_chrdev_region(devno,1);//如注册设备不成功，卸载设备号
return 0;
}
static int __init my_init (void)
{
first = MKDEV (my_major, my_minor);
register_chrdev_region (first, count, MYDEV_NAME);
my_cdev = cdev_alloc ();
cdev_init (my_cdev, &mycdrv_fops);
cdev_add (my_cdev, first, count);
printk (KERN_INFO "\nSucceeded in registering character device %s\n",
MYDEV_NAME);
return 0;
}
static int __init my_init(void)
{
ramdisk = kmalloc(ramdisk_size, GFP_KERNEL);
first = MKDEV(my_major, my_minor);
register_chrdev_region(first, count, MYDEV_NAME);
my_cdev = cdev_alloc();
cdev_init(my_cdev, &mycdrv_fops);
cdev_add(my_cdev, first, count);
pr_info("\nSucceeded in registering character device %s\n", MYDEV_NAME);
return 0;
}
static int __init vuln_init(void)
{
ramdisk = kmalloc(MAX_RW,GFP_KERNEL);
first = MKDEV(vuln_major,vuln_minor);
register_chrdev_region(first,count,DEVNAME);
cdev = cdev_alloc();
cdev_init(cdev,&fps);
cdev_add(cdev,first,count);
printk(KERN_INFO"Registring device %s\n",DEVNAME);
return 0;
}
static int scull_init_module(void)
{
int res = 0;
dev_t dev;
int i;
#ifdef __DEBUG_INFO
printk(KERN_ALERT "In init!!!\n");
#endif
if(scull_major){
dev = MKDEV(scull_major, scull_minor);
res = register_chrdev_region(dev, scull_num, "gzhSCULL");
}else{
res = alloc_chrdev_region(&dev, scull_minor, scull_num, "gzhSCULL");
scull_major = MAJOR(dev);
}
if(res != 0 ){
printk(KERN_ALERT "In scull_init_module(), register dev error");
return res;
}
printk(KERN_ALERT "tht major is %d\n", scull_major);
scull_devices = kmalloc(scull_num * sizeof(struct scull_dev), GFP_KERNEL);
if(scull_devices == NULL){
printk(KERN_ALERT "scull_devices malloc error\n");
goto fail;
}
memset(scull_devices, 0, scull_num * sizeof(struct scull_dev));
for(i = 0; i < scull_num; i++)
{
scull_devices[i].quantum = scull_quantum;
scull_devices[i].qset = scull_qset;
sema_init(&scull_devices[i].sem, 1);
init_completion(&scull_devices[i].comp);
scull_setup_cdev(&(scull_devices[i]), i);
}
return 0;
fail:
{
printk(KERN_ALERT "In Failed\n");
scull_cleanup_module();
}
return 0;
}
static int __init hwconfig_init(void)
{
int result,err;
dev_t devno = MKDEV(hwconfig_major,0);
hwinfo_from_uboot();
printk(KERN_ALERT"HWCONFIG=%s\n",hw_config);
printk(KERN_ALERT"PLATFORM=%s\n",platform);
hwconfig = simple_strtoull(hw_config,NULL,16);
printk(KERN_ALERT"hwconfig=%lld\n",hwconfig);
if(hwconfig_major)
result = register_chrdev_region(devno,1,HWCONFIG_NAME);
else
{
result = alloc_chrdev_region(&devno,0,1,HWCONFIG_NAME);
hwconfig_major = MAJOR(devno);
}
if (result < 0)
return result;
hwconfig_devp = kmalloc(sizeof(struct hwconfig),GFP_KERNEL);
if(!hwconfig_devp)
{
result = - ENOMEM;
goto fail_malloc;
}
memset(hwconfig_devp,0,sizeof(struct hwconfig));
cdev_init(&hwconfig_devp->cdev,&hwconfig_fops);
err = cdev_add(&hwconfig_devp->cdev,devno,1);
if(err)
printk(KERN_NOTICE "Error cdev_add!\n");
return 0;
fail_malloc:
unregister_chrdev_region(devno,1);
return result;
}
static inline int RegisterCAM_CALCharDrv(void)
{
struct device *CAM_CAL_device = NULL;
#if CAM_CAL_DYNAMIC_ALLOCATE_DEVNO
if (alloc_chrdev_region(&g_CAM_CALdevno, 0, 1, CAM_CAL_DRVNAME)) {
CAM_CALDB("[CAM_CAL] Allocate device no failed\n");
return -EAGAIN;
}
#else
if (register_chrdev_region(g_CAM_CALdevno , 1 , CAM_CAL_DRVNAME)) {
CAM_CALDB("[CAM_CAL] Register device no failed\n");
return -EAGAIN;
}
#endif
/* Allocate driver */
g_pCAM_CAL_CharDrv = cdev_alloc();
if (NULL == g_pCAM_CAL_CharDrv) {
unregister_chrdev_region(g_CAM_CALdevno, 1);
CAM_CALDB("[CAM_CAL] Allocate mem for kobject failed\n");
return -ENOMEM;
}
/* Attatch file operation. */
cdev_init(g_pCAM_CAL_CharDrv, &g_stCAM_CAL_fops);
g_pCAM_CAL_CharDrv->owner = THIS_MODULE;
/* Add to system */
if (cdev_add(g_pCAM_CAL_CharDrv, g_CAM_CALdevno, 1)) {
CAM_CALDB("[CAM_CAL] Attatch file operation failed\n");
unregister_chrdev_region(g_CAM_CALdevno, 1);
return -EAGAIN;
}
CAM_CAL_class = class_create(THIS_MODULE, "CAM_CALdrv");
if (IS_ERR(CAM_CAL_class)) {
int ret = PTR_ERR(CAM_CAL_class);
CAM_CALDB("Unable to create class, err = %d\n", ret);
return ret;
}
CAM_CAL_device = device_create(CAM_CAL_class, NULL, g_CAM_CALdevno, NULL, CAM_CAL_DRVNAME);
return 0;
}
static int __init scull_init_module( void )
{
int ret, i;
dev_t devno = 0;
if ( scull_major )
{
devno = MKDEV( scull_major, scull_mino );
ret = register_chrdev_region( devno, 1, "scull" );
}else{
ret = alloc_chrdev_region( &devno, scull_mino, 1, "scull" );
scull_major = MAJOR( devno );
}
if ( ret < 0 )
{
printk( KERN_WARNING "scull: can't get major %d\n", scull_major );
return(ret);
}
scull_devices = kmalloc( sizeof(struct scull_dev) * scull_nr_dev, GFP_KERNEL );
if ( !scull_devices )
{
ret = -ENOMEM;
goto fail;
}
for ( i = 0; i < scull_nr_dev; i++ )
{
scull_devices[i].quantum = SCULL_QUANTUM;
scull_devices[i].qset = SCULL_QSET;
sema_init( &scull_devices[i].sem, 1 );
scull_setup_dev( &scull_devices[i], i );
}
PDEBUG( "device open\n" );
/*
* if(printk_ratelimit())
* PDEBUG("device open\n");
*/
/*
* print_dev_t(buffer, dev);
* format_dev_t(buffer, dev)
*/
#ifdef SCULL_DEBUG
scull_create_proc();
#endif
return(0);
fail:
scull_cleanup_module();
return(ret);
}
int devblast_init_module(void)
{
int result,i;
dev_t devblast_devno = 0; /* Our first device number */
initProcessInformationList();
sema_init(&sem, 1);
init_waitqueue_head(&queue_provider);
providerPid = -1;
flagSendToProvider = 0;
if (devblast_major) {
devblast_devno = MKDEV(devblast_major, devblast_minor);
result = register_chrdev_region(devblast_devno, devblast_nr_devices, "devblast");
} else {
result = alloc_chrdev_region(&devblast_devno, devblast_minor, devblast_nr_devices,
"devblast");
devblast_major = MAJOR(devblast_devno);
}
if (result < 0) {
printk(KERN_WARNING "devblast: can't get major %d\n", devblast_major);
return result;
}
/*
* allocate the devices -- we can't have them static, as the number
* can be specified at load time
*/
blast_devices = kmalloc(devblast_nr_devices * sizeof(struct devblast_dev), GFP_KERNEL);
if (!blast_devices) {
result = -ENOMEM;
goto fail; /* Make this more graceful */
}
memset(blast_devices, 0, devblast_nr_devices * sizeof(struct devblast_dev));
/* Initialize each device. */
for (i = 0; i < devblast_nr_devices; i++) {
devblast_setup_cdev(&blast_devices[i], i);
}
//SET_MODULE_OWNER(&devblast_fops);
//major = register_chrdev(0, "devblast", &devblast_fops);
//ERROR_TRACE1("Modulo devblast carregado com sucesso. Major Number=%d\n", major);
printk(KERN_NOTICE "Modulo devblast carregado com sucesso. Major Number=%d\n", devblast_major);
return 0;
fail:
devblast_cleanup_module();
return result;
}
static int startup(void)
{
dev_t dev = MKDEV(major, minor);
int result = 0;
memory = NULL;
printk(KERN_INFO "hello: startup\n");
if (! request_region(lpt_port, SHORT_NR_PORTS, "MY_LPT")) {
printk(KERN_INFO "hello: can't get I/O mem address 0x%lx\n", lpt_port);
return -ENODEV;
}
printk(KERN_WARNING "hello: request_region: port 0x%lx hooked\n", lpt_port);
// get a driver number
if (major) {
dev = MKDEV(major, minor);
result = register_chrdev_region(dev, 1, "hello");
} else {
result = alloc_chrdev_region(&dev, minor, 1, "hello");
major = MAJOR(dev);
}
if (result < 0) {
printk(KERN_WARNING "hello: can't get version %d:%d\n", major, minor);
return result;
}
// Initialize the device.
my_cdev = cdev_alloc();
if(!my_cdev) {
printk(KERN_WARNING "hello: cdev_alloc failed");
return -1;
}
my_cdev->ops = &my_ops;
if(cdev_add(my_cdev, dev, 1) < 0) {
printk(KERN_WARNING "hello: cdev_add failed");
return -1;
}
hello_create_proc(); // proc debugging
printk(KERN_WARNING "hello: got version %d:%d\n", major, minor);
printk(KERN_WARNING "hello: my_cdev allocated\n");
printk(KERN_WARNING "hello: my_cdev added\n");
return 0;
}
static int GPS_init(void)
{
dev_t dev = MKDEV(GPS_major, 0);
INT32 alloc_ret = 0;
INT32 cdev_err = 0;
#if REMOVE_MK_NODE
struct device *stpgps_dev = NULL;
#endif
/*static allocate chrdev */
alloc_ret = register_chrdev_region(dev, 1, GPS_DRIVER_NAME);
if (alloc_ret) {
pr_warn("fail to register chrdev\n");
return alloc_ret;
}
cdev_init(&GPS_cdev, &GPS_fops);
GPS_cdev.owner = THIS_MODULE;
cdev_err = cdev_add(&GPS_cdev, dev, GPS_devs);
if (cdev_err)
goto error;
#if REMOVE_MK_NODE
stpgps_class = class_create(THIS_MODULE, "stpgps");
if (IS_ERR(stpgps_class))
goto error;
stpgps_dev = device_create(stpgps_class, NULL, dev, NULL, "stpgps");
if (IS_ERR(stpgps_dev))
goto error;
#endif
pr_warn(KERN_ALERT "%s driver(major %d) installed.\n", GPS_DRIVER_NAME, GPS_major);
return 0;
error:
#if REMOVE_MK_NODE
if (!IS_ERR(stpgps_dev))
device_destroy(stpgps_class, dev);
if (!IS_ERR(stpgps_class)) {
class_destroy(stpgps_class);
stpgps_class = NULL;
}
#endif
if (cdev_err == 0)
cdev_del(&GPS_cdev);
if (alloc_ret == 0)
unregister_chrdev_region(dev, GPS_devs);
return -1;
}
static int __init epio_init(void)
{
// int h_cfg ;
int res;
struct class *asd_class;
if(epio_major)
{
printk("epio_major = %d *************\n", epio_major) ;
devno_a = MKDEV(epio_major, 0) ;
res = register_chrdev_region(devno_a, 1, EPIO_NAME);
}
else
{
res = alloc_chrdev_region(&devno_a, 0, 1, EPIO_NAME);
epio_major = MAJOR(devno_a);
}
if(res)
{
printk("register chrdev region fail.\n") ;
goto out_unreg_chrdev_region ;
}
cdev_init(&epio_dev.cdev, &epio_fops);
res = cdev_add(&epio_dev.cdev, devno_a, 1);
printk("epio_driver:cdev_add:res=%d\n",res);
if (res)
{
printk("cdev_add fail.\n") ;
//goto out ;
}
asd_class = class_create(THIS_MODULE,EPIO_NAME);
if(IS_ERR(asd_class))
{
printk("create the asd_class failed\n");
return -1;
}
device_create(asd_class, NULL, devno_a, NULL, EPIO_NAME);
hw_state_dev.led_usermode=1;
out_unreg_chrdev_region:
unregister_chrdev_region(devno_a, 1) ;
return 0 ;
}
int init_module(void)
{
word divisor;
unsigned char reg;
struct resource *base_res;
printk("<1>""uart: INIT_MOD\n");
// To do: request the IO port region
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0)
#else
#endif
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0)
if(uart_major) {
if ( register_chrdev_region(MKDEV(uart_major,0), 1, "uart") < 0 ) {
printk ("register_chrdev_region() fail\n");
release_region(PORT_COM1,8);
return -1;
}
}
else {
if (alloc_chrdev_region(&devno, 0, 1, "uart") < 0) {
printk ("alloc_chrdev_region() fail\n");
release_region(PORT_COM1,8);
return -1;
}
uart_major=MAJOR(devno);
}
cdev_init(&mycdev, &uart_fops);
mycdev.owner=THIS_MODULE;
if(cdev_add(&mycdev, MKDEV(uart_major,0), 1)) {
printk ("Error adding cdev\n");
unregister_chrdev_region(MKDEV(uart_major, 0), 1);
release_region(PORT_COM1,8);
}
#else
uart_major = register_chrdev(0, "uart", &uart_fops);
if (uart_major < 0) {
printk("<1>" "uart: can't get major number\n");
release_region(PORT_COM1,8);
return -1;
}
#endif
// To do: PORT_COM1, set the baud: 2400,
// To do: BITS_8 | PARITY_NONE | STOP_ONE
return 0;
}
/*
* reg_dev() - registers a device & initializes the structure components
*/
static int reg_dev(int base_addr, int minor, int irq)
{
int err;
err = register_chrdev_region(MKDEV(major, minor), 1, MODULE_NAME);
if (err != 0) {
printk(LOG_LEVEL "ERROR registering chrdev region: error %d\n",
err);
goto out_reg_chrdev;
}
if ((request_irq(irq, uart_interrupt_handler, IRQF_SHARED, MODULE_NAME,
&devs[minor])) != 0) {
printk(LOG_LEVEL "ERROR requesting irq: error %d\n", err);
goto out_req_irq;
}
if (!request_region(base_addr, COM_NR_PORTS, MODULE_NAME)) {
printk(LOG_LEVEL "ERROR registering region\n");
err = -ENODEV;
goto out_req_reg;
}
atomic_set(&devs[minor].access, 1);
devs[minor].base_addr = base_addr;
INIT_KFIFO(devs[minor].read_buffer);
spin_lock_init(&devs[minor].read_lock);
init_waitqueue_head(&devs[minor].read_wq);
INIT_KFIFO(devs[minor].write_buffer);
spin_lock_init(&devs[minor].write_lock);
init_waitqueue_head(&devs[minor].write_wq);
outb(0x0, base_addr + IER);
outb(0x1, base_addr + IER);
outb(0x0, base_addr + FCR);
outb(0x7, base_addr + FCR);
outb(0xb, base_addr + MCR);
cdev_init(&devs[minor].cdev, &uart_fops);
cdev_add(&devs[minor].cdev, MKDEV(major, minor), 1);
return 0;
out_reg_chrdev:
return err;
out_req_reg:
free_irq(irq, &devs[minor]);
out_req_irq:
unregister_chrdev_region(MKDEV(major, minor), 1);
return err;
}
__init static int keyint1_driver_init (void)
{
int ret ;
dev_t devno = MKDEV (major, minor) ;
ret = register_chrdev_region (devno, 1, "keyint1_device") ;
if (ret) {
printk (KERN_ALERT"char device num fail!\r\n") ;
goto err ;
}
cdev_init (&keyint1_cdev, &keyint1_ops) ;
ret = cdev_add (&keyint1_cdev, devno, 1) ;
if (ret) {
printk (KERN_ALERT"CDEV ADD ERROR") ;
goto err1;
}
gph0base = ioremap (0xE0300C00, sizeof (gph0)) ;
WKUP_INT0_7_MASK = ioremap(0XE0300F00, 4) ;
PEND = ioremap (0XE0300F40, 4) ;
GPH0.GPH0CON = (GPH0.GPH0CON & (~(0xf<<4))) | (2 << 4) ;
GPH0.GPH0CON = (GPH0.GPH0CON & (~(0xf<<8))) | (2 << 8) ; //GPH0_2 EXT2
*WKUP_INT0_7_MASK = *WKUP_INT0_7_MASK & (~(1<<1)) ;
*WKUP_INT0_7_MASK = *WKUP_INT0_7_MASK & (~(1<<2)) ;
ret = request_irq (32 + 1, key_int_handler, IRQF_DISABLED | IRQF_TRIGGER_FALLING, "KEY1_IRQ", NULL) ;
if (ret) {
printk (KERN_ALERT"REQUEST IRQ ERROR\n") ;
goto err2 ;
}
ret = request_irq (32 + 2, key_int_handler, IRQF_DISABLED | IRQF_TRIGGER_FALLING, "KEY2_IRQ", NULL) ;
if (ret) {
printk (KERN_ALERT"REQUEST IRQ ERROR\n") ;
goto err3 ;
}
printk (KERN_ALERT"keyint1 DRIVER INSMOD DONE!\n") ;
return 0 ;
err3:
free_irq (32 + 1, NULL) ;
err2:
cdev_del (&keyint1_cdev) ;
err1:
unregister_chrdev_region (devno, 1);
err:
return ret ;
}
static int __init ds18b20_drv_init(void)
{
int ret = 0;
dev_t devno = MKDEV(mars_ds18b20_major, 0);
/* Allocating mars_ds18b20_dev structure dynamically */
mars_ds18b20_devp = kmalloc(sizeof(struct mars_ds18b20_dev), GFP_KERNEL);
if (!mars_ds18b20_devp) {
return -ENOMEM;
}
memset(mars_ds18b20_devp, 0, sizeof(struct mars_ds18b20_dev));
mars_ds18b20_devp->ds18b20_name = MARS_DS18B20_NAME;
/* Register char devices region */
if (mars_ds18b20_major) {
ret = register_chrdev_region(devno, 1, mars_ds18b20_devp->ds18b20_name);
}else {
/* Allocating major number dynamically */
ret = alloc_chrdev_region(&devno, 0, 1, mars_ds18b20_devp->ds18b20_name);
mars_ds18b20_major = MAJOR(devno);
}
if (ret < 0)
return ret;
/* Helper function to initialize and add cdev structure */
mars_ds18b20_setup_cdev(mars_ds18b20_devp, 0);
/* mdev - automatically create the device node */
mars_ds18b20_devp->ds18b20_cls = class_create(THIS_MODULE, mars_ds18b20_devp->ds18b20_name);
if (IS_ERR(mars_ds18b20_devp->ds18b20_cls))
return PTR_ERR(mars_ds18b20_devp->ds18b20_cls);
mars_ds18b20_devp->ds18b20_dev = device_create(mars_ds18b20_devp->ds18b20_cls, NULL, devno, NULL, mars_ds18b20_devp->ds18b20_name);
if (IS_ERR(mars_ds18b20_devp->ds18b20_dev)) {
class_destroy(mars_ds18b20_devp->ds18b20_cls);
cdev_del(&mars_ds18b20_devp->cdev);
unregister_chrdev_region(devno, 1);
kfree(mars_ds18b20_devp);
return PTR_ERR(mars_ds18b20_devp->ds18b20_dev);
}
ret = mars_ds18b20_hw_init();
if (ret)
return ret;
printk(MARS_DS18B20_NAME" is initialized!!\n");
return 0;
}
int IO_irq_init_module(void)
{
int result;
dev_t dev = 0;
/*
* Get a range of minor numbers to work with, asking for a dynamic
* major unless directed otherwise at load time.
*/
if (IO_irq_major) {
dev = MKDEV(IO_irq_major, IO_irq_minor);
result = register_chrdev_region(dev, 1, "IO_irq");
} else {
result = alloc_chrdev_region(&dev, IO_irq_minor, 1,
"IO_irq");
IO_irq_major = MAJOR(dev);
}
if (result < 0) {
printk(KERN_WARNING "IO_irq: can't get major %d\n", IO_irq_major);
return result;
}
/*
* allocate the devices -- we can't have them static, as the number
* can be specified at load time
*/
IO_irq_devices = kmalloc(sizeof(struct IO_irq_dev), GFP_KERNEL);
if (!IO_irq_devices) {
result = -ENOMEM;
goto fail; /* Make this more graceful */
}
memset(IO_irq_devices, 0, sizeof(struct IO_irq_dev));
/* Initialize each device. */
init_MUTEX(&IO_irq_devices->sem);
IO_irq_devices->IO_irq1 = (unsigned int) IO_IRQ1;
IO_irq_devices->IO_irq2 = (unsigned int) IO_IRQ2;
IO_irq_devices->IO_irq3 = (unsigned int) IO_IRQ3;
IO_irq_devices->IO_irq4 = (unsigned int) IO_IRQ4;
IO_irq_devices->IO_status = 0 ;
IO_irq_setup_cdev(IO_irq_devices);
set_irq_type(IO_IRQ1,IRQ_TYPE_EDGE_RISING );
set_irq_type(IO_IRQ2,IRQ_TYPE_EDGE_FALLING );
set_irq_type(IO_IRQ3,IRQ_TYPE_EDGE_RISING );
set_irq_type(IO_IRQ4,IRQ_TYPE_EDGE_FALLING );
return 0; /* succeed */
fail:
IO_irq_cleanup_module();
return result;
}
/*当驱动名字和设备名字匹配时，probe被调用*/
static int s5pc100_adc_probe(struct platform_device *pdev)
{
init_waitqueue_head(&readq); //务必初始化等待队列
/* 申请内存资源、中断资源(号) */
res_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
res_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 1);
if((res_mem == NULL) || (res_irq == NULL))
return -ENODEV;
printk("mem start = 0x%x,end = 0x%x\n",res_mem->start,res_mem->end);
printk("irqno = %d\n",res_irq->start);
adc_base = ioremap(res_mem->start,res_mem->end - res_mem->start);
if(adc_base == NULL)
return -ENOMEM;
/* 申请中断 */
ret = request_irq(res_irq->start,adc_irq_handler,flags,"adc",NULL);
if(ret < 0)
goto err1;
if(register_chrdev_region(devno,count,"adc") < 0)
goto err2;
/* 初始化cdev ，即关联cdev和file_operations*/
cdev_init(&myadc.cdev,&myfops);
ret = cdev_add(&myadc.cdev,devno,1);
if(ret < 0)
{
printk(KERN_WARNING "Error: %d fail adding adc device\n",ret);
goto err3;
}
clk = clk_get(NULL,"adc"); //获得adc时钟控制结构体
if(clk == NULL)
{
ret = -ENODEV;
goto err4;
}
clk_enable(clk); //打开adc时钟
printk(KERN_INFO "platform:match ok !\n");
return 0;
err4:
cdev_del(&myadc.cdev);
err3:
unregister_chrdev_region(devno,count);
err2:
free_irq(res_irq->start,NULL);
err1:
iounmap(adc_base);
return ret;
}
/* called from _mali_osk_init */
int initialize_kernel_device(void)
{
int err;
dev_t dev = 0;
if (0 == mali_major)
{
/* auto select a major */
err = alloc_chrdev_region(&dev, 0/*first minor*/, 1/*count*/, mali_dev_name);
mali_major = MAJOR(dev);
}
else
{
/* use load time defined major number */
dev = MKDEV(mali_major, 0);
err = register_chrdev_region(dev, 1/*count*/, mali_dev_name);
}
if (err)
{
goto init_chrdev_err;
}
memset(&device, 0, sizeof(device));
/* initialize our char dev data */
cdev_init(&device.cdev, &mali_fops);
device.cdev.owner = THIS_MODULE;
device.cdev.ops = &mali_fops;
/* register char dev with the kernel */
err = cdev_add(&device.cdev, dev, 1/*count*/);
if (err)
{
goto init_cdev_err;
}
err = mali_sysfs_register(&device, dev, mali_dev_name);
if (err)
{
goto init_sysfs_err;
}
/* Success! */
return 0;
init_sysfs_err:
cdev_del(&device.cdev);
init_cdev_err:
unregister_chrdev_region(dev, 1/*count*/);
init_chrdev_err:
return err;
}
static int __init hello_2_init (void)
{
int result;
dev = MKDEV (hello_major, hello_minor);
result = register_chrdev_region (dev, number_of_devices, "test");
if (result<0) {
printk (KERN_WARNING "hello: can't get major number %d\n", hello_major);
return result;
}
char_reg_setup_cdev ();
printk (KERN_INFO "char device registered\n");
return 0;
}
//----------------------------------------------------------------------
//sq_spi_download_init
//----------------------------------------------------------------------
int __init sq_spi_download_init(void)
{
int err=0,i;
//#if (USE_CDEV == 1)
dev_t dev_id;
int retval;
SPI_DOWNLOAD_DBG(" sq_spi_download_init\n");
err=spi_register_driver(&sq_spi_download_driver);
if(err)
printk("sq_spi_download_driver init fail\n");
/*
err = platform_driver_register(&sq_spi_download_driver);
if(err)
printk("sq_spi_download_driver init fail\n");
*/
//#else
if (major) {
dev_id = MKDEV(major, 0);
retval = register_chrdev_region(dev_id, sq_spi_download_COUNT,NAME);
} else {
retval = alloc_chrdev_region(&dev_id, 0, sq_spi_download_COUNT,NAME);
major = MAJOR(dev_id);
}
SPI_DOWNLOAD_DBG(": mask=%#lx major=%d\n", mask, major);
cdev_init(&sq_spi_download_cdev, &sq_spi_download_fops);
cdev_add(&sq_spi_download_cdev, dev_id, sq_spi_download_COUNT);
//#endif
SPI_DOWNLOAD_DBG(" sq_spi_download_init end\n");
/*
#define DL_PROGB (0x01 << 7)
#define DL_DONE (0x01 << 6)
#define DL_RST (0x01 << 5)
#define DL_INITB (0x01 << 4)
*/
i=10;
return err;
}
/*
功能描述 : 模块初始化函数
返回值 : 成功为0，失败为-1
参数 :
作者 : 张彦升
日期 : 2014年1月21日 11:22:01
*/
static int __init dpram_init(void)
{
int i = 0;
int minor_a = 0;
int minor_b = 0;
int ret;
dev_t devno = 0;
if (dpram_major)
{
devno = MKDEV(dpram_major, 0);
ret = register_chrdev_region(devno, DPRAM_DEVS_NR, "dpram");
}
else
{
ret = alloc_chrdev_region(&devno, 0, DPRAM_DEVS_NR, "dpram");
dpram_major = MAJOR(devno);
}
if (ret < 0)
{
printk(KERN_WARNING "dpram: can't get major %d\n", dpram_major);
return ret;
}
for (i = 0;i < DPRAM_PAIR_DEV_NR;i++)
{
minor_a = i * 2;
minor_b = minor_a + 1;
ret = dpram_pair_dev_init(&pair_devs[i],minor_a,minor_b);
if (-1 == ret)
{
return -EFAULT;
}
}
#ifdef DPRAM_DEBUG
/*创建proc接口*/
dpram_create_proc();
#endif /*DPRAM_DEBUG*/
/*暂时没添加清空内存逻辑*/
/*dpram_mem_clear(0,DPRAM_TOTAL_MEMORY_SIZE);*/
printk(KERN_INFO "dpram init.\n");
return 0;
}
/**
* @brief This function create the char dev
* @param hdev pointer to hdev
* @return 0--success otherwise failure
*/
int
mbtchar_register_char_dev(struct hci_dev *hdev)
{
int ret = 0, dev_num;
ENTER();
/* create the chrdev region */
if (mbtchar_major) {
dev_num = MKDEV(mbtchar_major, hdev->id);
ret = register_chrdev_region(dev_num, 1, MODULE_NAME);
} else {
PRINTM(MINFO, "mbtchar: no major # yet\n");
ret = alloc_chrdev_region(&dev_num, hdev->id, 1, MODULE_NAME);
}
if (ret) {
PRINTM(MERROR, "mbtchar: create chrdev_region failed\n");
LEAVE();
return ret;
}
if (!mbtchar_major) {
/* Store the allocated dev major # */
mbtchar_major = MAJOR(dev_num);
}
cdev_init(&hdev->cdev, &mbtchar_fops);
hdev->cdev.owner = THIS_MODULE;
hdev->cdev.ops = &mbtchar_fops;
dev_num = MKDEV(mbtchar_major, hdev->id);
if (cdev_add(&hdev->cdev, dev_num, 1)) {
PRINTM(MERROR, "mbtchar: cdev_add failed\n");
ret = -EFAULT;
goto free_cdev_region;
}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26)
device_create(mbtchar_class, NULL, MKDEV(mbtchar_major, hdev->id), NULL,
"mbtchar%d", hdev->id);
#else
device_create(mbtchar_class, NULL, MKDEV(mbtchar_major, hdev->id),
"mbtchar%d", hdev->id);
#endif
PRINTM(MINFO, "regier char dev=%d\n", hdev->id);
LEAVE();
return ret;
free_cdev_region:
unregister_chrdev_region(MKDEV(mbtchar_major, hdev->id), 1);
LEAVE();
return ret;
}
int scullc_init(void)
{
int result, i;
dev_t dev = MKDEV(scullc_major, 0);
/*
* Register your major, and accept a dynamic number.
*/
if (scullc_major)
result = register_chrdev_region(dev, scullc_devs, "scullc");
else {
result = alloc_chrdev_region(&dev, 0, scullc_devs, "scullc");
scullc_major = MAJOR(dev);
}
if (result < 0)
return result;
/*
* allocate the devices -- we can't have them static, as the number
* can be specified at load time
*/
scullc_devices = kmalloc(scullc_devs*sizeof (struct scullc_dev), GFP_KERNEL);
if (!scullc_devices) {
result = -ENOMEM;
goto fail_malloc;
}
memset(scullc_devices, 0, scullc_devs*sizeof (struct scullc_dev));
for (i = 0; i < scullc_devs; i++) {
scullc_devices[i].quantum = scullc_quantum;
scullc_devices[i].qset = scullc_qset;
sema_init (&scullc_devices[i].sem, 1);
scullc_setup_cdev(scullc_devices + i, i);
}
scullc_cache = kmem_cache_create("scullc", scullc_quantum,
0, SLAB_HWCACHE_ALIGN, NULL); /* no ctor/dtor */
if (!scullc_cache) {
scullc_cleanup();
return -ENOMEM;
}
#ifdef SCULLC_USE_PROC /* only when available */
create_proc_read_entry("scullcmem", 0, NULL, scullc_read_procmem, NULL);
#endif
return 0; /* succeed */
fail_malloc:
unregister_chrdev_region(dev, scullc_devs);
return result;
}
