err |= put_user(fix->smem_len, &fix32->smem_len);	err |= put_user(fix->type, &fix32->type);	err |= put_user(fix->type_aux, &fix32->type_aux);	err |= put_user(fix->visual, &fix32->visual);	err |= put_user(fix->xpanstep, &fix32->xpanstep);	err |= put_user(fix->ypanstep, &fix32->ypanstep);	err |= put_user(fix->ywrapstep, &fix32->ywrapstep);	err |= put_user(fix->line_length, &fix32->line_length);	data = (__u32) (unsigned long) fix->mmio_start;	err |= put_user(data, &fix32->mmio_start);	err |= put_user(fix->mmio_len, &fix32->mmio_len);	err |= put_user(fix->accel, &fix32->accel);	err |= copy_to_user(fix32->reserved, fix->reserved,			    sizeof(fix->reserved));	return err;}static int fb_get_fscreeninfo(struct inode *inode, struct file *file,				unsigned int cmd, unsigned long arg){	mm_segment_t old_fs;	struct fb_fix_screeninfo fix;	struct fb_fix_screeninfo32 __user *fix32;	int err;	fix32 = compat_ptr(arg);	old_fs = get_fs();	set_fs(KERNEL_DS);	err = fb_ioctl(inode, file, cmd, (unsigned long) &fix);	set_fs(old_fs);	if (!err)		err = do_fscreeninfo_to_user(&fix, fix32);	return err;}static longfb_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg){	struct inode *inode = file->f_path.dentry->d_inode;	int fbidx = iminor(inode);	struct fb_info *info = registered_fb[fbidx];	struct fb_ops *fb = info->fbops;	long ret = -ENOIOCTLCMD;	lock_kernel();	switch(cmd) {	case FBIOGET_VSCREENINFO:	case FBIOPUT_VSCREENINFO:	case FBIOPAN_DISPLAY:	case FBIOGET_CON2FBMAP:	case FBIOPUT_CON2FBMAP:		arg = (unsigned long) compat_ptr(arg);	case FBIOBLANK:		ret = fb_ioctl(inode, file, cmd, arg);		break;	case FBIOGET_FSCREENINFO:		ret = fb_get_fscreeninfo(inode, file, cmd, arg);		break;	case FBIOGETCMAP:	case FBIOPUTCMAP:		ret = fb_getput_cmap(inode, file, cmd, arg);		break;	default:		if (fb->fb_compat_ioctl)			ret = fb->fb_compat_ioctl(info, cmd, arg);		break;	}	unlock_kernel();	return ret;}#endifstatic int fb_mmap(struct file *file, struct vm_area_struct * vma){	int fbidx = iminor(file->f_path.dentry->d_inode);	struct fb_info *info = registered_fb[fbidx];	struct fb_ops *fb = info->fbops;	unsigned long off;#if !defined(__sparc__) || defined(__sparc_v9__)	unsigned long start;	u32 len;#endif	if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT))		return -EINVAL;	off = vma->vm_pgoff << PAGE_SHIFT;	if (!fb)		return -ENODEV;	if (fb->fb_mmap) {		int res;		lock_kernel();		res = fb->fb_mmap(info, vma);		unlock_kernel();		return res;	}#if defined(__sparc__) && !defined(__sparc_v9__)	/* Should never get here, all fb drivers should have their own	   mmap routines */	return -EINVAL;#else	/* !sparc32... */	lock_kernel();	/* frame buffer memory */	start = info->fix.smem_start;	len = PAGE_ALIGN((start & ~PAGE_MASK) + info->fix.smem_len);	if (off >= len) {		/* memory mapped io */		off -= len;		if (info->var.accel_flags) {			unlock_kernel();			return -EINVAL;		}		start = info->fix.mmio_start;		len = PAGE_ALIGN((start & ~PAGE_MASK) + info->fix.mmio_len);	}	unlock_kernel();	start &= PAGE_MASK;	if ((vma->vm_end - vma->vm_start + off) > len)		return -EINVAL;	off += start;	vma->vm_pgoff = off >> PAGE_SHIFT;	/* This is an IO map - tell maydump to skip this VMA */	vma->vm_flags |= VM_IO | VM_RESERVED;#if defined(__mc68000__)#if defined(CONFIG_SUN3)	pgprot_val(vma->vm_page_prot) |= SUN3_PAGE_NOCACHE;#elif defined(CONFIG_MMU)	if (CPU_IS_020_OR_030)		pgprot_val(vma->vm_page_prot) |= _PAGE_NOCACHE030;	if (CPU_IS_040_OR_060) {		pgprot_val(vma->vm_page_prot) &= _CACHEMASK040;		/* Use no-cache mode, serialized */		pgprot_val(vma->vm_page_prot) |= _PAGE_NOCACHE_S;	}#endif#elif defined(__powerpc__)	vma->vm_page_prot = phys_mem_access_prot(file, off >> PAGE_SHIFT,						 vma->vm_end - vma->vm_start,						 vma->vm_page_prot);#elif defined(__alpha__)	/* Caching is off in the I/O space quadrant by design.  */#elif defined(__i386__) || defined(__x86_64__)	if (boot_cpu_data.x86 > 3)		pgprot_val(vma->vm_page_prot) |= _PAGE_PCD;#elif defined(__mips__) || defined(__sparc_v9__)	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);#elif defined(__hppa__)	pgprot_val(vma->vm_page_prot) |= _PAGE_NO_CACHE;#elif defined(__arm__) || defined(__sh__) || defined(__m32r__)	vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);#elif defined(__avr32__)	vma->vm_page_prot = __pgprot((pgprot_val(vma->vm_page_prot)				      & ~_PAGE_CACHABLE)				     | (_PAGE_BUFFER | _PAGE_DIRTY));#elif defined(__ia64__)	if (efi_range_is_wc(vma->vm_start, vma->vm_end - vma->vm_start))		vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);	else		vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);#else#warning What do we have to do here??#endif	if (io_remap_pfn_range(vma, vma->vm_start, off >> PAGE_SHIFT,			     vma->vm_end - vma->vm_start, vma->vm_page_prot))		return -EAGAIN;	return 0;#endif /* !sparc32 */}static intfb_open(struct inode *inode, struct file *file){	int fbidx = iminor(inode);	struct fb_info *info;	int res = 0;	if (fbidx >= FB_MAX)		return -ENODEV;#ifdef CONFIG_KMOD	if (!(info = registered_fb[fbidx]))		try_to_load(fbidx);#endif /* CONFIG_KMOD */	if (!(info = registered_fb[fbidx]))		return -ENODEV;	if (!try_module_get(info->fbops->owner))		return -ENODEV;	file->private_data = info;	if (info->fbops->fb_open) {		res = info->fbops->fb_open(info,1);		if (res)			module_put(info->fbops->owner);	}	return res;}static int fb_release(struct inode *inode, struct file *file){	struct fb_info * const info = file->private_data;	lock_kernel();	if (info->fbops->fb_release)		info->fbops->fb_release(info,1);	module_put(info->fbops->owner);	unlock_kernel();	return 0;}static const struct file_operations fb_fops = {	.owner =	THIS_MODULE,	.read =		fb_read,	.write =	fb_write,	.ioctl =	fb_ioctl,#ifdef CONFIG_COMPAT	.compat_ioctl = fb_compat_ioctl,#endif	.mmap =		fb_mmap,	.open =		fb_open,	.release =	fb_release,#ifdef HAVE_ARCH_FB_UNMAPPED_AREA	.get_unmapped_area = get_fb_unmapped_area,#endif#ifdef CONFIG_FB_DEFERRED_IO	.fsync =	fb_deferred_io_fsync,#endif};struct class *fb_class;EXPORT_SYMBOL(fb_class);/** *	register_framebuffer - registers a frame buffer device *	@fb_info: frame buffer info structure * *	Registers a frame buffer device @fb_info. * *	Returns negative errno on error, or zero for success. * */intregister_framebuffer(struct fb_info *fb_info){	int i;	struct fb_event event;	struct fb_videomode mode;	if (num_registered_fb == FB_MAX)		return -ENXIO;	num_registered_fb++;	for (i = 0 ; i < FB_MAX; i++)		if (!registered_fb[i])			break;	fb_info->node = i;	fb_info->dev = device_create(fb_class, fb_info->device,				     MKDEV(FB_MAJOR, i), "fb%d", i);	if (IS_ERR(fb_info->dev)) {		/* Not fatal */		printk(KERN_WARNING "Unable to create device for framebuffer %d; errno = %ld\n", i, PTR_ERR(fb_info->dev));		fb_info->dev = NULL;	} else		fb_init_device(fb_info);	if (fb_info->pixmap.addr == NULL) {		fb_info->pixmap.addr = kmalloc(FBPIXMAPSIZE, GFP_KERNEL);		if (fb_info->pixmap.addr) {			fb_info->pixmap.size = FBPIXMAPSIZE;			fb_info->pixmap.buf_align = 1;			fb_info->pixmap.scan_align = 1;			fb_info->pixmap.access_align = 32;			fb_info->pixmap.flags = FB_PIXMAP_DEFAULT;		}	}		fb_info->pixmap.offset = 0;	if (!fb_info->pixmap.blit_x)		fb_info->pixmap.blit_x = ~(u32)0;	if (!fb_info->pixmap.blit_y)		fb_info->pixmap.blit_y = ~(u32)0;	if (!fb_info->modelist.prev || !fb_info->modelist.next)		INIT_LIST_HEAD(&fb_info->modelist);	fb_var_to_videomode(&mode, &fb_info->var);	fb_add_videomode(&mode, &fb_info->modelist);	registered_fb[i] = fb_info;	event.info = fb_info;	fb_notifier_call_chain(FB_EVENT_FB_REGISTERED, &event);	return 0;}/** *	unregister_framebuffer - releases a frame buffer device *	@fb_info: frame buffer info structure * *	Unregisters a frame buffer device @fb_info. * *	Returns negative errno on error, or zero for success. * */intunregister_framebuffer(struct fb_info *fb_info){	struct fb_event event;	int i;	i = fb_info->node;	if (!registered_fb[i])		return -EINVAL;	if (fb_info->pixmap.addr &&	    (fb_info->pixmap.flags & FB_PIXMAP_DEFAULT))		kfree(fb_info->pixmap.addr);	fb_destroy_modelist(&fb_info->modelist);	registered_fb[i]=NULL;	num_registered_fb--;	fb_cleanup_device(fb_info);	device_destroy(fb_class, MKDEV(FB_MAJOR, i));	event.info = fb_info;	fb_notifier_call_chain(FB_EVENT_FB_UNREGISTERED, &event);	return 0;}/** *	fb_set_suspend - low level driver signals suspend *	@info: framebuffer affected *	@state: 0 = resuming, !=0 = suspending * *	This is meant to be used by low level drivers to * 	signal suspend/resume to the core & clients. *	It must be called with the console semaphore held */void fb_set_suspend(struct fb_info *info, int state){	struct fb_event event;	event.info = info;	if (state) {		fb_notifier_call_chain(FB_EVENT_SUSPEND, &event);		info->state = FBINFO_STATE_SUSPENDED;	} else {		info->state = FBINFO_STATE_RUNNING;		fb_notifier_call_chain(FB_EVENT_RESUME, &event);	}}/** *	fbmem_init - init frame buffer subsystem * *	Initialize the frame buffer subsystem. * *	NOTE: This function is _only_ to be called by drivers/char/mem.c. * */static int __initfbmem_init(void){	create_proc_read_entry("fb", 0, NULL, fbmem_read_proc, NULL);	if (register_chrdev(FB_MAJOR,"fb",&fb_fops))		printk("unable to get major %d for fb devs\n", FB_MAJOR);	fb_class = class_create(THIS_MODULE, "graphics");	if (IS_ERR(fb_class)) {		printk(KERN_WARNING "Unable to create fb class; errno = %ld\n", PTR_ERR(fb_class));		fb_class = NULL;	}	return 0;}#ifdef MODULEmodule_init(fbmem_init);static void __exitfbmem_exit(void){	class_destroy(fb_class);	unregister_chrdev(FB_MAJOR, "fb");}module_exit(fbmem_exit);MODULE_LICENSE("GPL");MODULE_DESCRIPTION("Framebuffer base");#elsesubsys_initcall(fbmem_init);#endifint fb_new_modelist(struct fb_info *info){	struct fb_event event;	struct fb_var_screeninfo var = info->var;	struct list_head *pos, *n;	struct fb_modelist *modelist;	struct fb_videomode *m, mode;	int err = 1;	list_for_each_safe(pos, n, &info->modelist) {		modelist = list_entry(pos, struct fb_modelist, list);		m = &modelist->mode;		fb_videomode_to_var(&var, m);		var.activate = FB_ACTIVATE_TEST;		err = fb_set_var(info, &var);		fb_var_to_videomode(&mode, &var);		if (err || !fb_mode_is_equal(m, &mode)) {			list_del(pos);			kfree(pos);		}	}	err = 1;	if (!list_empty(&info->modelist)) {		event.info = info;		err = fb_notifier_call_chain(FB_EVENT_NEW_MODELIST, &event);	}	return err;}static char *video_options[FB_MAX] __read_mostly;static int ofonly __read_mostly;extern const char *global_mode_option;/** * fb_get_options - get kernel boot parameters * @name:   framebuffer name as it would appear in *          the boot parameter line *          (video=<name>:<options>) * @option: the option will be stored here * * NOTE: Needed to maintain backwards compatibility */int fb_get_options(char *name, char **option){	char *opt, *options = NULL;	int opt_len, retval = 0;	int name_len = strlen(name), i;	if (name_len && ofonly && strncmp(name, "offb", 4))		retval = 1;	if (name_len && !retval) {		for (i = 0; i < FB_MAX; i++) {			if (video_options[i] == NULL)				continue;			opt_len = strlen(video_options[i]);			if (!opt_len)				continue;			opt = video_options[i];			if (!strncmp(name, opt, name_len) &&			    opt[name_len] == ':')				options = opt + name_len + 1;		}	}	if (options && !strncmp(options, "off", 3))		retval = 1;	if (option)		*option = options;	return retval;}#ifndef MODULE/** *	video_setup - process command line options *	@options: string of options * *	Process command line options for frame buffer subsystem. * *	NOTE: This function is a __setup and __init function. *            It only stores the options.  Drivers have to call *            fb_get_options() as necessary. * *	Returns zero. * */static int __init video_setup(char *options){	int i, global = 0;	if (!options || !*options) 		global = 1; 	if (!global && !strncmp(options, "ofonly", 6)) { 		ofonly = 1; 		global = 1; 	} 	if (!global && !strstr(options, "fb:")) { 		global_mode_option = options; 		global = 1; 	} 	if (!global) { 		for (i = 0; i < FB_MAX; i++) { 			if (video_options[i] == NULL) { 				video_options[i] = options; 				break; 			}		}	}	return 1;}__setup("video=", video_setup);#endif    /*     *  Visible symbols for modules     */EXPORT_SYMBOL(register_framebuffer);EXPORT_SYMBOL(unregister_framebuffer);EXPORT_SYMBOL(num_registered_fb);EXPORT_SYMBOL(registered_fb);EXPORT_SYMBOL(fb_prepare_logo);EXPORT_SYMBOL(fb_show_logo);EXPORT_SYMBOL(fb_set_var);EXPORT_SYMBOL(fb_blank);EXPORT_SYMBOL(fb_pan_display);EXPORT_SYMBOL(fb_get_buffer_offset);EXPORT_SYMBOL(fb_set_suspend);EXPORT_SYMBOL(fb_get_options);MODULE_LICENSE("GPL");