自学教程：C++ EXPORT_SYMBOL_GPL函数代码示例

int hns_roce_alloc_pd(struct ib_pd *ibpd, struct ib_ucontext *context,		      struct ib_udata *udata){	struct ib_device *ib_dev = ibpd->device;	struct hns_roce_dev *hr_dev = to_hr_dev(ib_dev);	struct device *dev = hr_dev->dev;	struct hns_roce_pd *pd = to_hr_pd(ibpd);	int ret;	ret = hns_roce_pd_alloc(to_hr_dev(ib_dev), &pd->pdn);	if (ret) {		dev_err(dev, "[alloc_pd]hns_roce_pd_alloc failed!/n");		return ret;	}	if (context) {		struct hns_roce_ib_alloc_pd_resp uresp = {.pdn = pd->pdn};		if (ib_copy_to_udata(udata, &uresp, sizeof(uresp))) {			hns_roce_pd_free(to_hr_dev(ib_dev), pd->pdn);			dev_err(dev, "[alloc_pd]ib_copy_to_udata failed!/n");			return -EFAULT;		}	}	return 0;}EXPORT_SYMBOL_GPL(hns_roce_alloc_pd);void hns_roce_dealloc_pd(struct ib_pd *pd){	hns_roce_pd_free(to_hr_dev(pd->device), to_hr_pd(pd)->pdn);}

/* * Set up a pNFS Data Server client over NFSv3. * * Return any existing nfs_client that matches server address,port,version * and minorversion. * * For a new nfs_client, use a soft mount (default), a low retrans and a * low timeout interval so that if a connection is lost, we retry through * the MDS. */struct nfs_client *nfs3_set_ds_client(struct nfs_server *mds_srv,		const struct sockaddr *ds_addr, int ds_addrlen,		int ds_proto, unsigned int ds_timeo, unsigned int ds_retrans){	struct rpc_timeout ds_timeout;	struct nfs_client *mds_clp = mds_srv->nfs_client;	struct nfs_client_initdata cl_init = {		.addr = ds_addr,		.addrlen = ds_addrlen,		.nodename = mds_clp->cl_rpcclient->cl_nodename,		.ip_addr = mds_clp->cl_ipaddr,		.nfs_mod = &nfs_v3,		.proto = ds_proto,		.net = mds_clp->cl_net,		.timeparms = &ds_timeout,		.cred = mds_srv->cred,	};	struct nfs_client *clp;	char buf[INET6_ADDRSTRLEN + 1];	/* fake a hostname because lockd wants it */	if (rpc_ntop(ds_addr, buf, sizeof(buf)) <= 0)		return ERR_PTR(-EINVAL);	cl_init.hostname = buf;	if (mds_srv->flags & NFS_MOUNT_NORESVPORT)		set_bit(NFS_CS_NORESVPORT, &cl_init.init_flags);	/* Use the MDS nfs_client cl_ipaddr. */	nfs_init_timeout_values(&ds_timeout, ds_proto, ds_timeo, ds_retrans);	clp = nfs_get_client(&cl_init);	return clp;}EXPORT_SYMBOL_GPL(nfs3_set_ds_client);

void gcore_input_report_key(struct gcore_data *gdata, int scancode, int value){	struct input_dev *idev = gdata->input_dev;	int error;	struct input_keymap_entry ke = {		.flags	  = 0,		.len	  = sizeof(scancode),	};	*((int *) ke.scancode) = scancode;	error = input_get_keycode(idev, &ke);	if (!error && ke.keycode != KEY_UNKNOWN && ke.keycode != KEY_RESERVED) {		/* Only report mapped keys */		input_report_key(idev, ke.keycode, value);	} else if (!!value) {		/* Or report MSC_SCAN on keypress of an unmapped key */		input_event(idev, EV_MSC, MSC_SCAN, scancode);	}}EXPORT_SYMBOL_GPL(gcore_input_report_key);void gcore_input_remove(struct gcore_data *gdata){	input_unregister_device(gdata->input_dev);	kfree(gdata->input_dev->keycode);}

/** * dax_zero_page_range - zero a range within a page of a DAX file * @inode: The file being truncated * @from: The file offset that is being truncated to * @length: The number of bytes to zero * @get_block: The filesystem method used to translate file offsets to blocks * * This function can be called by a filesystem when it is zeroing part of a * page in a DAX file.  This is intended for hole-punch operations.  If * you are truncating a file, the helper function dax_truncate_page() may be * more convenient. * * We work in terms of PAGE_SIZE here for commonality with * block_truncate_page(), but we could go down to PAGE_SIZE if the filesystem * took care of disposing of the unnecessary blocks.  Even if the filesystem * block size is smaller than PAGE_SIZE, we have to zero the rest of the page * since the file might be mmapped. */int dax_zero_page_range(struct inode *inode, loff_t from, unsigned length,							get_block_t get_block){	struct buffer_head bh;	pgoff_t index = from >> PAGE_SHIFT;	unsigned offset = from & (PAGE_SIZE-1);	int err;	/* Block boundary? Nothing to do */	if (!length)		return 0;	BUG_ON((offset + length) > PAGE_SIZE);	memset(&bh, 0, sizeof(bh));	bh.b_bdev = inode->i_sb->s_bdev;	bh.b_size = PAGE_SIZE;	err = get_block(inode, index, &bh, 0);	if (err < 0)		return err;	if (buffer_written(&bh)) {		struct block_device *bdev = bh.b_bdev;		struct blk_dax_ctl dax = {			.sector = to_sector(&bh, inode),			.size = PAGE_SIZE,		};		if (dax_map_atomic(bdev, &dax) < 0)			return PTR_ERR(dax.addr);		clear_pmem(dax.addr + offset, length);		wmb_pmem();		dax_unmap_atomic(bdev, &dax);	}	return 0;}EXPORT_SYMBOL_GPL(dax_zero_page_range);/** * dax_truncate_page - handle a partial page being truncated in a DAX file * @inode: The file being truncated * @from: The file offset that is being truncated to * @get_block: The filesystem method used to translate file offsets to blocks * * Similar to block_truncate_page(), this function can be called by a * filesystem when it is truncating a DAX file to handle the partial page. * * We work in terms of PAGE_SIZE here for commonality with * block_truncate_page(), but we could go down to PAGE_SIZE if the filesystem * took care of disposing of the unnecessary blocks.  Even if the filesystem * block size is smaller than PAGE_SIZE, we have to zero the rest of the page * since the file might be mmapped. */int dax_truncate_page(struct inode *inode, loff_t from, get_block_t get_block){	unsigned length = PAGE_ALIGN(from) - from;	return dax_zero_page_range(inode, from, length, get_block);}

