static int __init _spi_init(void) { int ret; unsigned char ch = 0x01; struct spi_master *master; struct spi_board_info spi_device_info = { .modalias = "ami-spi-device", .max_speed_hz = 12000000, //speed of your device splace can handle .bus_num = 0, //BUS number .chip_select = 0, .mode = 3, }; printk(KERN_INFO "spi basic driver init"); master = spi_busnum_to_master(spi_device_info.bus_num); if (!master) { printk(KERN_ALERT "Failed to create master device"); return -ENODEV; } //create a slave new device, given the master and device info sdev = spi_new_device(master, &spi_device_info); if (!sdev) { printk(KERN_ALERT "Failed to create slave device"); return -ENODEV; } sdev->bits_per_word = 8; ret = spi_setup(sdev); if (ret) { printk(KERN_ALERT "Failed to setup slave"); spi_unregister_device(sdev); return -ENODEV; } printk(KERN_ALERT "Writing ch=0x01 to spi interface"); spi_write(sdev, &ch, sizeof(ch)); return 0; } static void __exit _spi_exit(void) { printk(KERN_INFO "spi basic driver exit"); if (sdev) { unsigned char ch = 0xff; spi_write(sdev, &ch, sizeof(ch)); spi_unregister_device(sdev); } }
void cc2520_plat_spi_free() { if (state.spi_device) spi_unregister_device(state.spi_device); spi_unregister_driver(&cc2520_spi_driver); }
struct v4l2_subdev *v4l2_spi_new_subdev(struct v4l2_device *v4l2_dev, struct spi_master *master, struct spi_board_info *info) { struct v4l2_subdev *sd = NULL; struct spi_device *spi = NULL; BUG_ON(!v4l2_dev); if (info->modalias) request_module(info->modalias); spi = spi_new_device(master, info); if (spi == NULL || spi->dev.driver == NULL) goto error; if (!try_module_get(spi->dev.driver->owner)) goto error; sd = spi_get_drvdata(spi); if (v4l2_device_register_subdev(v4l2_dev, sd)) sd = NULL; module_put(spi->dev.driver->owner); error: if (spi && sd == NULL) spi_unregister_device(spi); return sd; }
int BcmSpiReleaseSlave(int busNum, int slaveId) { if ( slaveId > 7 ) { return SPI_STATUS_ERR; } if ( LEG_SPI_BUS_NUM == busNum ) { #ifndef SPI return( SPI_STATUS_ERR ); #else if ( NULL == bcmLegSpiDevices[slaveId] ) { printk(KERN_ERR "BcmSpiReleaseSlave - slaveId %d, already released\n", slaveId); return( SPI_STATUS_ERR ); } bcmLegSpiDevInfo[slaveId].max_speed_hz = 781000; spi_unregister_driver(&bcmLegSpiDevDrv[slaveId]); spi_unregister_device(bcmLegSpiDevices[slaveId]); bcmLegSpiDevices[slaveId] = 0; #endif } else if ( HS_SPI_BUS_NUM == busNum ) { #ifndef HS_SPI return( SPI_STATUS_ERR ); #else if ( NULL == bcmHSSpiDevices[slaveId] ) { printk(KERN_ERR "BcmSpiReleaseSlave - slaveId %d, already released\n", slaveId); return( SPI_STATUS_ERR ); } bcmHSSpiDevInfo[slaveId].max_speed_hz = 781000; spi_unregister_driver(&bcmHSSpiDevDrv[slaveId]); spi_unregister_device(bcmHSSpiDevices[slaveId]); bcmHSSpiDevices[slaveId] = 0; #endif } else return( SPI_STATUS_ERR ); return 0; }
// ----------------------------------------------------------------------------------- static void __exit exit_maspi(void) { if (maspi_device) { printk(KERN_INFO "unregistering maspi spi device\n"); spi_unregister_device(maspi_device); } }
/****************************** Module exit function ******************************/ static void __exit nrf_exit(void) { printk(KERN_ALERT "Bye from module!!\n"); nrf_power_down(); spi_unregister_device(spi_device); device_destroy(nrf_class,MKDEV(MAJOR(dev),0)); class_unregister(nrf_class); class_destroy(nrf_class); cdev_del(nrf_cdev); unregister_chrdev_region(MKDEV(MAJOR(dev),0),1); }
static inline __init int spi_int(void) { int ret; struct spi_board_info spi_device_info_1 = { .modalias = "spi_int", .max_speed_hz = speed_hz, .bus_num = spi_bus, .mode = 1, // depends on the mode we have to use this }; struct spi_master *master1; // for specifying I am using this driver for spi_master master1 = spi_busnum_to_master( spi_device_info_1.bus_num ); //assigning bus_number to master if( !master1 ) { printk( KERN_INFO"spi bus information for master not found"); return -ENODEV; // error to the kernel } spi_device_1 = spi_new_device( master1, &spi_device_info_1 ); // creation of spi device in kernel module if( !spi_device_1 ) { printk(KERN_INFO"spi device not able to create "); // this error is generated if we are using the same channel which bydefault spi is using return -ENODEV; } spi_device_1->bits_per_word = 32; // specifying the lenght of word that can spi transfer spi_device_1->cs_gpio =60; // for external GPIO as chip select ret = spi_setup( spi_pot_device); if( ret ) spi_unregister_device( spi_device_1 ); else printk( KERN_INFO "%d bus no andcs no %d", spi_bus, gpio_pin_chipselect ); return ret; } static inline void spi_release(void) { spi_unregister_device( spi_pot_device ); }
static void butterfly_detach(struct parport *p) { struct butterfly *pp; struct platform_device *pdev; int status; /* FIXME this global is ugly ... but, how to quickly get from * the parport to the "struct butterfly" associated with it? * "old school" driver-internal device lists? */ if (!butterfly || butterfly->port != p) return; pp = butterfly; butterfly = NULL; #ifdef HAVE_USI spi_unregister_device(pp->butterfly); pp->butterfly = NULL; #endif spi_unregister_device(pp->dataflash); pp->dataflash = NULL; status = spi_bitbang_stop(&pp->bitbang); /* turn off VCC */ parport_write_data(pp->port, 0); msleep(10); parport_release(pp->pd); parport_unregister_device(pp->pd); pdev = to_platform_device(pp->bitbang.master->cdev.dev); (void) spi_master_put(pp->bitbang.master); platform_device_unregister(pdev); }
static inline __init int spi_init(void) { struct spi_board_info spi_pot_device_info = { .modalias = "itrigue", .max_speed_hz = speed_hz, .bus_num = pot_spi_bus, .chip_select = pot_spi_cs, .mode = 0, }; struct spi_master *master; int ret; master = spi_busnum_to_master( spi_pot_device_info.bus_num ); if( !master ) return -ENODEV; spi_pot_device = spi_new_device( master, &spi_pot_device_info ); if( !spi_pot_device ) return -ENODEV; spi_pot_device->bits_per_word = 16; ret = spi_setup( spi_pot_device ); if( ret ) spi_unregister_device( spi_pot_device ); else printk( KERN_INFO "I-Trigue 3300 potentiometers registered to SPI bus %u, chipselect %u\n", pot_spi_bus, pot_spi_cs ); return ret; } static inline void spi_exit(void) { spi_unregister_device( spi_pot_device ); }
static __init int spisvc_init(void) { struct spi_master *m = NULL; struct spi_board_info board = { .modalias = "spidev", .max_speed_hz = 15058800, .mode = SPI_MODE_3, .platform_data = NULL, .bus_num = 0, .chip_select = 0, .irq = 0, }; if (SPI_INVALID_BUS == busnum) /* Bus not assigned: find SPI master with lowest bus number */ for (busnum = 0; SPI_MAX_BUS > busnum && NULL == m; busnum++) m = spi_busnum_to_master(busnum); else m = spi_busnum_to_master(busnum); if (!m) { pr_err("SPI bus not available.\n"); return -ENODEV; } board.bus_num = busnum = m->bus_num; board.chip_select = cs; spidev = spi_new_device(m, &board); if (!spidev) { dev_err(&m->dev, "Cannot add '%s' on bus %u, cs %u\n", board.modalias, board.bus_num, board.chip_select); return -ENODEV; } return 0; } module_init(spisvc_init); static __exit void spisvc_exit(void) { if (spidev) spi_unregister_device(spidev); } module_exit(spisvc_exit);
void bcm_mpi_deinit(bcm_mpi_t *t) { bcm_pr_debug("%s()\n", __func__); #ifdef BCMPH_DEBUG_MPI bcm_mpi_dump_and_reset_trace(t); #endif #ifdef BCMPH_USE_SPI_DRIVER #ifndef BCMPH_NOHW if (t->bus_is_locked) { spi_bus_unlock(t->dev->master); t->bus_is_locked = false; } spi_unregister_device(t->dev); #endif // !BCMPH_NOHW t->dev = NULL; #else // !BCMPH_USE_SPI_DRIVER #ifndef BCMPH_NOHW if (bcm_mpi_dev_data.ref_count > 0) { if (1 == bcm_mpi_dev_data.ref_count) { platform_driver_unregister(&(bcm63xx_spi_driver)); } else { bcm_mpi_dev_data.ref_count -= 1; } } else { bcm_pr_err("Illegal call of %s()\n", __func__); } #endif // !BCMPH_NOHW #endif // !BCMPH_USE_SPI_DRIVER }
struct v4l2_subdev *v4l2_spi_new_subdev(struct v4l2_device *v4l2_dev, struct spi_master *master, struct spi_board_info *info) { struct v4l2_subdev *sd = NULL; struct spi_device *spi = NULL; BUG_ON(!v4l2_dev); if (info->modalias) request_module(info->modalias); spi = spi_new_device(master, info); if (spi == NULL || spi->dev.driver == NULL) goto error; if (!try_module_get(spi->dev.driver->owner)) goto error; sd = spi_get_drvdata(spi); /* Register with the v4l2_device which increases the module's use count as well. */ if (v4l2_device_register_subdev(v4l2_dev, sd)) sd = NULL; /* Decrease the module use count to match the first try_module_get. */ module_put(spi->dev.driver->owner); error: /* If we have a client but no subdev, then something went wrong and we must unregister the client. */ if (spi && sd == NULL) spi_unregister_device(spi); return sd; }
static void __exit low_speed_spidev_module_exit(void) { pr_info("module exit"); if (dev) spi_unregister_device(dev); }
int __init bcm_mpi_init(bcm_mpi_t *t, const bcm_mpi_params_t *params) { int ret = -1; #ifdef BCMPH_USE_SPI_DRIVER # ifndef BCMPH_NOHW struct spi_master *master; struct spi_board_info board_info; # endif // !BCMPH_NOHW #endif // BCMPH_USE_SPI_DRIVER bcm_pr_debug("%s()\n", __func__); bcm_assert(NULL != params); #ifndef BCMPH_NOHW t->trx_opts.fill_byte = params->fill_byte; t->trx_opts.wait_completion_with_irq = params->wait_completion_with_irq; t->trx_opts.drop_cs_after_each_byte = params->drop_cs_after_each_byte; t->trx_opts.cs_off_clk_cycles = params->cs_off_clk_cycles; #endif // !BCMPH_NOHW #ifdef BCMPH_USE_SPI_DRIVER t->mpi_clk = params->clk; # ifndef BCMPH_NOHW master = spi_busnum_to_master(params->bus_num); if (NULL == master) { bcm_pr_err("No SPI master found for bus num %d. Module bcm63xx-spi not loaded ?\n", (int)(params->bus_num)); ret = -EINVAL; goto fail_master; } memset(&(board_info), 0, sizeof(board_info)); strcpy(board_info.modalias, driver_name); board_info.max_speed_hz = params->clk; board_info.bus_num = params->bus_num; board_info.chip_select = params->cs; board_info.mode = SPI_MODE_3; t->dev = spi_new_device(master, &(board_info)); if (NULL == t->dev) { bcm_pr_err("Failed to add SPI device (busnum = %d, chip select = %d, clock = %lu)\n", (int)(params->bus_num), (int)(params->cs), (unsigned long)(params->clk)); ret = -ENOMEM; goto fail_new_dev; } put_device(&(master->dev)); /* Lock the bus */ if ((params->has_exclusive_bus_access) && (!bcm_drv_param_mpi_no_exclusive_bus_access)) { spi_bus_lock(t->dev->master); t->bus_is_locked = true; } bcm_mpi_enable_extra_CSs(params->cs); # ifdef BCMPH_DEBUG_MPI t->trace_len = 0; # endif // BCMPH_DEBUG_MPI return (0); spi_unregister_device(t->dev); fail_new_dev: put_device(&(master->dev)); fail_master: # else // BCMPH_NOHW ret = 0; # endif // BCMPH_NOHW #else // !BCMPH_USE_SPI_DRIVER # ifndef BCMPH_NOHW t->mpi_cs = params->cs; t->clk_cfg = bcm_mpi_get_clk_cfg(params->clk, params->cs_off_clk_cycles); bcm_mpi_enable_extra_CSs(params->cs); if (bcm_mpi_dev_data.ref_count <= 0) { struct device_driver *spi_driver = driver_find(bcm63xx_spi_driver.driver.name, &platform_bus_type); if (NULL != spi_driver) { bcm_pr_err("Error: Driver '%s' is already registered, aborting...\n", bcm63xx_spi_driver.driver.name); ret = -EBUSY; } else { ret = platform_driver_register(&(bcm63xx_spi_driver)); } bcm_assert(((ret) && (0 == bcm_mpi_dev_data.ref_count)) || ((!ret) && (1 == bcm_mpi_dev_data.ref_count))); } else { bcm_mpi_dev_data.ref_count += 1; ret = 0; } if (!ret) { bcm_assert(bcm_mpi_dev_data.ref_count > 0); if (params->cs > bcm_mpi_dev_data.num_chipselect) { dev_err(&(bcm_mpi_dev_data.pdev->dev), "%s, unsupported slave %d\n", __func__, params->cs); if (1 == bcm_mpi_dev_data.ref_count) { platform_driver_unregister(&(bcm63xx_spi_driver)); } bcm_mpi_dev_data.ref_count -= 1; ret = -EINVAL; } else { t->dev_data = &(bcm_mpi_dev_data); } } # else // BCMPH_NOHW ret = 0; # endif // BCMPH_NOHW #endif // !BCMPH_USE_SPI_DRIVER return (ret); }
static void __exit mcp3901_exit(void) { spi_unregister_device(mcp3901_device); spi_unregister_driver(&mcp3901_driver); }
static void __exit galileo_module_exit(void) { pr_info("module exit"); if (dev) spi_unregister_device(dev); }
static void hotplug_spi_exit(void) { printk(KERN_ALERT "Removing SPI Device: %s, bus: %i, chip-sel: %i\n", slave_spi_board_info.modalias, slave_spi_board_info.bus_num, slave_spi_board_info.chip_select); spi_unregister_device(slave_spi_device); }
static void qtft_spi_device_unregister(struct spi_device *device) { spi_unregister_device(device); }
/** * pmodad1_of_probe - Probe method for PmodAD1 device (over GPIO). * @pdev: pointer to platform devices * * This function probes the PmodAD1 device in the device tree. It initializes the * PmodAD1 driver data structure. It returns 0, if the driver is bound to the PmodAD1 * device, or a negative value if there is an error. */ static int __devinit pmodad1_of_probe(struct platform_device *pdev) { struct pmodad1_device *pmodad1_dev; struct platform_device *pmodad1_pdev; struct spi_gpio_platform_data *pmodad1_pdata; struct device_node *np = pdev->dev.of_node; const u32* tree_info; const u32* spi_speed; int status = 0; /* Alloc Space for platform device structure */ pmodad1_dev = (struct pmodad1_device*) kzalloc(sizeof(*pmodad1_dev), GFP_KERNEL); if(!pmodad1_dev) { status = -ENOMEM; dev_err(&pdev->dev, "Platform device structure allocation " "failed: %d\n", status); goto dev_alloc_err; } pmodad1_dev->val_buf = (unsigned short *)kmalloc(read_buf_size, GFP_KERNEL); if (!pmodad1_dev->val_buf) { status = -ENOMEM; dev_err(&pdev->dev, "Device value buffer allocation " "failed: %d\n", status); goto buf_alloc_err; } /* Get the GPIO Pins */ pmodad1_dev->iSCLK = of_get_named_gpio(np, "spi-sclk-gpio", 0); pmodad1_dev->iSDOUT = of_get_named_gpio(np, "spi-sdout-gpio", 0); status = of_get_named_gpio(np, "spi-cs-gpio", 0); pmodad1_dev->iCS = (status < 0) ? SPI_GPIO_NO_CHIPSELECT : status; #ifdef CONFIG_PMODS_DEBUG printk(KERN_INFO DRIVER_NAME " %s: iSCLK: 0x%lx\n", np->name, pmodad1_dev->iSCLK); printk(KERN_INFO DRIVER_NAME " %s: iSDOUT: 0x%lx\n", np->name, pmodad1_dev->iSDOUT); printk(KERN_INFO DRIVER_NAME " %s: iCS : 0x%lx\n", np->name, pmodad1_dev->iCS); #endif /* Get SPI Related Params */ tree_info = of_get_property(np, "spi-bus-num", NULL); if(tree_info) { pmodad1_dev->spi_id = be32_to_cpup((tree_info)); #ifdef CONFIG_PMODS_DEBUG printk(KERN_INFO DRIVER_NAME " %s: BUS_ID\t%x\n", np->name, pmodad1_dev->spi_id); #endif } spi_speed = of_get_property(np, "spi-speed-hz", NULL); if(spi_speed) { pmodad1_dev->spi_speed = be32_to_cpup((spi_speed)); #ifdef CONFIG_PMODS_DEBUG printk(KERN_INFO DRIVER_NAME " %s: SPI_SPEED\t%x\n", np->name, pmodad1_dev->spi_speed); #endif } else { pmodad1_dev->spi_speed = DEFAULT_SPI_SPEED; } /* Alloc Space for platform data structure */ pmodad1_pdata = (struct spi_gpio_platform_data*) kzalloc(sizeof(*pmodad1_pdata), GFP_KERNEL); if(!pmodad1_pdata) { status = -ENOMEM; goto pdata_alloc_err; } /* Fill up Platform Data Structure */ pmodad1_pdata->sck = pmodad1_dev->iSCLK; pmodad1_pdata->miso = pmodad1_dev->iSDOUT; pmodad1_pdata->mosi = SPI_GPIO_NO_MOSI; pmodad1_pdata->num_chipselect = 1; /* Alloc Space for platform data structure */ pmodad1_pdev = (struct platform_device*) kzalloc(sizeof(*pmodad1_pdev), GFP_KERNEL); if(!pmodad1_pdev) { status = -ENOMEM; goto pdev_alloc_err; } /* Fill up Platform Device Structure */ pmodad1_pdev->name = "spi_gpio"; pmodad1_pdev->id = pmodad1_dev->spi_id; pmodad1_pdev->dev.platform_data = pmodad1_pdata; pmodad1_dev->pdev = pmodad1_pdev; /* Register spi_gpio master */ status = platform_device_register(pmodad1_dev->pdev); if(status < 0) { dev_err(&pdev->dev, "platform_device_register failed: %d\n", status); goto pdev_reg_err; } #ifdef CONFIG_PMODS_DEBUG printk(KERN_INFO DRIVER_NAME " %s: spi_gpio platform device registered.\n", np->name); #endif pmodad1_dev->name = (char *)np->name; /* Fill up Board Info for SPI device */ status = add_pmodad1_device_to_bus(pmodad1_dev); if(status < 0) { dev_err(&pdev->dev, "add_pmodad1_device_to_bus failed: %d\n", status); goto spi_add_err; } #ifdef CONFIG_PMODS_DEBUG printk(KERN_INFO DRIVER_NAME " %s: spi device registered.\n", np->name); #endif /* Point device node data to pmodad1_device structure */ if(np->data == NULL) np->data = pmodad1_dev; if(pmodad1_dev_id == 0) { /* Alloc Major & Minor number for char device */ status = alloc_chrdev_region(&pmodad1_dev_id, 0, MAX_PMODAD1_DEV_NUM, DRIVER_NAME); if(status) { dev_err(&pdev->dev, "Character device region not allocated correctly: %d\n", status); goto err_alloc_chrdev_region; } #ifdef CONFIG_PMODS_DEBUG printk(KERN_INFO DRIVER_NAME " : Char Device Region Registered, with Major: %d.\n", MAJOR(pmodad1_dev_id)); #endif } if(pmodad1_class == NULL) { /* Create Pmodad1 Device Class */ pmodad1_class = class_create(THIS_MODULE, DRIVER_NAME); if (IS_ERR(pmodad1_class)) { status = PTR_ERR(pmodad1_class); goto err_create_class; } #ifdef CONFIG_PMODS_DEBUG printk(KERN_INFO DRIVER_NAME " : pmodad1 device class registered.\n"); #endif } if(spi_drv_registered == 0) { /* Register SPI Driver for Pmodad1 Device */ status = spi_register_driver(&pmodad1_spi_driver); if (status < 0) { dev_err(&pdev->dev, "pmodad1_spi_driver register failed: %d\n", status); goto err_spi_register; } spi_drv_registered = 1; } device_num ++; return status; err_spi_register: class_destroy(pmodad1_class); pmodad1_class = NULL; err_create_class: unregister_chrdev_region(pmodad1_dev_id, MAX_PMODAD1_DEV_NUM); pmodad1_dev_id = 0; err_alloc_chrdev_region: spi_unregister_device(pmodad1_dev->spi); spi_add_err: platform_device_unregister(pmodad1_dev->pdev); pdev_reg_err: kfree(pmodad1_pdev); pdev_alloc_err: kfree(pmodad1_pdata); pdata_alloc_err: kfree(pmodad1_dev->val_buf); buf_alloc_err: kfree(pmodad1_dev); dev_alloc_err: return status; }
/** * gpio_pmodoled_of_probe - Probe method for PmodOLED device (over GPIO). * @pdev: pointer to platform devices * * This function probes the OLED device in the device tree. It initializes the * OLED driver data structure. It returns 0, if the driver is bound to the OLED * device, or a negative value if there is an error. */ static int gpio_pmodoled_of_probe(struct platform_device *pdev) { struct gpio_pmodoled_device *gpio_pmodoled_dev; struct platform_device *gpio_pmodoled_pdev; struct spi_gpio_platform_data *gpio_pmodoled_pdata; struct device_node *np = pdev->dev.of_node; const u32 *tree_info; int status = 0; /* Alloc Space for platform device structure */ gpio_pmodoled_dev = (struct gpio_pmodoled_device *) kzalloc(sizeof(*gpio_pmodoled_dev), GFP_KERNEL); if (!gpio_pmodoled_dev) { status = -ENOMEM; goto dev_alloc_err; } /* Alloc Graphic Buffer for device */ gpio_pmodoled_dev->disp_buf = (uint8_t *) kmalloc(DISPLAY_BUF_SZ, GFP_KERNEL); if (!gpio_pmodoled_dev->disp_buf) { status = -ENOMEM; dev_err(&pdev->dev, "Device Display data buffer allocation failed: %d\n", status); goto disp_buf_alloc_err; } /* Get the GPIO Pins */ gpio_pmodoled_dev->iVBAT = of_get_named_gpio(np, "vbat-gpio", 0); gpio_pmodoled_dev->iVDD = of_get_named_gpio(np, "vdd-gpio", 0); gpio_pmodoled_dev->iRES = of_get_named_gpio(np, "res-gpio", 0); gpio_pmodoled_dev->iDC = of_get_named_gpio(np, "dc-gpio", 0); gpio_pmodoled_dev->iSCLK = of_get_named_gpio(np, "spi-sclk-gpio", 0); gpio_pmodoled_dev->iSDIN = of_get_named_gpio(np, "spi-sdin-gpio", 0); status = of_get_named_gpio(np, "spi-cs-gpio", 0); gpio_pmodoled_dev->iCS = (status < 0) ? SPI_GPIO_NO_CHIPSELECT : status; #ifdef CONFIG_PMODS_DEBUG printk(KERN_INFO DRIVER_NAME " %s: iVBAT: 0x%lx\n", np->name, gpio_pmodoled_dev->iVBAT); printk(KERN_INFO DRIVER_NAME " %s: iVDD : 0x%lx\n", np->name, gpio_pmodoled_dev->iVDD); printk(KERN_INFO DRIVER_NAME " %s: iRES : 0x%lx\n", np->name, gpio_pmodoled_dev->iRES); printk(KERN_INFO DRIVER_NAME " %s: iDC : 0x%lx\n", np->name, gpio_pmodoled_dev->iDC); printk(KERN_INFO DRIVER_NAME " %s: iSCLK: 0x%lx\n", np->name, gpio_pmodoled_dev->iSCLK); printk(KERN_INFO DRIVER_NAME " %s: iSDIN: 0x%lx\n", np->name, gpio_pmodoled_dev->iSDIN); printk(KERN_INFO DRIVER_NAME " %s: iCS : 0x%lx\n", np->name, gpio_pmodoled_dev->iCS); #endif /* Get SPI Related Params */ tree_info = of_get_property(np, "spi-bus-num", NULL); if (tree_info) { gpio_pmodoled_dev->spi_id = be32_to_cpup((tree_info)); #ifdef CONFIG_PMODS_DEBUG printk(KERN_INFO DRIVER_NAME " %s: BUS_ID\t%x\n", np->name, gpio_pmodoled_dev->spi_id); #endif } /* Alloc Space for platform data structure */ gpio_pmodoled_pdata = (struct spi_gpio_platform_data *) kzalloc(sizeof(*gpio_pmodoled_pdata), GFP_KERNEL); if (!gpio_pmodoled_pdata) { status = -ENOMEM; goto pdata_alloc_err; } /* Fill up Platform Data Structure */ gpio_pmodoled_pdata->sck = gpio_pmodoled_dev->iSCLK; gpio_pmodoled_pdata->miso = SPI_GPIO_NO_MISO; gpio_pmodoled_pdata->mosi = gpio_pmodoled_dev->iSDIN; gpio_pmodoled_pdata->num_chipselect = 1; /* Alloc Space for platform data structure */ gpio_pmodoled_pdev = (struct platform_device *) kzalloc(sizeof(*gpio_pmodoled_pdev), GFP_KERNEL); if (!gpio_pmodoled_pdev) { status = -ENOMEM; goto pdev_alloc_err; } /* Fill up Platform Device Structure */ gpio_pmodoled_pdev->name = "spi_gpio"; gpio_pmodoled_pdev->id = gpio_pmodoled_dev->spi_id; gpio_pmodoled_pdev->dev.platform_data = gpio_pmodoled_pdata; gpio_pmodoled_dev->pdev = gpio_pmodoled_pdev; /* Register spi_gpio master */ status = platform_device_register(gpio_pmodoled_dev->pdev); if (status < 0) { dev_err(&pdev->dev, "platform_device_register failed: %d\n", status); goto pdev_reg_err; } #ifdef CONFIG_PMODS_DEBUG printk(KERN_INFO DRIVER_NAME " %s: spi_gpio platform device registered.\n", np->name); #endif gpio_pmodoled_dev->name = np->name; /* Fill up Board Info for SPI device */ status = add_gpio_pmodoled_device_to_bus(gpio_pmodoled_dev); if (status < 0) { dev_err(&pdev->dev, "add_gpio_pmodoled_device_to_bus failed: %d\n", status); goto spi_add_err; } #ifdef CONFIG_PMODS_DEBUG printk(KERN_INFO DRIVER_NAME " %s: spi device registered.\n", np->name); #endif /* Point device node data to gpio_pmodoled_device structure */ if (np->data == NULL) np->data = gpio_pmodoled_dev; if (gpio_pmodoled_dev_id == 0) { /* Alloc Major & Minor number for char device */ status = alloc_chrdev_region(&gpio_pmodoled_dev_id, 0, MAX_PMODOLED_GPIO_DEV_NUM, DRIVER_NAME); if (status) { dev_err(&pdev->dev, "Character device region not allocated correctly: %d\n", status); goto err_alloc_chrdev_region; } #ifdef CONFIG_PMODS_DEBUG printk(KERN_INFO DRIVER_NAME " : Char Device Region Registered, with Major: %d.\n", MAJOR(gpio_pmodoled_dev_id)); #endif } if (gpio_pmodoled_class == NULL) { /* Create Pmodoled-gpio Device Class */ gpio_pmodoled_class = class_create(THIS_MODULE, DRIVER_NAME); if (IS_ERR(gpio_pmodoled_class)) { status = PTR_ERR(gpio_pmodoled_class); goto err_create_class; } #ifdef CONFIG_PMODS_DEBUG printk(KERN_INFO DRIVER_NAME " : pmodoled_gpio device class registered.\n"); #endif } if (spi_drv_registered == 0) { /* Register SPI Driver for Pmodoled Device */ status = spi_register_driver(&gpio_pmodoled_spi_driver); if (status < 0) { dev_err(&pdev->dev, "gpio_pmodoled_spi_driver register failed: %d\n", status); goto err_spi_register; } spi_drv_registered = 1; } device_num++; return status; err_spi_register: class_destroy(gpio_pmodoled_class); gpio_pmodoled_class = NULL; err_create_class: unregister_chrdev_region(gpio_pmodoled_dev_id, MAX_PMODOLED_GPIO_DEV_NUM); gpio_pmodoled_dev_id = 0; err_alloc_chrdev_region: spi_unregister_device(gpio_pmodoled_dev->spi); spi_add_err: platform_device_unregister(gpio_pmodoled_dev->pdev); pdev_reg_err: kfree(gpio_pmodoled_pdev); pdev_alloc_err: kfree(gpio_pmodoled_pdata); pdata_alloc_err: kfree(gpio_pmodoled_dev->disp_buf); disp_buf_alloc_err: kfree(gpio_pmodoled_dev); dev_alloc_err: return status; }
/****************************** register spi device and attach it to Master driver ******************************/ static int reg_spi_device(void) { int retval = 0; struct spi_board_info spi_device_info = { .modalias = "nrf24l01+", .max_speed_hz = 5000000, .bus_num = 0, .chip_select = 1, .mode = 0, }; struct spi_master *master; master = spi_busnum_to_master(spi_device_info.bus_num); if(!master){ printk(KERN_ALERT "getting master device is failed!!\n"); retval = -ENODEV; goto out; } spi_device = spi_new_device(master,&spi_device_info); if(!spi_device){ printk(KERN_ALERT "registering spi device is failed!!\n"); retval = -ENODEV; goto out; } spi_device->bits_per_word = 8; retval = spi_setup(spi_device); if(retval){ spi_unregister_device(spi_device); goto out; } return 0; out: return retval; } /****************************** Module initialization function ******************************/ static int __init nrf_init(void) { int retval = 0; printk(KERN_INFO "hello from module!!\n"); retval = reg_dev(); if(retval != 0) goto out; retval = reg_spi_device(); if(retval != 0) goto out; radio_init(); return 0; out: return retval; }