static int aximx5_lcd_set_power (struct lcd_device *ld, int state) { struct mediaq11xx_base *mq_base = class_get_devdata (&ld->class_dev); int lcdfp_state = mq_base->get_power (mq_base, MEDIAQ_11XX_FP_DEVICE_ID) ? 1 : 0; int fpctl_state = mq_base->get_power (mq_base, MEDIAQ_11XX_FB_DEVICE_ID) ? 1 : 0; int new_lcdfp_state = (state < 1) ? 1 : 0; int new_fpctl_state = (state < 4) ? 1 : 0; debug_func ("state:%d\n", state); if (new_lcdfp_state != lcdfp_state) mq_base->set_power (mq_base, MEDIAQ_11XX_FP_DEVICE_ID, new_lcdfp_state); if (new_fpctl_state != fpctl_state) mq_base->set_power (mq_base, MEDIAQ_11XX_FB_DEVICE_ID, new_fpctl_state); if (new_lcdfp_state) /* MediaQ GPIO 1 seems connected to flat-panel power */ mq_base->set_GPIO (mq_base, GPIO_NR_AXIMX5_MQ1132_FP_ENABLE, MQ_GPIO_OUT1); else /* Output '0' to MQ1132 GPIO 1 */ mq_base->set_GPIO (mq_base, GPIO_NR_AXIMX5_MQ1132_FP_ENABLE, MQ_GPIO_OUT0); return 0; }
void radeonfb_bl_exit(struct radeonfb_info *rinfo) { #ifdef CONFIG_PMAC_BACKLIGHT mutex_lock(&pmac_backlight_mutex); #endif mutex_lock(&rinfo->info->bl_mutex); if (rinfo->info->bl_dev) { struct radeon_bl_privdata *pdata; #ifdef CONFIG_PMAC_BACKLIGHT if (pmac_backlight == rinfo->info->bl_dev) pmac_backlight = NULL; #endif pdata = class_get_devdata(&rinfo->info->bl_dev->class_dev); backlight_device_unregister(rinfo->info->bl_dev); kfree(pdata); rinfo->info->bl_dev = NULL; printk("radeonfb: Backlight unloaded\n"); } mutex_unlock(&rinfo->info->bl_mutex); #ifdef CONFIG_PMAC_BACKLIGHT mutex_unlock(&pmac_backlight_mutex); #endif }
static int aximx5_lcd_set_contrast (struct lcd_device *ld, int contrast) { struct mediaq11xx_base *mq_base = class_get_devdata (&ld->class_dev); u32 x; debug_func ("contrast:%d\n", contrast); /* Well... this is kind of tricky but here's how it works: * On 24-bit TFT panels the R,G,B channels are output via * the FD0..FD23 MQ1132' outputs. There are separate enable * bits for these pins in FP07R, which we will use. * Basically we just mask out (setting them to '1') * the lowest 1..8 bits of every color component thus * effectively reducing the number of bits for them. */ if (contrast > 7) contrast = 7; contrast = 7 ^ contrast; x = (1 << contrast) - 1; mq_base->regs->FP.pin_output_data |= 0x00ffffff; mq_base->regs->FP.pin_output_select_1 = (mq_base->regs->FP.pin_output_select_1 & 0xff000000) | x | (x << 8) | (x << 16); return 0; }
static inline u32 mcspi_read_reg(struct spi_master *master, int idx) { struct omap2_mcspi * mcspi = class_get_devdata(&master->cdev); return __raw_readl(mcspi->base + idx); }
static ssize_t omap_pwm_led_off_period_show(struct class_device *cdev, char *buf) { struct led_classdev *led_cdev = class_get_devdata(cdev); struct omap_pwm_led *led = cdev_to_omap_pwm_led(led_cdev); return sprintf(buf, "%u\n", led->off_period) + 1; }
static int __devinit pcmcia_bus_add_socket(struct class_device *class_dev, struct class_interface *class_intf) { struct pcmcia_socket *socket = class_get_devdata(class_dev); int ret; socket = pcmcia_get_socket(socket); if (!socket) { printk(KERN_ERR "PCMCIA obtaining reference to socket %p failed\n", socket); return -ENODEV; } /* * Ugly. But we want to wait for the socket threads to have started up. * We really should let the drivers themselves drive some of this.. */ msleep(250); #ifdef CONFIG_PCMCIA_IOCTL init_waitqueue_head(&socket->queue); #endif INIT_LIST_HEAD(&socket->devices_list); INIT_WORK(&socket->device_add, pcmcia_delayed_add_pseudo_device, socket); memset(&socket->pcmcia_state, 0, sizeof(u8)); socket->device_count = 0; ret = pccard_register_pcmcia(socket, &pcmcia_bus_callback); if (ret) { printk(KERN_ERR "PCMCIA registration PCCard core failed for socket %p\n", socket); pcmcia_put_socket(socket); return (ret); } return 0; }
static inline u32 mcspi_read_cs_reg(const struct spi_device *spi, int idx) { struct omap2_mcspi * mcspi = class_get_devdata(&spi->master->cdev); return __raw_readl(mcspi->base + spi->chip_select * 0x14 + idx); }
static inline void mcspi_write_cs_reg(const struct spi_device *spi, int idx, u32 val) { struct omap2_mcspi * mcspi = class_get_devdata(&spi->master->cdev); __raw_writel(val, mcspi->base + spi->chip_select * 0x14 + idx); }
static ssize_t store_mem_db(struct class_device *class_dev, const char *buf, size_t count) { struct pcmcia_socket *s = class_get_devdata(class_dev); unsigned long start_addr, end_addr; unsigned int add = ADD_MANAGED_RESOURCE; ssize_t ret = 0; ret = sscanf (buf, "+ 0x%lx - 0x%lx", &start_addr, &end_addr); if (ret != 2) { ret = sscanf (buf, "- 0x%lx - 0x%lx", &start_addr, &end_addr); add = REMOVE_MANAGED_RESOURCE; if (ret != 2) { ret = sscanf (buf, "0x%lx - 0x%lx", &start_addr, &end_addr); add = ADD_MANAGED_RESOURCE; if (ret != 2) return -EINVAL; } } if (end_addr < start_addr) return -EINVAL; ret = adjust_memory(s, add, start_addr, end_addr); if (!ret) s->resource_setup_new = 1; return ret ? ret : count; }
static inline void mcspi_write_reg(struct spi_master *master, int idx, u32 val) { struct omap2_mcspi * mcspi = class_get_devdata(&master->cdev); __raw_writel(val, mcspi->base + idx); }
static int roverp5p_backlight_get_power (struct backlight_device *bd) { struct mediaq11xx_base *mq_base = class_get_devdata (&bd->class_dev); debug_func ("\n"); return mq_base->get_GPIO (mq_base, 64) ? 0 : 4; }
static ssize_t led_delay_off_show(struct class_device *dev, char *buf) { struct led_classdev *led_cdev = class_get_devdata(dev); struct hwtimer_data *timer_data = led_cdev->trigger_data; sprintf(buf, "%lu\n", timer_data->delay_off); return strlen(buf) + 1; }
static void __devexit pccard_sysfs_remove_rsrc(struct class_device *class_dev) { struct pcmcia_socket *s = class_get_devdata(class_dev); struct class_device_attribute **attr; if (s->resource_ops != &pccard_nonstatic_ops) return; for (attr = pccard_rsrc_attributes; *attr; attr++) class_device_remove_file(class_dev, *attr); }
static ssize_t led_brightness_show(struct class_device *dev, char *buf) { struct led_classdev *led_cdev = class_get_devdata(dev); ssize_t ret = 0; /* no lock needed for this */ sprintf(buf, "%u\n", led_cdev->brightness); ret = strlen(buf) + 1; return ret; }
static ssize_t name_show(struct class_device *cdev, char *buf) { struct switch_dev *sdev = (struct switch_dev *) class_get_devdata(cdev); if (sdev->print_name) { int ret = sdev->print_name(sdev, buf); if (ret >= 0) return ret; } return sprintf(buf, "%s\n", sdev->name); }
static int aximx5_lcd_get_contrast (struct lcd_device *ld) { struct mediaq11xx_base *mq_base = class_get_devdata (&ld->class_dev); u32 c, x; debug_func ("\n"); x = (mq_base->regs->FP.pin_output_select_1 & 0x7f); for (c = 7; x; x >>= 1, c--) ; return c; }
static void pcmcia_bus_remove_socket(struct class_device *class_dev, struct class_interface *class_intf) { struct pcmcia_socket *socket = class_get_devdata(class_dev); if (!socket) return; socket->pcmcia_state.dead = 1; pccard_register_pcmcia(socket, NULL); pcmcia_put_socket(socket); return; }
static int aximx5_lcd_get_power (struct lcd_device *ld) { struct mediaq11xx_base *mq_base = class_get_devdata (&ld->class_dev); int lcdfp_state = mq_base->get_power (mq_base, MEDIAQ_11XX_FP_DEVICE_ID); int fpctl_state = mq_base->get_power (mq_base, MEDIAQ_11XX_FB_DEVICE_ID); debug_func ("\n"); if (lcdfp_state == 0) { if (fpctl_state == 0) return 4; else return 2; } return 0; }
static int __devinit pccard_sysfs_add_rsrc(struct class_device *class_dev) { struct pcmcia_socket *s = class_get_devdata(class_dev); struct class_device_attribute **attr; int ret = 0; if (s->resource_ops != &pccard_nonstatic_ops) return 0; for (attr = pccard_rsrc_attributes; *attr; attr++) { ret = class_device_create_file(class_dev, *attr); if (ret) break; } return ret; }
static int __devexit omap_rtc_remove(struct platform_device *pdev) { struct rtc_device *rtc = platform_get_drvdata(pdev);; device_init_wakeup(&pdev->dev, 0); /* leave rtc running, but disable irqs */ rtc_write(0, OMAP_RTC_INTERRUPTS_REG); free_irq(omap_rtc_timer, rtc); free_irq(omap_rtc_alarm, rtc); release_resource(class_get_devdata(&rtc->class_dev)); rtc_device_unregister(rtc); return 0; }
static ssize_t led_brightness_store(struct class_device *dev, const char *buf, size_t size) { struct led_classdev *led_cdev = class_get_devdata(dev); ssize_t ret = -EINVAL; char *after; unsigned long state = simple_strtoul(buf, &after, 10); size_t count = after - buf; if (*after && isspace(*after)) count++; if (count == size) { ret = count; led_set_brightness(led_cdev, state); } return ret; }
static void omap2_mcspi_txrx_dma(struct spi_device *spi, struct spi_transfer *xfer) { struct omap2_mcspi * mcspi; struct omap2_mcspi_cs * cs = spi->controller_state; struct omap2_mcspi_dma * mcspi_dma; unsigned int count, c; unsigned long base, tx_reg, rx_reg; int word_len, data_type, element_count; u8 * rx; const u8 * tx; u32 l; mcspi = class_get_devdata(&spi->master->cdev); mcspi_dma = &mcspi->dma_channels[spi->chip_select]; count = xfer->len; c = count; word_len = cs->word_len; l = mcspi_read_cs_reg(spi, OMAP2_MCSPI_CHCONF0); l &= ~OMAP2_MCSPI_CHCONF_TRM_MASK; if (xfer->tx_buf == NULL) l |= OMAP2_MCSPI_CHCONF_TRM_RX_ONLY; else if (xfer->rx_buf == NULL) l |= OMAP2_MCSPI_CHCONF_TRM_TX_ONLY; mcspi_write_cs_reg(spi, OMAP2_MCSPI_CHCONF0, l); omap2_mcspi_set_enable(spi, 1); base = io_v2p(mcspi->base) + spi->chip_select * 0x14; tx_reg = base + OMAP2_MCSPI_TX0; rx_reg = base + OMAP2_MCSPI_RX0; rx = xfer->rx_buf; tx = xfer->tx_buf; if (word_len <= 8) { data_type = OMAP_DMA_DATA_TYPE_S8; element_count = count; } else if (word_len <= 16) { data_type = OMAP_DMA_DATA_TYPE_S16; element_count = count >> 1; } else if (word_len <= 32) {
static int appledisplay_bl_get_brightness(struct backlight_device *bd) { struct appledisplay *pdata = class_get_devdata(&bd->class_dev); int retval; retval = usb_control_msg( pdata->udev, usb_rcvctrlpipe(pdata->udev, 0), USB_REQ_GET_REPORT, USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, ACD_USB_BRIGHTNESS, 0, pdata->msgdata, 2, ACD_USB_TIMEOUT); if (retval < 0) return retval; else return pdata->msgdata[1]; }
static int roverp5p_backlight_set_power (struct backlight_device *bd, int state) { struct mediaq11xx_base *mq_base = class_get_devdata (&bd->class_dev); debug_func ("state:%d\n", state); /* Turn off backlight power */ if (state == 0) { mq_base->set_GPIO (mq_base, 64, MQ_GPIO_IN | MQ_GPIO_OUT1); if (PWM_PWDUTY0 & 0x3ff) CKEN |= CKEN0_PWM0; else CKEN &= ~CKEN0_PWM0; } else { CKEN &= ~CKEN0_PWM0; mq_base->set_GPIO (mq_base, 64, MQ_GPIO_IN | MQ_GPIO_OUT0); } return 0; }
static ssize_t goldfish_switch_state_store(struct class_device *dev, const char *buf, size_t count) { struct goldfish_switch *qs = class_get_devdata(dev); uint32_t state; if (!(qs->flags & SW_FLAGS_OUTPUT)) return -EPERM; if (sscanf(buf, "%d", &state) != 1) return -EINVAL; writel(state, qs->base + SW_STATE); qs->state = readl(qs->base + SW_STATE); if(state != qs->state) return -EINVAL; return count; }
static int appledisplay_bl_update_status(struct backlight_device *bd) { struct appledisplay *pdata = class_get_devdata(&bd->class_dev); int retval; pdata->msgdata[0] = 0x10; pdata->msgdata[1] = bd->props->brightness; retval = usb_control_msg( pdata->udev, usb_sndctrlpipe(pdata->udev, 0), USB_REQ_SET_REPORT, USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE, ACD_USB_BRIGHTNESS, 0, pdata->msgdata, 2, ACD_USB_TIMEOUT); return retval; }
static ssize_t led_delay_on_store(struct class_device *dev, const char *buf, size_t size) { struct led_classdev *led_cdev = class_get_devdata(dev); struct timer_trig_data *timer_data = led_cdev->trigger_data; int ret = -EINVAL; char *after; unsigned long state = simple_strtoul(buf, &after, 10); size_t count = after - buf; if (*after && isspace(*after)) count++; if (count == size) { timer_data->delay_on = state; mod_timer(&timer_data->timer, jiffies + 1); ret = count; } return ret; }
static ssize_t show_mem_db(struct class_device *class_dev, char *buf) { struct pcmcia_socket *s = class_get_devdata(class_dev); struct socket_data *data; struct resource_map *p; ssize_t ret = 0; down(&rsrc_sem); data = s->resource_data; for (p = data->mem_db.next; p != &data->mem_db; p = p->next) { if (ret > (PAGE_SIZE - 10)) continue; ret += snprintf (&buf[ret], (PAGE_SIZE - ret - 1), "0x%08lx - 0x%08lx\n", ((unsigned long) p->base), ((unsigned long) p->base + p->num - 1)); } up(&rsrc_sem); return (ret); }
static ssize_t omap_pwm_led_off_period_store(struct class_device *cdev, const char *buf, size_t size) { struct led_classdev *led_cdev = class_get_devdata(cdev); struct omap_pwm_led *led = cdev_to_omap_pwm_led(led_cdev); int ret = -EINVAL; unsigned long val; char *after; size_t count; val = simple_strtoul(buf, &after, 10); count = after - buf; if (*after && isspace(*after)) count++; if (count == size) { led->off_period = val; omap_pwm_led_set_blink(led); ret = count; } return ret; }
static ssize_t led_delay_off_store(struct class_device *dev, const char *buf, size_t size) { struct led_classdev *led_cdev = class_get_devdata(dev); struct hwtimer_data *timer_data = led_cdev->trigger_data; int ret = -EINVAL; char *after; unsigned long state = simple_strtoul(buf, &after, 10); size_t count = after - buf; if (*after && isspace(*after)) count++; if (count == size) { timer_data->delay_off = state; if (!timer_data->delay_on || !timer_data->delay_off) led_set_brightness(led_cdev, LED_OFF); else led_set_brightness(led_cdev, LED_FULL); ret = count; } return ret; }