static void __exit gpio_exit(void) { #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) if (gpiodev_class != NULL) { #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 36) device_destroy(gpiodev_class, MKDEV(gpio_major, 0)); #else class_device_destroy(gpiodev_class, MKDEV(gpio_major, 0)); #endif class_destroy(gpiodev_class); } gpiodev_class = NULL; if (gpio_major >= 0) unregister_chrdev(gpio_major, "gpio"); #else if (gpiodev_handle != NULL) devfs_unregister(gpiodev_handle); gpiodev_handle = NULL; devfs_unregister_chrdev(gpio_major, "gpio"); #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) */ si_detach(gpio_sih); }
static void chd_dec_release_chdev(struct crystalhd_adp *adp) { struct crystalhd_ioctl_data *temp = NULL; if (!adp) return; if (adp->chd_dec_major > 0) { /* unregister crystalhd class */ device_destroy(crystalhd_class, MKDEV(adp->chd_dec_major, 0)); unregister_chrdev(adp->chd_dec_major, CRYSTALHD_API_NAME); BCMLOG(BCMLOG_INFO, "released api device - %d\n", adp->chd_dec_major); class_destroy(crystalhd_class); } adp->chd_dec_major = 0; /* Clear iodata pool.. */ do { temp = chd_dec_alloc_iodata(adp, 0); kfree(temp); } while (temp); crystalhd_delete_elem_pool(adp); }
static void mmapcall_exit(void) { unregister_chrdev(MMAPCALL_DEV_MAJOR, MMAPCALL_DEV_NAME); }
void __exit cpuid_exit(void) { unregister_chrdev(CPUID_MAJOR, "cpu/cpuid"); }
static void led_exit(void) { unregister_chrdev(LED_MAJOR, DEVICE_NAME); printk("led unregistered !!\n"); }
static __devinit int tspdrv_probe(struct platform_device *pdev) { struct vibrator_platform_data *pdata; int ret, i; /* initialized below */ DbgOut((KERN_INFO "tspdrv: tspdrv_probe.\n")); /* This condition will be removed,after all board files changes done */ if (pdev->dev.platform_data == NULL) { vibrator_drvdata.is_pmic_vib_en = 0; #if defined(CONFIG_MACH_M2_ATT) || defined(CONFIG_MACH_M2_VZW) || \ defined(CONFIG_MACH_M2_SPR) || defined(CONFIG_MACH_M2_DCM) || \ defined(CONFIG_MACH_M2_SKT) || defined(CONFIG_MACH_JAGUAR) || \ defined(CONFIG_MACH_AEGIS2) || defined(CONFIG_MACH_COMANCHE) vibrator_drvdata.vib_pwm_gpio = GPIO_VIB_PWM; vibrator_drvdata.vib_en_gpio = GPIO_VIB_ON; vibrator_drvdata.haptic_pwr_en_gpio = GPIO_HAPTIC_PWR_EN; vibrator_drvdata.vib_model = HAPTIC_PWM; #endif #if defined(CONFIG_MACH_APEXQ) || defined(CONFIG_MACH_JASPER) || \ defined(CONFIG_MACH_GOGH) || defined(CONFIG_MACH_ESPRESSO_ATT) vibrator_drvdata.vib_pwm_gpio = GPIO_MOTOR_EN; vibrator_drvdata.vib_en_gpio = GPIO_MOTOR_EN; vibrator_drvdata.haptic_pwr_en_gpio = GPIO_MOTOR_EN; vibrator_drvdata.vib_model = HAPTIC_MOTOR; #endif #ifdef CONFIG_MACH_M2_ATT if (system_rev >= BOARD_REV04) { vibrator_drvdata.vib_en_gpio = PM8921_GPIO_PM_TO_SYS(\ PMIC_GPIO_VIB_ON); vibrator_drvdata.is_pmic_vib_en = 1; } if (system_rev >= BOARD_REV08) { vibrator_drvdata.haptic_pwr_en_gpio = PM8921_GPIO_PM_TO_SYS(\ PMIC_GPIO_HAPTIC_PWR_EN); vibrator_drvdata.is_pmic_haptic_pwr_en = 1; } #endif #ifdef CONFIG_MACH_M2_VZW if (system_rev >= BOARD_REV09) { vibrator_drvdata.vib_en_gpio = PM8921_GPIO_PM_TO_SYS(\ PMIC_GPIO_VIB_ON); vibrator_drvdata.is_pmic_vib_en = 1; } #endif #ifdef CONFIG_MACH_M2_SPR if (system_rev >= BOARD_REV03) { vibrator_drvdata.vib_en_gpio = PM8921_GPIO_PM_TO_SYS(\ PMIC_GPIO_VIB_ON); vibrator_drvdata.is_pmic_vib_en = 1; } #endif #ifdef CONFIG_MACH_M2_DCM if (system_rev >= BOARD_REV01) { vibrator_drvdata.vib_en_gpio = PM8921_GPIO_PM_TO_SYS(\ PMIC_GPIO_VIB_ON); vibrator_drvdata.is_pmic_vib_en = 1; } #endif #ifdef CONFIG_MACH_AEGIS2 if (system_rev >= BOARD_REV01) { vibrator_drvdata.vib_en_gpio = PM8921_GPIO_PM_TO_SYS(\ PMIC_GPIO_VIB_ON); vibrator_drvdata.is_pmic_vib_en = 1; } #endif } else { pdata = pdev->dev.platform_data; vibrator_drvdata.vib_model = pdata->vib_model; vibrator_drvdata.is_pmic_haptic_pwr_en = \ pdata->is_pmic_haptic_pwr_en; if (pdata->is_pmic_haptic_pwr_en) vibrator_drvdata.haptic_pwr_en_gpio = \ PM8921_GPIO_PM_TO_SYS(pdata->haptic_pwr_en_gpio); else vibrator_drvdata.haptic_pwr_en_gpio = \ pdata->haptic_pwr_en_gpio; if (pdata->vib_model == HAPTIC_PWM) { vibrator_drvdata.vib_pwm_gpio = pdata->vib_pwm_gpio; vibrator_drvdata.is_pmic_vib_en = \ pdata->is_pmic_vib_en; if (pdata->is_pmic_vib_en) vibrator_drvdata.vib_en_gpio = \ PM8921_GPIO_PM_TO_SYS(pdata->vib_en_gpio); else vibrator_drvdata.vib_en_gpio = \ pdata->vib_en_gpio; } } #ifdef IMPLEMENT_AS_CHAR_DRIVER g_nmajor = register_chrdev(0, MODULE_NAME, &fops); if (g_nmajor < 0) { DbgOut((KERN_ERR "tspdrv: can't get major number.\n")); ret = g_nmajor; goto register_err; } #else ret = misc_register(&miscdev); if (ret) { DbgOut((KERN_ERR "tspdrv: misc_register failed.\n")); goto register_err; } #endif DbgRecorderInit(()); vibetonz_clk_on(&pdev->dev); ImmVibeSPI_ForceOut_Initialize(); VibeOSKernelLinuxInitTimer(); /* Get and concatenate device name and initialize data buffer */ g_cchdevice_name = 0; for (i = 0; i < NUM_ACTUATORS; i++) { char *szName = g_szdevice_name + g_cchdevice_name; ImmVibeSPI_Device_GetName(i, szName, VIBE_MAX_DEVICE_NAME_LENGTH); /* Append version information and get buffer length */ strncat(szName, VERSION_STR, sizeof(VERSION_STR)); g_cchdevice_name += strnlen(szName, sizeof(szName)); g_samples_buffer[i].nindex_playing_buffer = -1;/* Not playing */ g_samples_buffer[i].actuator_samples[0].nbuffer_size = 0; g_samples_buffer[i].actuator_samples[1].nbuffer_size = 0; } wake_lock_init(&vib_wake_lock, WAKE_LOCK_SUSPEND, "vib_present"); vibetonz_start(); return 0; register_err: #ifdef IMPLEMENT_AS_CHAR_DRIVER unregister_chrdev(g_nmajor, MODULE_NAME); #else misc_deregister(&miscdev); #endif return ret; }
void __timerbench_exit (void) { unregister_chrdev (TB_MAJOR, TB_DEVNAME); }
static void gib_dev_exit(void) { CRDEBUG; unregister_chrdev(GIB_MAJOR,"gib"); }
static void cdata_cleanup_module(void) { unregister_chrdev(121, "cdata"); }
void __exit yoda_char_dev_exit(void) { remove_proc_entry(DEVICE_NAME, NULL); unregister_chrdev(Major, DEVICE_NAME); printk(KERN_INFO "yoda_char_dev shutting down.\n"); }
static void __exit ioctl_exit(void) { unregister_chrdev(DEVICE_MAJOR, DEVICE_NAME); printk("rmmod %s\n", DEVICE_NAME); }
/*! * This function is called by the driver framework to initialize the LDB * device. * * @param dev The device structure for the LDB passed in by the * driver framework. * * @return Returns 0 on success or negative error code on error */ static int ldb_probe(struct platform_device *pdev) { int ret = 0, i, ipu_di, ipu_di_pix_fmt[2]; bool primary = false, find_1080p = false; struct resource *res; struct ldb_platform_data *plat_data = pdev->dev.platform_data; mm_segment_t old_fs; struct clk *ldb_clk_parent; unsigned long ldb_clk_prate = 455000000; struct fb_var_screeninfo *var[2]; uint32_t reg; struct device *temp; int mxc_ldb_major; const struct fb_videomode *mode; struct class *mxc_ldb_class; if (g_enable_ldb == false) return -ENODEV; spin_lock_init(&ldb_lock); g_ldb_dev = &pdev->dev; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (IS_ERR(res)) return -ENODEV; memset(&ldb, 0, sizeof(struct ldb_data)); enabled[0] = enabled[1] = false; var[0] = var[1] = NULL; if (g_boot_cmd) { ldb.chan_mode_opt = g_chan_mode_opt; ldb.chan_bit_map[0] = g_chan_bit_map[0]; ldb.chan_bit_map[1] = g_chan_bit_map[1]; } ldb.base_addr = res->start; ldb_reg = ioremap(ldb.base_addr, res->end - res->start + 1); ldb.control_reg = ldb_reg + 2; INIT_LIST_HEAD(&ldb.modelist); for (i = 0; i < mxcfb_ldb_modedb_sz; i++) fb_add_videomode(&mxcfb_ldb_modedb[i], &ldb.modelist); for (i = 0; i < num_registered_fb; i++) { if ((registered_fb[i]->var.sync & FB_SYNC_EXT) && (registered_fb[i]->var.vmode == FB_VMODE_NONINTERLACED)) { ldb.fbi[i] = registered_fb[i]; mode = fb_match_mode(&ldb.fbi[i]->var, &ldb.modelist); if (mode) { dev_dbg(g_ldb_dev, "fb mode found\n"); fb_videomode_to_var(&ldb.fbi[i]->var, mode); } else { dev_warn(g_ldb_dev, "can't find video mode\n"); goto err0; } /* * Default ldb mode: * 1080p: DI0 split, SPWG or DI1 split, SPWG * others: single, SPWG */ if (g_boot_cmd == false) { if (fb_mode_is_equal(mode, &mxcfb_ldb_modedb[0])) { if (strcmp(ldb.fbi[i]->fix.id, "DISP3 BG") == 0) { ldb.chan_mode_opt = LDB_SPL_DI0; dev_warn(g_ldb_dev, "default di0 split mode\n"); } else if (strcmp(ldb.fbi[i]->fix.id, "DISP3 BG - DI1") == 0) { ldb.chan_mode_opt = LDB_SPL_DI1; dev_warn(g_ldb_dev, "default di1 split mode\n"); } ldb.chan_bit_map[0] = LDB_BIT_MAP_SPWG; ldb.chan_bit_map[1] = LDB_BIT_MAP_SPWG; find_1080p = true; } else if (!find_1080p) { if (strcmp(ldb.fbi[i]->fix.id, "DISP3 BG") == 0) { ldb.chan_mode_opt = LDB_SIN_DI0; ldb.chan_bit_map[0] = LDB_BIT_MAP_SPWG; dev_warn(g_ldb_dev, "default di0 single mode\n"); } else if (strcmp(ldb.fbi[i]->fix.id, "DISP3 BG - DI1") == 0) { ldb.chan_mode_opt = LDB_SIN_DI1; ldb.chan_bit_map[1] = LDB_BIT_MAP_SPWG; dev_warn(g_ldb_dev, "default di1 single mode\n"); } } } acquire_console_sem(); fb_blank(ldb.fbi[i], FB_BLANK_POWERDOWN); release_console_sem(); if (i == 0) primary = true; if (ldb.fbi[1] != NULL) break; } } /* * We cannot support two LVDS panel with different pixel clock rates * except that one's pixel clock rate is two times of the others'. */ if (ldb.fbi[1] && ldb.fbi[0] != NULL) { if (ldb.fbi[0]->var.pixclock != ldb.fbi[1]->var.pixclock && ldb.fbi[0]->var.pixclock != 2 * ldb.fbi[1]->var.pixclock && ldb.fbi[1]->var.pixclock != 2 * ldb.fbi[0]->var.pixclock) return -EINVAL; } ldb.bgref_rmode = plat_data->ext_ref; ldb.lvds_bg_reg = regulator_get(&pdev->dev, plat_data->lvds_bg_reg); if (!IS_ERR(ldb.lvds_bg_reg)) { regulator_set_voltage(ldb.lvds_bg_reg, 2500000, 2500000); regulator_enable(ldb.lvds_bg_reg); } for (i = 0; i < 2; i++) { if (ldb.fbi[i] != NULL) { if (strcmp(ldb.fbi[i]->fix.id, "DISP3 BG") == 0) ipu_di = 0; else if (strcmp(ldb.fbi[i]->fix.id, "DISP3 BG - DI1") == 0) ipu_di = 1; else { dev_err(g_ldb_dev, "Wrong framebuffer\n"); goto err0; } var[ipu_di] = &ldb.fbi[i]->var; if (ldb.fbi[i]->fbops->fb_ioctl) { old_fs = get_fs(); set_fs(KERNEL_DS); ldb.fbi[i]->fbops->fb_ioctl(ldb.fbi[i], MXCFB_GET_DIFMT, (unsigned long)&(ipu_di_pix_fmt[ipu_di])); set_fs(old_fs); } else { dev_err(g_ldb_dev, "Can't get framebuffer " "information\n"); goto err0; } if (!valid_mode(ipu_di_pix_fmt[ipu_di])) { dev_err(g_ldb_dev, "Unsupport pixel format " "for ldb input\n"); goto err0; } reg = __raw_readl(ldb.control_reg); if (var[ipu_di]->sync & FB_SYNC_VERT_HIGH_ACT) { if (ipu_di == 0) __raw_writel((reg & ~LDB_DI0_VS_POL_MASK) | LDB_DI0_VS_POL_ACT_HIGH, ldb.control_reg); else __raw_writel((reg & ~LDB_DI1_VS_POL_MASK) | LDB_DI1_VS_POL_ACT_HIGH, ldb.control_reg); } else { if (ipu_di == 0) __raw_writel((reg & ~LDB_DI0_VS_POL_MASK) | LDB_DI0_VS_POL_ACT_LOW, ldb.control_reg); else __raw_writel((reg & ~LDB_DI1_VS_POL_MASK) | LDB_DI1_VS_POL_ACT_LOW, ldb.control_reg); } /* TODO:Set the correct pll4 rate for all situations */ if (ipu_di == 1) { ldb.ldb_di_clk[1] = clk_get(&pdev->dev, "ldb_di1_clk"); ldb_clk_parent = clk_get_parent(ldb.ldb_di_clk[1]); clk_set_rate(ldb_clk_parent, ldb_clk_prate); clk_put(ldb.ldb_di_clk[1]); } else { ldb.ldb_di_clk[0] = clk_get(&pdev->dev, "ldb_di0_clk"); ldb_clk_parent = clk_get_parent(ldb.ldb_di_clk[0]); clk_set_rate(ldb_clk_parent, ldb_clk_prate); clk_put(ldb.ldb_di_clk[0]); } } } reg = __raw_readl(ldb.control_reg); if (ldb.bgref_rmode == LDB_EXT_REF) __raw_writel((reg & ~LDB_BGREF_RMODE_MASK) | LDB_BGREF_RMODE_EXT, ldb.control_reg); else __raw_writel((reg & ~LDB_BGREF_RMODE_MASK) | LDB_BGREF_RMODE_INT, ldb.control_reg); switch (ldb.chan_mode_opt) { case LDB_SIN_DI0: if (var[0] == NULL) { dev_err(g_ldb_dev, "Can't find framebuffer on DI0\n"); break; } reg = __raw_readl(ldb.control_reg); if (bits_per_pixel(ipu_di_pix_fmt[0]) == 24) __raw_writel((reg & ~LDB_DATA_WIDTH_CH0_MASK) | LDB_DATA_WIDTH_CH0_24, ldb.control_reg); else if (bits_per_pixel(ipu_di_pix_fmt[0]) == 18) __raw_writel((reg & ~LDB_DATA_WIDTH_CH0_MASK) | LDB_DATA_WIDTH_CH0_18, ldb.control_reg); reg = __raw_readl(ldb.control_reg); if (ldb.chan_bit_map[0] == LDB_BIT_MAP_SPWG) __raw_writel((reg & ~LDB_BIT_MAP_CH0_MASK) | LDB_BIT_MAP_CH0_SPWG, ldb.control_reg); else __raw_writel((reg & ~LDB_BIT_MAP_CH0_MASK) | LDB_BIT_MAP_CH0_JEIDA, ldb.control_reg); ldb.ldb_di_clk[0] = clk_get(NULL, "ldb_di0_clk"); clk_set_rate(ldb.ldb_di_clk[0], ldb_clk_prate/7); clk_enable(ldb.ldb_di_clk[0]); clk_put(ldb.ldb_di_clk[0]); reg = __raw_readl(ldb.control_reg); __raw_writel((reg & ~LDB_CH0_MODE_MASK) | LDB_CH0_MODE_EN_TO_DI0, ldb.control_reg); ldb.ch_working[0] = true; break; case LDB_SIN_DI1: if (var[1] == NULL) { dev_err(g_ldb_dev, "Can't find framebuffer on DI1\n"); break; } reg = __raw_readl(ldb.control_reg); if (bits_per_pixel(ipu_di_pix_fmt[1]) == 24) __raw_writel((reg & ~LDB_DATA_WIDTH_CH1_MASK) | LDB_DATA_WIDTH_CH1_24, ldb.control_reg); else if (bits_per_pixel(ipu_di_pix_fmt[1]) == 18) __raw_writel((reg & ~LDB_DATA_WIDTH_CH1_MASK) | LDB_DATA_WIDTH_CH1_18, ldb.control_reg); reg = __raw_readl(ldb.control_reg); if (ldb.chan_bit_map[1] == LDB_BIT_MAP_SPWG) __raw_writel((reg & ~LDB_BIT_MAP_CH1_MASK) | LDB_BIT_MAP_CH1_SPWG, ldb.control_reg); else __raw_writel((reg & ~LDB_BIT_MAP_CH1_MASK) | LDB_BIT_MAP_CH1_JEIDA, ldb.control_reg); ldb.ldb_di_clk[1] = clk_get(NULL, "ldb_di1_clk"); clk_set_rate(ldb.ldb_di_clk[1], ldb_clk_prate/7); clk_enable(ldb.ldb_di_clk[1]); clk_put(ldb.ldb_di_clk[1]); reg = __raw_readl(ldb.control_reg); __raw_writel((reg & ~LDB_CH1_MODE_MASK) | LDB_CH1_MODE_EN_TO_DI1, ldb.control_reg); ldb.ch_working[1] = true; break; case LDB_SEP: if (var[0] == NULL || var[1] == NULL) { dev_err(g_ldb_dev, "Can't find framebuffers on DI0/1\n"); break; } reg = __raw_readl(ldb.control_reg); if (bits_per_pixel(ipu_di_pix_fmt[0]) == 24) __raw_writel((reg & ~LDB_DATA_WIDTH_CH0_MASK) | LDB_DATA_WIDTH_CH0_24, ldb.control_reg); else if (bits_per_pixel(ipu_di_pix_fmt[0]) == 18) __raw_writel((reg & ~LDB_DATA_WIDTH_CH0_MASK) | LDB_DATA_WIDTH_CH0_18, ldb.control_reg); reg = __raw_readl(ldb.control_reg); if (bits_per_pixel(ipu_di_pix_fmt[1]) == 24) __raw_writel((reg & ~LDB_DATA_WIDTH_CH1_MASK) | LDB_DATA_WIDTH_CH1_24, ldb.control_reg); else if (bits_per_pixel(ipu_di_pix_fmt[1]) == 18) __raw_writel((reg & ~LDB_DATA_WIDTH_CH1_MASK) | LDB_DATA_WIDTH_CH1_18, ldb.control_reg); reg = __raw_readl(ldb.control_reg); if (ldb.chan_bit_map[0] == LDB_BIT_MAP_SPWG) __raw_writel((reg & ~LDB_BIT_MAP_CH0_MASK) | LDB_BIT_MAP_CH0_SPWG, ldb.control_reg); else __raw_writel((reg & ~LDB_BIT_MAP_CH0_MASK) | LDB_BIT_MAP_CH0_JEIDA, ldb.control_reg); reg = __raw_readl(ldb.control_reg); if (ldb.chan_bit_map[1] == LDB_BIT_MAP_SPWG) __raw_writel((reg & ~LDB_BIT_MAP_CH1_MASK) | LDB_BIT_MAP_CH1_SPWG, ldb.control_reg); else __raw_writel((reg & ~LDB_BIT_MAP_CH1_MASK) | LDB_BIT_MAP_CH1_JEIDA, ldb.control_reg); ldb.ldb_di_clk[0] = clk_get(NULL, "ldb_di0_clk"); clk_set_rate(ldb.ldb_di_clk[0], ldb_clk_prate/7); clk_enable(ldb.ldb_di_clk[0]); clk_put(ldb.ldb_di_clk[0]); ldb.ldb_di_clk[1] = clk_get(NULL, "ldb_di1_clk"); clk_set_rate(ldb.ldb_di_clk[1], ldb_clk_prate/7); clk_enable(ldb.ldb_di_clk[1]); clk_put(ldb.ldb_di_clk[1]); reg = __raw_readl(ldb.control_reg); __raw_writel((reg & ~(LDB_CH0_MODE_MASK | LDB_CH1_MODE_MASK)) | LDB_CH0_MODE_EN_TO_DI0 | LDB_CH1_MODE_EN_TO_DI1, ldb.control_reg); ldb.ch_working[0] = true; ldb.ch_working[1] = true; break; case LDB_DUL_DI0: case LDB_SPL_DI0: if (var[0] == NULL) { dev_err(g_ldb_dev, "Can't find framebuffer on DI0\n"); break; } reg = __raw_readl(ldb.control_reg); if (bits_per_pixel(ipu_di_pix_fmt[0]) == 24) __raw_writel((reg & ~(LDB_DATA_WIDTH_CH0_MASK | LDB_DATA_WIDTH_CH1_MASK)) | LDB_DATA_WIDTH_CH0_24 | LDB_DATA_WIDTH_CH1_24, ldb.control_reg); else if (bits_per_pixel(ipu_di_pix_fmt[0]) == 18) __raw_writel((reg & ~(LDB_DATA_WIDTH_CH0_MASK | LDB_DATA_WIDTH_CH1_MASK)) | LDB_DATA_WIDTH_CH0_18 | LDB_DATA_WIDTH_CH1_18, ldb.control_reg); reg = __raw_readl(ldb.control_reg); if (ldb.chan_bit_map[0] == LDB_BIT_MAP_SPWG) __raw_writel((reg & ~LDB_BIT_MAP_CH0_MASK) | LDB_BIT_MAP_CH0_SPWG, ldb.control_reg); else __raw_writel((reg & ~LDB_BIT_MAP_CH0_MASK) | LDB_BIT_MAP_CH0_JEIDA, ldb.control_reg); reg = __raw_readl(ldb.control_reg); if (ldb.chan_bit_map[1] == LDB_BIT_MAP_SPWG) __raw_writel((reg & ~LDB_BIT_MAP_CH1_MASK) | LDB_BIT_MAP_CH1_SPWG, ldb.control_reg); else __raw_writel((reg & ~LDB_BIT_MAP_CH1_MASK) | LDB_BIT_MAP_CH1_JEIDA, ldb.control_reg); reg = __raw_readl(ldb.control_reg); if (ldb.chan_mode_opt == LDB_SPL_DI0) __raw_writel(reg | LDB_SPLIT_MODE_EN, ldb.control_reg); ldb.ldb_di_clk[0] = clk_get(NULL, "ldb_di0_clk"); ldb.ldb_di_clk[1] = clk_get(NULL, "ldb_di1_clk"); if (ldb.chan_mode_opt == LDB_DUL_DI0) { clk_set_rate(ldb.ldb_di_clk[0], ldb_clk_prate/7); } else { clk_set_rate(ldb.ldb_di_clk[0], 2*ldb_clk_prate/7); clk_set_rate(ldb.ldb_di_clk[1], 2*ldb_clk_prate/7); } clk_enable(ldb.ldb_di_clk[0]); clk_enable(ldb.ldb_di_clk[1]); clk_put(ldb.ldb_di_clk[0]); clk_put(ldb.ldb_di_clk[1]); reg = __raw_readl(ldb.control_reg); __raw_writel((reg & ~(LDB_CH0_MODE_MASK | LDB_CH1_MODE_MASK)) | LDB_CH0_MODE_EN_TO_DI0 | LDB_CH1_MODE_EN_TO_DI0, ldb.control_reg); ldb.ch_working[0] = true; ldb.ch_working[1] = true; break; case LDB_DUL_DI1: case LDB_SPL_DI1: if (var[1] == NULL) { dev_err(g_ldb_dev, "Can't find framebuffer on DI1\n"); break; } reg = __raw_readl(ldb.control_reg); if (bits_per_pixel(ipu_di_pix_fmt[1]) == 24) __raw_writel((reg & ~(LDB_DATA_WIDTH_CH0_MASK | LDB_DATA_WIDTH_CH1_MASK)) | LDB_DATA_WIDTH_CH0_24 | LDB_DATA_WIDTH_CH1_24, ldb.control_reg); else if (bits_per_pixel(ipu_di_pix_fmt[1]) == 18) __raw_writel((reg & ~(LDB_DATA_WIDTH_CH0_MASK | LDB_DATA_WIDTH_CH1_MASK)) | LDB_DATA_WIDTH_CH0_18 | LDB_DATA_WIDTH_CH1_18, ldb.control_reg); reg = __raw_readl(ldb.control_reg); if (ldb.chan_bit_map[0] == LDB_BIT_MAP_SPWG) __raw_writel((reg & ~LDB_BIT_MAP_CH0_MASK) | LDB_BIT_MAP_CH0_SPWG, ldb.control_reg); else __raw_writel((reg & ~LDB_BIT_MAP_CH0_MASK) | LDB_BIT_MAP_CH0_JEIDA, ldb.control_reg); reg = __raw_readl(ldb.control_reg); if (ldb.chan_bit_map[1] == LDB_BIT_MAP_SPWG) __raw_writel((reg & ~LDB_BIT_MAP_CH1_MASK) | LDB_BIT_MAP_CH1_SPWG, ldb.control_reg); else __raw_writel((reg & ~LDB_BIT_MAP_CH1_MASK) | LDB_BIT_MAP_CH1_JEIDA, ldb.control_reg); reg = __raw_readl(ldb.control_reg); if (ldb.chan_mode_opt == LDB_SPL_DI1) __raw_writel(reg | LDB_SPLIT_MODE_EN, ldb.control_reg); ldb.ldb_di_clk[0] = clk_get(NULL, "ldb_di0_clk"); ldb.ldb_di_clk[1] = clk_get(NULL, "ldb_di1_clk"); if (ldb.chan_mode_opt == LDB_DUL_DI1) { clk_set_rate(ldb.ldb_di_clk[1], ldb_clk_prate/7); } else { clk_set_rate(ldb.ldb_di_clk[0], 2*ldb_clk_prate/7); clk_set_rate(ldb.ldb_di_clk[1], 2*ldb_clk_prate/7); } clk_enable(ldb.ldb_di_clk[0]); clk_enable(ldb.ldb_di_clk[1]); clk_put(ldb.ldb_di_clk[0]); clk_put(ldb.ldb_di_clk[1]); reg = __raw_readl(ldb.control_reg); __raw_writel((reg & ~(LDB_CH0_MODE_MASK | LDB_CH1_MODE_MASK)) | LDB_CH0_MODE_EN_TO_DI1 | LDB_CH1_MODE_EN_TO_DI1, ldb.control_reg); ldb.ch_working[0] = true; ldb.ch_working[1] = true; break; default: break; } mxc_ldb_major = register_chrdev(0, "mxc_ldb", &mxc_ldb_fops); if (mxc_ldb_major < 0) { dev_err(g_ldb_dev, "Unable to register MXC LDB as a char " "device\n"); ret = mxc_ldb_major; goto err0; } mxc_ldb_class = class_create(THIS_MODULE, "mxc_ldb"); if (IS_ERR(mxc_ldb_class)) { dev_err(g_ldb_dev, "Unable to create class for MXC LDB\n"); ret = PTR_ERR(mxc_ldb_class); goto err1; } temp = device_create(mxc_ldb_class, NULL, MKDEV(mxc_ldb_major, 0), NULL, "mxc_ldb"); if (IS_ERR(temp)) { dev_err(g_ldb_dev, "Unable to create class device for " "MXC LDB\n"); ret = PTR_ERR(temp); goto err2; } ret = fb_register_client(&nb); if (ret < 0) goto err2; if (primary && ldb.fbi[0] != NULL) { acquire_console_sem(); fb_blank(ldb.fbi[0], FB_BLANK_UNBLANK); release_console_sem(); fb_show_logo(ldb.fbi[0], 0); } return ret; err2: class_destroy(mxc_ldb_class); err1: unregister_chrdev(mxc_ldb_major, "mxc_ldb"); err0: iounmap(ldb_reg); return ret; }
void mydrv_cleanup(void) { kfree(mydrv_data); unregister_chrdev(MYDRV_MAJOR, DEVICE_NAME); }
static void __exit alsa_sound_exit(void) { snd_info_minor_unregister(); snd_info_done(); unregister_chrdev(major, "alsa"); }
static void cdata_cleanup_module(void) { unregister_chrdev(DEV_MAJOR, DEV_NAME); printk(KERN_INFO "(Ivan Lee)CDATA.ko cleanup.\n"); }
static void modem_exit(void) { printk("Modem_exit..."); sysfs_remove_group(&modem->dev.kobj, &modem_attr_grp); unregister_chrdev(MODEM_MAJOR, MODEM_DRIVER); }
void cleanup_module(void) { unregister_chrdev(Major, DEVICE_NAME); }
static int simple_char_driver_exit(void) { printk(KERN_ALERT "Exiting %s function\n",__FUNCTION__); //Print unregister_chrdev(MAJORNUMBER, "simple_char_driver"); //Unregister return 0; }
static void __exit end_mod(void){ unregister_chrdev(22, "ppio"); printk("Modulo1 ended...\n"); }
static int __init mydriver_module_init(void) { int ret; mydriver_major=register_chrdev(0, DEVICE_NAME, &mydriver_fops); if (mydriver_major < 0){ printk("failed to register device.\n"); return -1; } mydriver_class = class_create(THIS_MODULE, CLASS_NAME); if (IS_ERR(mydriver_class)){ printk("failed to create device class.\n"); unregister_chrdev(mydriver_major, DEVICE_NAME); return -1; } mydriver_device = device_create(mydriver_class, NULL, MKDEV(mydriver_major, 0), NULL, DEVICE_NAME); if (IS_ERR(mydriver_device)){ printk("failed to create device .\n"); unregister_chrdev(mydriver_major, DEVICE_NAME); return -1; } ret = device_create_file(mydriver_device, &dev_attr_direction1); if (ret < 0) printk("failed to create /sys endpoint"); ret = device_create_file(mydriver_device, &dev_attr_direction2); if (ret < 0) printk("failed to create /sys endpoint"); ret = device_create_file(mydriver_device, &dev_attr_direction3); if (ret < 0) printk("failed to create /sys endpoint"); ret = device_create_file(mydriver_device, &dev_attr_direction4); if (ret < 0) printk("failed to create /sys endpoint"); ret = device_create_file(mydriver_device, &dev_attr_pwm1_speed); if (ret < 0) printk("failed to create /sys endpoint"); ret = device_create_file(mydriver_device, &dev_attr_pwm2_speed); if (ret < 0) printk("failed to create /sys endpoint"); ret = device_create_file(mydriver_device, &dev_attr_pwm3_speed); if (ret < 0) printk("failed to create /sys endpoint"); ret = device_create_file(mydriver_device, &dev_attr_pwm4_speed); if (ret < 0) printk("failed to create /sys endpoint"); mypwm_addr = (unsigned long)ioremap(PWM_PHY_ADDR, sizeof(u32)); printk("my pwm driver initial successfully!\n"); return 0; }
/* * @brief: agv_cleanup_dev - 注销字符设备 */ void agv_cleanup_dev(void) { unregister_chrdev(s_agv_dev_major, AGV_DEV_PATH); }
void sample_cleanup(void){ // kfree(buffer); printk("Unregistration Character Device to Kernel\n"); unregister_chrdev(CHR_DEV_MAJOR, CHR_DEV_NAME); }
static void divas_maint_unregister_chrdev(void) { unregister_chrdev(major, DEVNAME); }
static void device_exit(void) { unregister_chrdev(200, DEVICE_NAME); printk(KERN_ALERT "Calc module is unloaded!\n"); }
static void __exit telephony_exit(void) { unregister_chrdev(PHONE_MAJOR, "telephony"); }
void my_cleanup_module(void) { unregister_chrdev(CDATA_MAJOR, "cdata"); printk(KERN_ALERT "cdata module: unregisterd.\n"); }
static void __exit xz_dec_test_exit(void) { unregister_chrdev(device_major, DEVICE_NAME); xz_dec_end(state); printk(KERN_INFO DEVICE_NAME ": module unloaded\n"); }
static void divas_maint_unregister_chrdev(void) { devfs_remove(DEVNAME); unregister_chrdev(major, DEVNAME); }
static void __exit dram_exit( void ) { unregister_chrdev( my_major, modname ); printk( "<1>Removing \'%s\' module\n", modname ); }
void __exit pcf8563_exit(void) { unregister_chrdev(PCF8563_MAJOR, DEVICE_NAME); }