/** * ad_sd_write_reg() - Write a register * * @sigma_delta: The sigma delta device * @reg: Address of the register * @size: Size of the register (0-3) * @val: Value to write to the register * * Returns 0 on success, an error code otherwise. **/int ad_sd_write_reg(struct ad_sigma_delta *sigma_delta, unsigned int reg,	unsigned int size, unsigned int val){	uint8_t *data = sigma_delta->data;	struct spi_transfer t = {		.tx_buf		= data,		.len		= size + 1,		.cs_change	= sigma_delta->bus_locked,	};	struct spi_message m;	int ret;	data[0] = (reg << sigma_delta->info->addr_shift) | sigma_delta->comm;	switch (size) {	case 3:		data[1] = val >> 16;		data[2] = val >> 8;		data[3] = val;		break;	case 2:		put_unaligned_be16(val, &data[1]);		break;	case 1:		data[1] = val;		break;	case 0:		break;	default:		return -EINVAL;	}	spi_message_init(&m);	spi_message_add_tail(&t, &m);	if (sigma_delta->bus_locked)		ret = spi_sync_locked(sigma_delta->spi, &m);	else		ret = spi_sync(sigma_delta->spi, &m);	return ret;}EXPORT_SYMBOL_GPL(ad_sd_write_reg);static int ad_sd_read_reg_raw(struct ad_sigma_delta *sigma_delta,	unsigned int reg, unsigned int size, uint8_t *val){	uint8_t *data = sigma_delta->data;	int ret;	struct spi_transfer t[] = {		{			.tx_buf = data,			.len = 1,		}, {			.rx_buf = val,

int rave_sp_exec(struct rave_sp *sp,		 void *__data,  size_t data_size,		 void *reply_data, size_t reply_data_size){	struct rave_sp_reply reply = {		.data     = reply_data,		.length   = reply_data_size,		.received = COMPLETION_INITIALIZER_ONSTACK(reply.received),	};	unsigned char *data = __data;	int command, ret = 0;	u8 ackid;	command = sp->variant->cmd.translate(data[0]);	if (command < 0)		return command;	ackid       = atomic_inc_return(&sp->ackid);	reply.ackid = ackid;	reply.code  = rave_sp_reply_code((u8)command),	mutex_lock(&sp->bus_lock);	mutex_lock(&sp->reply_lock);	sp->reply = &reply;	mutex_unlock(&sp->reply_lock);	data[0] = command;	data[1] = ackid;	rave_sp_write(sp, data, data_size);	if (!wait_for_completion_timeout(&reply.received, HZ)) {		dev_err(&sp->serdev->dev, "Command timeout/n");		ret = -ETIMEDOUT;		mutex_lock(&sp->reply_lock);		sp->reply = NULL;		mutex_unlock(&sp->reply_lock);	}	mutex_unlock(&sp->bus_lock);	return ret;}EXPORT_SYMBOL_GPL(rave_sp_exec);static void rave_sp_receive_event(struct rave_sp *sp,				  const unsigned char *data, size_t length){	u8 cmd[] = {		[0] = rave_sp_reply_code(data[0]),		[1] = data[1],	};

void save_stack_trace_tsk(struct task_struct *task, struct stack_trace *trace){	struct stack_trace_data trace_data = {		.trace = trace,		.skip = trace->skip,	};	walk_stackframe(stack_pointer(task), stack_trace_cb, &trace_data);}EXPORT_SYMBOL_GPL(save_stack_trace_tsk);void save_stack_trace(struct stack_trace *trace){	save_stack_trace_tsk(current, trace);}

/** * nfs_do_submount - set up mountpoint when crossing a filesystem boundary * @dentry - parent directory * @fh - filehandle for new root dentry * @fattr - attributes for new root inode * @authflavor - security flavor to use when performing the mount * */struct vfsmount *nfs_do_submount(struct dentry *dentry, struct nfs_fh *fh,				 struct nfs_fattr *fattr, rpc_authflavor_t authflavor){	struct nfs_clone_mount mountdata = {		.sb = dentry->d_sb,		.dentry = dentry,		.fh = fh,		.fattr = fattr,		.authflavor = authflavor,	};	struct vfsmount *mnt = ERR_PTR(-ENOMEM);	char *page = (char *) __get_free_page(GFP_USER);	char *devname;	dprintk("--> nfs_do_submount()/n");	dprintk("%s: submounting on %s/%s/n", __func__,			dentry->d_parent->d_name.name,			dentry->d_name.name);	if (page == NULL)		goto out;	devname = nfs_devname(dentry, page, PAGE_SIZE);	mnt = (struct vfsmount *)devname;	if (IS_ERR(devname))		goto free_page;	mnt = nfs_do_clone_mount(NFS_SB(dentry->d_sb), devname, &mountdata);free_page:	free_page((unsigned long)page);out:	dprintk("%s: done/n", __func__);	dprintk("<-- nfs_do_submount() = %p/n", mnt);	return mnt;}EXPORT_SYMBOL_GPL(nfs_do_submount);struct vfsmount *nfs_submount(struct nfs_server *server, struct dentry *dentry,			      struct nfs_fh *fh, struct nfs_fattr *fattr){	int err;	struct dentry *parent = dget_parent(dentry);	/* Look it up again to get its attributes */	err = server->nfs_client->rpc_ops->lookup(parent->d_inode, &dentry->d_name, fh, fattr);	dput(parent);	if (err != 0)		return ERR_PTR(err);	return nfs_do_submount(dentry, fh, fattr, server->client->cl_auth->au_flavor);}

int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst, u32 id,		       u32 ts, u32 tsage, long expires, u32 error){	struct rta_cacheinfo ci = {		.rta_lastuse = jiffies_to_clock_t(jiffies - dst->lastuse),		.rta_used = dst->__use,		.rta_clntref = atomic_read(&(dst->__refcnt)),		.rta_error = error,		.rta_id =  id,		.rta_ts = ts,		.rta_tsage = tsage,	};	if (expires)		ci.rta_expires = jiffies_to_clock_t(expires);	return nla_put(skb, RTA_CACHEINFO, sizeof(ci), &ci);}EXPORT_SYMBOL_GPL(rtnl_put_cacheinfo);static void set_operstate(struct net_device *dev, unsigned char transition){	unsigned char operstate = dev->operstate;	switch(transition) {	case IF_OPER_UP:		if ((operstate == IF_OPER_DORMANT ||		     operstate == IF_OPER_UNKNOWN) &&		    !netif_dormant(dev))			operstate = IF_OPER_UP;		break;	case IF_OPER_DORMANT:		if (operstate == IF_OPER_UP ||		    operstate == IF_OPER_UNKNOWN)			operstate = IF_OPER_DORMANT;		break;	}	if (dev->operstate != operstate) {		write_lock_bh(&dev_base_lock);		dev->operstate = operstate;		write_unlock_bh(&dev_base_lock);		netdev_state_change(dev);	}}

static int pmf_get_detect(struct gpio_runtime *rt,			  enum notify_type type){	char *name;	int err = -EBUSY, ret;	struct pmf_args args = { .count = 1, .u[0].p = &ret };	switch (type) {	case AOA_NOTIFY_HEADPHONE:		name = "headphone-detect";		break;	case AOA_NOTIFY_LINE_IN:		name = "linein-detect";		break;	case AOA_NOTIFY_LINE_OUT:		name = "lineout-detect";		break;	default:		return -EINVAL;	}	err = pmf_call_function(rt->node, name, &args);	if (err)		return err;	return ret;}static struct gpio_methods methods = {	.init			= pmf_gpio_init,	.exit			= pmf_gpio_exit,	.all_amps_off		= pmf_gpio_all_amps_off,	.all_amps_restore	= pmf_gpio_all_amps_restore,	.set_headphone		= pmf_gpio_set_headphone,	.set_speakers		= pmf_gpio_set_amp,	.set_lineout		= pmf_gpio_set_lineout,	.set_hw_reset		= pmf_gpio_set_hw_reset,	.get_headphone		= pmf_gpio_get_headphone,	.get_speakers		= pmf_gpio_get_amp,	.get_lineout		= pmf_gpio_get_lineout,	.set_notify		= pmf_set_notify,	.get_detect		= pmf_get_detect,};struct gpio_methods *pmf_gpio_methods = &methods;EXPORT_SYMBOL_GPL(pmf_gpio_methods);

/* Extract info for Tcp socket info provided via netlink. */void tcp_vegas_get_info(struct sock *sk, u32 ext, struct sk_buff *skb){	const struct vegas *ca = inet_csk_ca(sk);	if (ext & (1 << (INET_DIAG_VEGASINFO - 1))) {		struct tcpvegas_info info = {			.tcpv_enabled = ca->doing_vegas_now,			.tcpv_rttcnt = ca->cntRTT,			.tcpv_rtt = ca->baseRTT,			.tcpv_minrtt = ca->minRTT,		};		nla_put(skb, INET_DIAG_VEGASINFO, sizeof(info), &info);	}}EXPORT_SYMBOL_GPL(tcp_vegas_get_info);static struct tcp_congestion_ops tcp_vegas __read_mostly = {	.flags		= TCP_CONG_RTT_STAMP,	.init		= tcp_vegas_init,	.ssthresh	= tcp_reno_ssthresh,	.cong_avoid	= tcp_vegas_cong_avoid,	.min_cwnd	= tcp_reno_min_cwnd,	.pkts_acked	= tcp_vegas_pkts_acked,	.set_state	= tcp_vegas_state,	.cwnd_event	= tcp_vegas_cwnd_event,	.get_info	= tcp_vegas_get_info,	.owner		= THIS_MODULE,	.name		= "vegas",};static int __init tcp_vegas_register(void){	BUILD_BUG_ON(sizeof(struct vegas) > ICSK_CA_PRIV_SIZE);	tcp_register_congestion_control(&tcp_vegas);	return 0;}static void __exit tcp_vegas_unregister(void){	tcp_unregister_congestion_control(&tcp_vegas);}

/** * nfs_do_submount - set up mountpoint when crossing a filesystem boundary * @dentry - parent directory * @fh - filehandle for new root dentry * @fattr - attributes for new root inode * @authflavor - security flavor to use when performing the mount * */struct vfsmount *nfs_do_submount(struct dentry *dentry, struct nfs_fh *fh,				 struct nfs_fattr *fattr, rpc_authflavor_t authflavor){	struct nfs_clone_mount mountdata = {		.sb = dentry->d_sb,		.dentry = dentry,		.fh = fh,		.fattr = fattr,		.authflavor = authflavor,	};	struct vfsmount *mnt;	char *page = (char *) __get_free_page(GFP_USER);	char *devname;	if (page == NULL)		return ERR_PTR(-ENOMEM);	devname = nfs_devname(dentry, page, PAGE_SIZE);	if (IS_ERR(devname))		mnt = (struct vfsmount *)devname;	else		mnt = nfs_do_clone_mount(NFS_SB(dentry->d_sb), devname, &mountdata);	free_page((unsigned long)page);	return mnt;}EXPORT_SYMBOL_GPL(nfs_do_submount);struct vfsmount *nfs_submount(struct nfs_server *server, struct dentry *dentry,			      struct nfs_fh *fh, struct nfs_fattr *fattr){	int err;	struct dentry *parent = dget_parent(dentry);	/* Look it up again to get its attributes */	err = server->nfs_client->rpc_ops->lookup(d_inode(parent), &dentry->d_name, fh, fattr, NULL);	dput(parent);	if (err != 0)		return ERR_PTR(err);	return nfs_do_submount(dentry, fh, fattr, server->client->cl_auth->au_flavor);}

void xen_free_vm_area(struct vm_struct *area){	unsigned int order = get_order(area->size);	unsigned long i;	unsigned long phys_addr = __pa(area->addr);	/* This area is used for foreign page mappping.	 * So underlying machine page may not be assigned. */	for (i = 0; i < (1 << order); i++) {		unsigned long ret;		unsigned long gpfn = (phys_addr >> PAGE_SHIFT) + i;		struct xen_memory_reservation reservation = {			.nr_extents   = 1,			.address_bits = 0,			.extent_order = 0,			.domid        = DOMID_SELF		};		set_xen_guest_handle(reservation.extent_start, &gpfn);		ret = HYPERVISOR_memory_op(XENMEM_populate_physmap,					   &reservation);		BUG_ON(ret != 1);	}	free_pages((unsigned long)area->addr, order);	kfree(area);}EXPORT_SYMBOL_GPL(xen_free_vm_area);/**************************************************************************** * grant table hack * cmd: GNTTABOP_xxx */int arch_gnttab_map_shared(unsigned long *frames, unsigned long nr_gframes,			   unsigned long max_nr_gframes,			   struct grant_entry **__shared){	*__shared = __va(frames[0] << PAGE_SHIFT);	return 0;}

void mars_digest(unsigned char *digest, void *data, int len){	struct hash_desc desc = {		.tfm = mars_tfm,		.flags = 0,	};	struct scatterlist sg;	memset(digest, 0, mars_digest_size);	// TODO: use per-thread instance, omit locking	down(&tfm_sem);	crypto_hash_init(&desc);	sg_init_table(&sg, 1);	sg_set_buf(&sg, data, len);	crypto_hash_update(&desc, &sg, sg.length);	crypto_hash_final(&desc, digest);	up(&tfm_sem);}EXPORT_SYMBOL_GPL(mars_digest);void mref_checksum(struct mref_object *mref){	unsigned char checksum[mars_digest_size];	int len;	if (mref->ref_cs_mode <= 0 || !mref->ref_data)		return;	mars_digest(checksum, mref->ref_data, mref->ref_len);	len = sizeof(mref->ref_checksum);	if (len > mars_digest_size)		len = mars_digest_size;	memcpy(&mref->ref_checksum, checksum, len);}

/** * stack_trace_save - Save a stack trace into a storage array * @store:	Pointer to storage array * @size:	Size of the storage array * @skipnr:	Number of entries to skip at the start of the stack trace * * Return: Number of trace entries stored */unsigned int stack_trace_save(unsigned long *store, unsigned int size,			      unsigned int skipnr){	struct stack_trace trace = {		.entries	= store,		.max_entries	= size,		.skip		= skipnr + 1,	};	save_stack_trace(&trace);	return trace.nr_entries;}EXPORT_SYMBOL_GPL(stack_trace_save);/** * stack_trace_save_tsk - Save a task stack trace into a storage array * @task:	The task to examine * @store:	Pointer to storage array * @size:	Size of the storage array * @skipnr:	Number of entries to skip at the start of the stack trace * * Return: Number of trace entries stored */unsigned int stack_trace_save_tsk(struct task_struct *task,				  unsigned long *store, unsigned int size,				  unsigned int skipnr){	struct stack_trace trace = {		.entries	= store,		.max_entries	= size,		.skip		= skipnr + 1,	};	save_stack_trace_tsk(task, &trace);	return trace.nr_entries;}/** * stack_trace_save_regs - Save a stack trace based on pt_regs into a storage array * @regs:	Pointer to pt_regs to examine * @store:	Pointer to storage array * @size:	Size of the storage array * @skipnr:	Number of entries to skip at the start of the stack trace * * Return: Number of trace entries stored */unsigned int stack_trace_save_regs(struct pt_regs *regs, unsigned long *store,				   unsigned int size, unsigned int skipnr){	struct stack_trace trace = {		.entries	= store,		.max_entries	= size,		.skip		= skipnr,	};	save_stack_trace_regs(regs, &trace);	return trace.nr_entries;}#ifdef CONFIG_HAVE_RELIABLE_STACKTRACE/** * stack_trace_save_tsk_reliable - Save task stack with verification * @tsk:	Pointer to the task to examine * @store:	Pointer to storage array * @size:	Size of the storage array * * Return:	An error if it detects any unreliable features of the *		stack. Otherwise it guarantees that the stack trace is *		reliable and returns the number of entries stored. * * If the task is not 'current', the caller *must* ensure the task is inactive. */int stack_trace_save_tsk_reliable(struct task_struct *tsk, unsigned long *store,				  unsigned int size){	struct stack_trace trace = {		.entries	= store,		.max_entries	= size,	};	int ret = save_stack_trace_tsk_reliable(tsk, &trace);	return ret ? ret : trace.nr_entries;}#endif#ifdef CONFIG_USER_STACKTRACE_SUPPORT/** * stack_trace_save_user - Save a user space stack trace into a storage array * @store:	Pointer to storage array * @size:	Size of the storage array * * Return: Number of trace entries stored//.........这里部分代码省略.........

//.........这里部分代码省略.........			dax_unmap_atomic(bdev, &dax);			goto fallback;		}		if (pfn_t_to_pfn(dax.pfn) & PG_PMD_COLOUR) {			dax_pmd_dbg(&bh, address, "pfn unaligned");			dax_unmap_atomic(bdev, &dax);			goto fallback;		}		if (!pfn_t_devmap(dax.pfn)) {			dax_unmap_atomic(bdev, &dax);			dax_pmd_dbg(&bh, address, "pfn not in memmap");			goto fallback;		}		if (buffer_unwritten(&bh) || buffer_new(&bh)) {			clear_pmem(dax.addr, PMD_SIZE);			wmb_pmem();			count_vm_event(PGMAJFAULT);			mem_cgroup_count_vm_event(vma->vm_mm, PGMAJFAULT);			result |= VM_FAULT_MAJOR;		}		dax_unmap_atomic(bdev, &dax);		/*		 * For PTE faults we insert a radix tree entry for reads, and		 * leave it clean.  Then on the first write we dirty the radix		 * tree entry via the dax_pfn_mkwrite() path.  This sequence		 * allows the dax_pfn_mkwrite() call to be simpler and avoid a		 * call into get_block() to translate the pgoff to a sector in		 * order to be able to create a new radix tree entry.		 *		 * The PMD path doesn't have an equivalent to		 * dax_pfn_mkwrite(), though, so for a read followed by a		 * write we traverse all the way through __dax_pmd_fault()		 * twice.  This means we can just skip inserting a radix tree		 * entry completely on the initial read and just wait until		 * the write to insert a dirty entry.		 */		if (write) {			error = dax_radix_entry(mapping, pgoff, dax.sector,					true, true);			if (error) {				dax_pmd_dbg(&bh, address,						"PMD radix insertion failed");				goto fallback;			}		}		dev_dbg(part_to_dev(bdev->bd_part),				"%s: %s addr: %lx pfn: %lx sect: %llx/n",				__func__, current->comm, address,				pfn_t_to_pfn(dax.pfn),				(unsigned long long) dax.sector);		result |= vmf_insert_pfn_pmd(vma, address, pmd,				dax.pfn, write);	} out:	i_mmap_unlock_read(mapping);	if (buffer_unwritten(&bh))		complete_unwritten(&bh, !(result & VM_FAULT_ERROR));	return result; fallback:	count_vm_event(THP_FAULT_FALLBACK);	result = VM_FAULT_FALLBACK;	goto out;}EXPORT_SYMBOL_GPL(__dax_pmd_fault);/** * dax_pmd_fault - handle a PMD fault on a DAX file * @vma: The virtual memory area where the fault occurred * @vmf: The description of the fault * @get_block: The filesystem method used to translate file offsets to blocks * * When a page fault occurs, filesystems may call this helper in their * pmd_fault handler for DAX files. */int dax_pmd_fault(struct vm_area_struct *vma, unsigned long address,			pmd_t *pmd, unsigned int flags, get_block_t get_block,			dax_iodone_t complete_unwritten){	int result;	struct super_block *sb = file_inode(vma->vm_file)->i_sb;	if (flags & FAULT_FLAG_WRITE) {		sb_start_pagefault(sb);		file_update_time(vma->vm_file);	}	result = __dax_pmd_fault(vma, address, pmd, flags, get_block,				complete_unwritten);	if (flags & FAULT_FLAG_WRITE)		sb_end_pagefault(sb);	return result;}

struct page *read_dax_sector(struct block_device *bdev, sector_t n){	struct page *page = alloc_pages(GFP_KERNEL, 0);	struct blk_dax_ctl dax = {		.size = PAGE_SIZE,		.sector = n & ~((((int) PAGE_SIZE) / 512) - 1),	};	long rc;	if (!page)		return ERR_PTR(-ENOMEM);	rc = dax_map_atomic(bdev, &dax);	if (rc < 0)		return ERR_PTR(rc);	memcpy_from_pmem(page_address(page), dax.addr, PAGE_SIZE);	dax_unmap_atomic(bdev, &dax);	return page;}/* * dax_clear_sectors() is called from within transaction context from XFS, * and hence this means the stack from this point must follow GFP_NOFS * semantics for all operations. */int dax_clear_sectors(struct block_device *bdev, sector_t _sector, long _size){	struct blk_dax_ctl dax = {		.sector = _sector,		.size = _size,	};	might_sleep();	do {		long count, sz;		count = dax_map_atomic(bdev, &dax);		if (count < 0)			return count;		sz = min_t(long, count, SZ_128K);		clear_pmem(dax.addr, sz);		dax.size -= sz;		dax.sector += sz / 512;		dax_unmap_atomic(bdev, &dax);		cond_resched();	} while (dax.size);	wmb_pmem();	return 0;}EXPORT_SYMBOL_GPL(dax_clear_sectors);/* the clear_pmem() calls are ordered by a wmb_pmem() in the caller */static void dax_new_buf(void __pmem *addr, unsigned size, unsigned first,		loff_t pos, loff_t end){	loff_t final = end - pos + first; /* The final byte of the buffer */	if (first > 0)		clear_pmem(addr, first);	if (final < size)		clear_pmem(addr + final, size - final);}

//.........这里部分代码省略.........	entry = radix_tree_lookup(&mapping->page_tree, pmd_index);	rcu_read_unlock();	/* see if the start of our range is covered by a PMD entry */	if (entry && RADIX_DAX_TYPE(entry) == RADIX_DAX_PMD)		start_index = pmd_index;	tag_pages_for_writeback(mapping, start_index, end_index);	pagevec_init(&pvec, 0);	while (!done) {		pvec.nr = find_get_entries_tag(mapping, start_index,				PAGECACHE_TAG_TOWRITE, PAGEVEC_SIZE,				pvec.pages, indices);		if (pvec.nr == 0)			break;		for (i = 0; i < pvec.nr; i++) {			if (indices[i] > end_index) {				done = true;				break;			}			ret = dax_writeback_one(bdev, mapping, indices[i],					pvec.pages[i]);			if (ret < 0)				return ret;		}	}	wmb_pmem();	return 0;}EXPORT_SYMBOL_GPL(dax_writeback_mapping_range);static int dax_insert_mapping(struct inode *inode, struct buffer_head *bh,			struct vm_area_struct *vma, struct vm_fault *vmf){	unsigned long vaddr = (unsigned long)vmf->virtual_address;	struct address_space *mapping = inode->i_mapping;	struct block_device *bdev = bh->b_bdev;	struct blk_dax_ctl dax = {		.sector = to_sector(bh, inode),		.size = bh->b_size,	};	pgoff_t size;	int error;	i_mmap_lock_read(mapping);	/*	 * Check truncate didn't happen while we were allocating a block.	 * If it did, this block may or may not be still allocated to the	 * file.  We can't tell the filesystem to free it because we can't	 * take i_mutex here.  In the worst case, the file still has blocks	 * allocated past the end of the file.	 */	size = (i_size_read(inode) + PAGE_SIZE - 1) >> PAGE_SHIFT;	if (unlikely(vmf->pgoff >= size)) {		error = -EIO;		goto out;	}	if (dax_map_atomic(bdev, &dax) < 0) {		error = PTR_ERR(dax.addr);		goto out;

int cpufreq_frequency_table_target(struct cpufreq_policy *policy,				   struct cpufreq_frequency_table *table,				   unsigned int target_freq,				   unsigned int relation,				   unsigned int *index){	struct cpufreq_frequency_table optimal = {		.index = ~0,		.frequency = 0,	};	struct cpufreq_frequency_table suboptimal = {		.index = ~0,		.frequency = 0,	};	unsigned int diff, i = 0;	pr_debug("request for target %u kHz (relation: %u) for cpu %u/n",					target_freq, relation, policy->cpu);	switch (relation) {	case CPUFREQ_RELATION_H:		suboptimal.frequency = ~0;		break;	case CPUFREQ_RELATION_L:	case CPUFREQ_RELATION_C:		optimal.frequency = ~0;		break;	}	if (!cpu_online(policy->cpu))		return -EINVAL;	for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {		unsigned int freq = table[i].frequency;		if (freq == CPUFREQ_ENTRY_INVALID)			continue;		if ((freq < policy->min) || (freq > policy->max))			continue;		if (freq == target_freq) {			optimal.index = i;			break;		}		switch (relation) {		case CPUFREQ_RELATION_H:			if (freq < target_freq) {				if (freq >= optimal.frequency) {					optimal.frequency = freq;					optimal.index = i;				}			} else {				if (freq <= suboptimal.frequency) {					suboptimal.frequency = freq;					suboptimal.index = i;				}			}			break;		case CPUFREQ_RELATION_L:			if (freq > target_freq) {				if (freq <= optimal.frequency) {					optimal.frequency = freq;					optimal.index = i;				}			} else {				if (freq >= suboptimal.frequency) {					suboptimal.frequency = freq;					suboptimal.index = i;				}			}			break;		case CPUFREQ_RELATION_C:			diff = abs(freq - target_freq);			if (diff < optimal.frequency ||			    (diff == optimal.frequency &&			     freq > table[optimal.index].frequency)) {				optimal.frequency = diff;				optimal.index = i;			}			break;		}	}	if (optimal.index > i) {		if (suboptimal.index > i)			return -EINVAL;		*index = suboptimal.index;	} else		*index = optimal.index;	pr_debug("target is %u (%u kHz, %u)/n", *index, table[*index].frequency,		table[*index].index);	return 0;}EXPORT_SYMBOL_GPL(cpufreq_frequency_table_target);static DEFINE_PER_CPU(struct cpufreq_frequency_table *, cpufreq_show_table);/** * show_available_freqs - show available frequencies for the specified CPU */static ssize_t show_available_freqs(struct cpufreq_policy *policy, char *buf){//.........这里部分代码省略.........

/** * xenbus_map_ring_valloc * @dev: xenbus device * @gnt_ref: grant reference * @vaddr: pointer to address to be filled out by mapping * * Based on Rusty Russell's skeleton driver's map_page. * Map a page of memory into this domain from another domain's grant table. * xenbus_map_ring_valloc allocates a page of virtual address space, maps the * page to that address, and sets *vaddr to that address. * Returns 0 on success, and GNTST_* (see xen/include/interface/grant_table.h) * or -ENOMEM on error. If an error is returned, device will switch to * XenbusStateClosing and the error message will be saved in XenStore. */int xenbus_map_ring_valloc(struct xenbus_device *dev, int gnt_ref, void **vaddr){	struct gnttab_map_grant_ref op = {		.flags = GNTMAP_host_map,		.ref   = gnt_ref,		.dom   = dev->otherend_id,	};	struct vm_struct *area;	*vaddr = NULL;	area = xen_alloc_vm_area(PAGE_SIZE);	if (!area)		return -ENOMEM;	op.host_addr = (unsigned long)area->addr;	if (HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1))		BUG();	if (op.status != GNTST_okay) {		xen_free_vm_area(area);		xenbus_dev_fatal(dev, op.status,				 "mapping in shared page %d from domain %d",				 gnt_ref, dev->otherend_id);		return op.status;	}	/* Stuff the handle in an unused field */	area->phys_addr = (unsigned long)op.handle;	*vaddr = area->addr;	return 0;}EXPORT_SYMBOL_GPL(xenbus_map_ring_valloc);/** * xenbus_map_ring * @dev: xenbus device * @gnt_ref: grant reference * @handle: pointer to grant handle to be filled * @vaddr: address to be mapped to * * Map a page of memory into this domain from another domain's grant table. * xenbus_map_ring does not allocate the virtual address space (you must do * this yourself!). It only maps in the page to the specified address. * Returns 0 on success, and GNTST_* (see xen/include/interface/grant_table.h) * or -ENOMEM on error. If an error is returned, device will switch to * XenbusStateClosing and the error message will be saved in XenStore. */int xenbus_map_ring(struct xenbus_device *dev, int gnt_ref,		    grant_handle_t *handle, void *vaddr){	struct gnttab_map_grant_ref op = {		.host_addr = (unsigned long)vaddr,		.flags     = GNTMAP_host_map,		.ref       = gnt_ref,		.dom       = dev->otherend_id,	};	if (HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1))		BUG();	if (op.status != GNTST_okay) {		xenbus_dev_fatal(dev, op.status,				 "mapping in shared page %d from domain %d",				 gnt_ref, dev->otherend_id);	} else		*handle = op.handle;	return op.status;}EXPORT_SYMBOL_GPL(xenbus_map_ring);/** * xenbus_unmap_ring_vfree * @dev: xenbus device * @vaddr: addr to unmap * * Based on Rusty Russell's skeleton driver's unmap_page. * Unmap a page of memory in this domain that was imported from another domain. * Use xenbus_unmap_ring_vfree if you mapped in your memory with * xenbus_map_ring_valloc (it will free the virtual address space). * Returns 0 on success and returns GNTST_* on error//.........这里部分代码省略.........

int cw1200_core_probe(const struct sbus_ops *sbus_ops,		      struct sbus_priv *sbus,		      struct device *pdev,		      struct cw1200_common **pself,		      u8 *mac_addr){	int err = -ENOMEM;	u16 ctrl_reg;	struct ieee80211_hw *dev;	struct cw1200_common *priv;	struct wsm_operational_mode mode = {		.power_mode = wsm_power_mode_quiescent,		.disableMoreFlagUsage = true,	};	dev = cw1200_init_common(sizeof(struct cw1200_common), mac_addr);	if (!dev)		goto err;	priv = dev->priv;	priv->sbus_ops = sbus_ops;	priv->sbus_priv = sbus;	priv->pdev = pdev;	SET_IEEE80211_DEV(priv->hw, pdev);	/* WSM callbacks. */	priv->wsm_cbc.scan_complete = cw1200_scan_complete_cb;	priv->wsm_cbc.tx_confirm = cw1200_tx_confirm_cb;	priv->wsm_cbc.rx = cw1200_rx_cb;	priv->wsm_cbc.suspend_resume = cw1200_suspend_resume;	/* priv->wsm_cbc.set_pm_complete = cw1200_set_pm_complete_cb; */	priv->wsm_cbc.channel_switch = cw1200_channel_switch_cb;	err = cw1200_register_bh(priv);	if (err)		goto err1;	err = cw1200_load_firmware(priv);	if (err)		goto err2;	priv->sbus_ops->lock(priv->sbus_priv);	WARN_ON(priv->sbus_ops->set_block_size(priv->sbus_priv,			SDIO_BLOCK_SIZE));	priv->sbus_ops->unlock(priv->sbus_priv);	if (wait_event_interruptible_timeout(priv->wsm_startup_done,				priv->wsm_caps.firmwareReady, 3*HZ) <= 0) {		/* TODO: Needs to find how to reset device */		/*       in QUEUE mode properly.           */		goto err3;	}	WARN_ON(cw1200_reg_write_16(priv, ST90TDS_CONTROL_REG_ID,					ST90TDS_CONT_WUP_BIT));	if (cw1200_reg_read_16(priv,ST90TDS_CONTROL_REG_ID, &ctrl_reg))		WARN_ON(cw1200_reg_read_16(priv,ST90TDS_CONTROL_REG_ID,						&ctrl_reg));	WARN_ON(!(ctrl_reg & ST90TDS_CONT_RDY_BIT));	/* Set low-power mode. */	WARN_ON(wsm_set_operational_mode(priv, &mode));	/* Enable multi-TX confirmation */	WARN_ON(wsm_use_multi_tx_conf(priv, true));	err = cw1200_register_common(dev);	if (err) {		priv->sbus_ops->irq_unsubscribe(priv->sbus_priv);		goto err3;	}	*pself = dev->priv;	return err;err3:	sbus_ops->reset(sbus);err2:	cw1200_unregister_bh(priv);err1:	cw1200_free_common(dev);err:	return err;}EXPORT_SYMBOL_GPL(cw1200_core_probe);void cw1200_core_release(struct cw1200_common *self){	cw1200_unregister_common(self->hw);	cw1200_free_common(self->hw);	return;}

//.........这里部分代码省略.........		rcu_read_lock();		ca_ops = READ_ONCE(icsk->icsk_ca_ops);		if (ca_ops)			err = nla_put_string(skb, INET_DIAG_CONG, ca_ops->name);		rcu_read_unlock();		if (err < 0)			goto errout;	}	handler->idiag_get_info(sk, r, info);	if (sk->sk_state < TCP_TIME_WAIT) {		union tcp_cc_info info;		size_t sz = 0;		int attr;		rcu_read_lock();		ca_ops = READ_ONCE(icsk->icsk_ca_ops);		if (ca_ops && ca_ops->get_info)			sz = ca_ops->get_info(sk, ext, &attr, &info);		rcu_read_unlock();		if (sz && nla_put(skb, attr, sz, &info) < 0)			goto errout;	}out:	nlmsg_end(skb, nlh);	return 0;errout:	nlmsg_cancel(skb, nlh);	return -EMSGSIZE;}EXPORT_SYMBOL_GPL(inet_sk_diag_fill);static int inet_csk_diag_fill(struct sock *sk,			      struct sk_buff *skb,			      const struct inet_diag_req_v2 *req,			      struct user_namespace *user_ns,			      u32 portid, u32 seq, u16 nlmsg_flags,			      const struct nlmsghdr *unlh){	return inet_sk_diag_fill(sk, inet_csk(sk), skb, req,				 user_ns, portid, seq, nlmsg_flags, unlh);}static int inet_twsk_diag_fill(struct sock *sk,			       struct sk_buff *skb,			       u32 portid, u32 seq, u16 nlmsg_flags,			       const struct nlmsghdr *unlh){	struct inet_timewait_sock *tw = inet_twsk(sk);	struct inet_diag_msg *r;	struct nlmsghdr *nlh;	long tmo;	nlh = nlmsg_put(skb, portid, seq, unlh->nlmsg_type, sizeof(*r),			nlmsg_flags);	if (!nlh)		return -EMSGSIZE;	r = nlmsg_data(nlh);	BUG_ON(tw->tw_state != TCP_TIME_WAIT);	tmo = tw->tw_timer.expires - jiffies;	if (tmo < 0)

static int can_fill_info(struct sk_buff *skb, const struct net_device *dev){	struct can_priv *priv = netdev_priv(dev);	struct can_ctrlmode cm = {.flags = priv->ctrlmode};	struct can_berr_counter bec;	enum can_state state = priv->state;	if (priv->do_get_state)		priv->do_get_state(dev, &state);	NLA_PUT_U32(skb, IFLA_CAN_STATE, state);	NLA_PUT(skb, IFLA_CAN_CTRLMODE, sizeof(cm), &cm);	NLA_PUT_U32(skb, IFLA_CAN_RESTART_MS, priv->restart_ms);	NLA_PUT(skb, IFLA_CAN_BITTIMING,		sizeof(priv->bittiming), &priv->bittiming);	NLA_PUT(skb, IFLA_CAN_CLOCK, sizeof(cm), &priv->clock);	if (priv->do_get_berr_counter && !priv->do_get_berr_counter(dev, &bec))		NLA_PUT(skb, IFLA_CAN_BERR_COUNTER, sizeof(bec), &bec);	if (priv->bittiming_const)		NLA_PUT(skb, IFLA_CAN_BITTIMING_CONST,			sizeof(*priv->bittiming_const), priv->bittiming_const);	return 0;nla_put_failure:	return -EMSGSIZE;}static size_t can_get_xstats_size(const struct net_device *dev){	return sizeof(struct can_device_stats);}static int can_fill_xstats(struct sk_buff *skb, const struct net_device *dev){	struct can_priv *priv = netdev_priv(dev);	NLA_PUT(skb, IFLA_INFO_XSTATS,		sizeof(priv->can_stats), &priv->can_stats);	return 0;nla_put_failure:	return -EMSGSIZE;}static int can_newlink(struct net *src_net, struct net_device *dev,		       struct nlattr *tb[], struct nlattr *data[]){	return -EOPNOTSUPP;}static struct rtnl_link_ops can_link_ops __read_mostly = {	.kind		= "can",	.maxtype	= IFLA_CAN_MAX,	.policy		= can_policy,	.setup		= can_setup,	.newlink	= can_newlink,	.changelink	= can_changelink,	.get_size	= can_get_size,	.fill_info	= can_fill_info,	.get_xstats_size = can_get_xstats_size,	.fill_xstats	= can_fill_xstats,};int register_candev(struct net_device *dev){	dev->rtnl_link_ops = &can_link_ops;	return register_netdev(dev);}EXPORT_SYMBOL_GPL(register_candev);void unregister_candev(struct net_device *dev){	unregister_netdev(dev);}

//.........这里部分代码省略.........static int crypto_init_blkcipher_ops(struct crypto_tfm *tfm, u32 type, u32 mask){	struct blkcipher_alg *alg = &tfm->__crt_alg->cra_blkcipher;	if (alg->ivsize > PAGE_SIZE / 8)		return -EINVAL;	if ((mask & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_MASK)		return crypto_init_blkcipher_ops_sync(tfm);	else		return crypto_init_blkcipher_ops_async(tfm);}static void crypto_blkcipher_show(struct seq_file *m, struct crypto_alg *alg)	__attribute__ ((unused));static void crypto_blkcipher_show(struct seq_file *m, struct crypto_alg *alg){	seq_printf(m, "type         : blkcipher/n");	seq_printf(m, "blocksize    : %u/n", alg->cra_blocksize);	seq_printf(m, "min keysize  : %u/n", alg->cra_blkcipher.min_keysize);	seq_printf(m, "max keysize  : %u/n", alg->cra_blkcipher.max_keysize);	seq_printf(m, "ivsize       : %u/n", alg->cra_blkcipher.ivsize);	seq_printf(m, "geniv        : %s/n", alg->cra_blkcipher.geniv ?:					     "<default>");}const struct crypto_type crypto_blkcipher_type = {	.ctxsize = crypto_blkcipher_ctxsize,	.init = crypto_init_blkcipher_ops,#ifdef CONFIG_PROC_FS	.show = crypto_blkcipher_show,#endif};EXPORT_SYMBOL_GPL(crypto_blkcipher_type);static int crypto_grab_nivcipher(struct crypto_skcipher_spawn *spawn,				const char *name, u32 type, u32 mask){	struct crypto_alg *alg;	int err;	type = crypto_skcipher_type(type);	mask = crypto_skcipher_mask(mask)| CRYPTO_ALG_GENIV;	alg = crypto_alg_mod_lookup(name, type, mask);	if (IS_ERR(alg))		return PTR_ERR(alg);	err = crypto_init_spawn(&spawn->base, alg, spawn->base.inst, mask);	crypto_mod_put(alg);	return err;}struct crypto_instance *skcipher_geniv_alloc(struct crypto_template *tmpl,					     struct rtattr **tb, u32 type,					     u32 mask){	struct {		int (*setkey)(struct crypto_ablkcipher *tfm, const u8 *key,			      unsigned int keylen);		int (*encrypt)(struct ablkcipher_request *req);		int (*decrypt)(struct ablkcipher_request *req);		unsigned int min_keysize;		unsigned int max_keysize;		unsigned int ivsize;

static void acpi_bus_osc_support(void){	u32 capbuf[2];	struct acpi_osc_context context = {		.uuid_str = sb_uuid_str,		.rev = 1,		.cap.length = 8,		.cap.pointer = capbuf,	};	acpi_handle handle;	capbuf[OSC_QUERY_TYPE] = OSC_QUERY_ENABLE;	capbuf[OSC_SUPPORT_TYPE] = OSC_SB_PR3_SUPPORT; /* _PR3 is in use */#if defined(CONFIG_ACPI_PROCESSOR_AGGREGATOR) || /	defined(CONFIG_ACPI_PROCESSOR_AGGREGATOR_MODULE)	capbuf[OSC_SUPPORT_TYPE] |= OSC_SB_PAD_SUPPORT;#endif#if defined(CONFIG_ACPI_PROCESSOR) || defined(CONFIG_ACPI_PROCESSOR_MODULE)	capbuf[OSC_SUPPORT_TYPE] |= OSC_SB_PPC_OST_SUPPORT;#endif	if (ACPI_FAILURE(acpi_get_handle(NULL, "//_SB", &handle)))		return;	if (ACPI_SUCCESS(acpi_run_osc(handle, &context)))		kfree(context.ret.pointer);	/* do we need to check the returned cap? Sounds no */}/* --------------------------------------------------------------------------                                Event Management   -------------------------------------------------------------------------- */#ifdef CONFIG_ACPI_PROC_EVENTstatic DEFINE_SPINLOCK(acpi_bus_event_lock);LIST_HEAD(acpi_bus_event_list);DECLARE_WAIT_QUEUE_HEAD(acpi_bus_event_queue);extern int event_is_open;int acpi_bus_generate_proc_event4(const char *device_class, const char *bus_id, u8 type, int data){	struct acpi_bus_event *event;	unsigned long flags = 0;	/* drop event on the floor if no one's listening */	if (!event_is_open)		return 0;	event = kzalloc(sizeof(struct acpi_bus_event), GFP_ATOMIC);	if (!event)		return -ENOMEM;	strcpy(event->device_class, device_class);	strcpy(event->bus_id, bus_id);	event->type = type;	event->data = data;	spin_lock_irqsave(&acpi_bus_event_lock, flags);	list_add_tail(&event->node, &acpi_bus_event_list);	spin_unlock_irqrestore(&acpi_bus_event_lock, flags);	wake_up_interruptible(&acpi_bus_event_queue);	return 0;}EXPORT_SYMBOL_GPL(acpi_bus_generate_proc_event4);int acpi_bus_generate_proc_event(struct acpi_device *device, u8 type, int data){	if (!device)		return -EINVAL;	return acpi_bus_generate_proc_event4(device->pnp.device_class,					     device->pnp.bus_id, type, data);}EXPORT_SYMBOL(acpi_bus_generate_proc_event);int acpi_bus_receive_event(struct acpi_bus_event *event){	unsigned long flags = 0;	struct acpi_bus_event *entry = NULL;	DECLARE_WAITQUEUE(wait, current);	if (!event)		return -EINVAL;	if (list_empty(&acpi_bus_event_list)) {		set_current_state(TASK_INTERRUPTIBLE);		add_wait_queue(&acpi_bus_event_queue, &wait);		if (list_empty(&acpi_bus_event_list))			schedule();		remove_wait_queue(&acpi_bus_event_queue, &wait);//.........这里部分代码省略.........

//.........这里部分代码省略.........		 * need to use a lower xclk frequency.		 * Yet, it would be possible to adjust xclk depending on the		 * desired resolution, since this affects directly the		 * frame rate.		 */		dev->board.xclk = EM28XX_XCLK_FREQUENCY_4_3MHZ;		em28xx_write_reg(dev, EM28XX_R0F_XCLK, dev->board.xclk);		v4l2->sensor_xtal = 4300000;		pdata.xtal = v4l2->sensor_xtal;		if (NULL ==		    v4l2_i2c_new_subdev_board(&v4l2->v4l2_dev, adap,					      &mt9v011_info, NULL)) {			ret = -ENODEV;			break;		}		/* probably means GRGB 16 bit bayer */		v4l2->vinmode = 0x0d;		v4l2->vinctl = 0x00;		break;	}	case EM28XX_MT9M001:		v4l2->sensor_xres = 1280;		v4l2->sensor_yres = 1024;		em28xx_initialize_mt9m001(dev);		/* probably means BGGR 16 bit bayer */		v4l2->vinmode = 0x0c;		v4l2->vinctl = 0x00;		break;	case EM28XX_MT9M111:		v4l2->sensor_xres = 640;		v4l2->sensor_yres = 512;		dev->board.xclk = EM28XX_XCLK_FREQUENCY_48MHZ;		em28xx_write_reg(dev, EM28XX_R0F_XCLK, dev->board.xclk);		em28xx_initialize_mt9m111(dev);		v4l2->vinmode = 0x0a;		v4l2->vinctl = 0x00;		break;	case EM28XX_OV2640:	{		struct v4l2_subdev *subdev;		struct i2c_board_info ov2640_info = {			.type = "ov2640",			.flags = I2C_CLIENT_SCCB,			.addr = client->addr,			.platform_data = &camlink,		};		struct v4l2_mbus_framefmt fmt;		/*		 * FIXME: sensor supports resolutions up to 1600x1200, but		 * resolution setting/switching needs to be modified to		 * - switch sensor output resolution (including further		 *   configuration changes)		 * - adjust bridge xclk		 * - disable 16 bit (12 bit) output formats on high resolutions		 */		v4l2->sensor_xres = 640;		v4l2->sensor_yres = 480;		subdev =		     v4l2_i2c_new_subdev_board(&v4l2->v4l2_dev, adap,					       &ov2640_info, NULL);		if (NULL == subdev) {			ret = -ENODEV;			break;		}		fmt.code = MEDIA_BUS_FMT_YUYV8_2X8;		fmt.width = 640;		fmt.height = 480;		v4l2_subdev_call(subdev, video, s_mbus_fmt, &fmt);		/* NOTE: for UXGA=1600x1200 switch to 12MHz */		dev->board.xclk = EM28XX_XCLK_FREQUENCY_24MHZ;		em28xx_write_reg(dev, EM28XX_R0F_XCLK, dev->board.xclk);		v4l2->vinmode = 0x08;		v4l2->vinctl = 0x00;		break;	}	case EM28XX_NOSENSOR:	default:		ret = -EINVAL;	}	if (ret < 0) {		v4l2_clk_unregister_fixed(v4l2->clk);		v4l2->clk = NULL;	}	return ret;}EXPORT_SYMBOL_GPL(em28xx_init_camera);