1 // SPDX-License-Identifier: GPL-2.0
14 #include <linux/device.h>
30  * The SRCU here makes sure that STM device doesn't disappear from under a
36 static ssize_t masters_show(struct device *dev,  in masters_show()
43 	ret = sprintf(buf, "%u %u\n", stm->data->sw_start, stm->data->sw_end);  in masters_show()
50 static ssize_t channels_show(struct device *dev,  in channels_show()
57 	ret = sprintf(buf, "%u\n", stm->data->sw_nchannels);  in channels_show()
64 static ssize_t hw_override_show(struct device *dev,  in hw_override_show()
71 	ret = sprintf(buf, "%u\n", stm->data->hw_override);  in hw_override_show()
93  * stm_find_device() - find stm device by name
96  * This is called when either policy gets assigned to an stm device or an
97  * stm_source device gets linked to an stm device.
99  * This grabs device's reference (get_device()) and module reference, both
102  * Return:	stm device pointer or null if lookup failed.
107 	struct device *dev;  in stm_find_device()
117 	if (!try_module_get(stm->owner)) {  in stm_find_device()
127  * stm_put_device() - drop references on the stm device
128  * @stm:	stm device, previously acquired by stm_find_device()
130  * This drops the module reference and device reference taken by
135 	module_put(stm->owner);  in stm_put_device()
136 	put_device(&stm->dev);  in stm_put_device()
140  * Internally we only care about software-writable masters here, that is the
141  * ones in the range [stm_data->sw_start..stm_data..sw_end], however we need
144  * $master - stm_data->sw_start to reference master descriptors and such.
148 	((_s)->masters[(_m) - (_s)->data->sw_start])
153 	if (idx < stm->data->sw_start || idx > stm->data->sw_end)  in stm_master()
164 				     BITS_TO_LONGS(stm->data->sw_nchannels)),  in stp_master_alloc()
167 		return -ENOMEM;  in stp_master_alloc()
169 	master->nr_free = stm->data->sw_nchannels;  in stp_master_alloc()
188 	struct stp_master *master = stm_master(stm, output->master);  in stm_output_claim()
190 	lockdep_assert_held(&stm->mc_lock);  in stm_output_claim()
191 	lockdep_assert_held(&output->lock);  in stm_output_claim()
193 	if (WARN_ON_ONCE(master->nr_free < output->nr_chans))  in stm_output_claim()
196 	bitmap_allocate_region(&master->chan_map[0], output->channel,  in stm_output_claim()
197 			       ilog2(output->nr_chans));  in stm_output_claim()
199 	master->nr_free -= output->nr_chans;  in stm_output_claim()
205 	struct stp_master *master = stm_master(stm, output->master);  in stm_output_disclaim()
207 	lockdep_assert_held(&stm->mc_lock);  in stm_output_disclaim()
208 	lockdep_assert_held(&output->lock);  in stm_output_disclaim()
210 	bitmap_release_region(&master->chan_map[0], output->channel,  in stm_output_disclaim()
211 			      ilog2(output->nr_chans));  in stm_output_disclaim()
213 	master->nr_free += output->nr_chans;  in stm_output_disclaim()
214 	output->nr_chans = 0;  in stm_output_disclaim()
222 			      unsigned int end, unsigned int width)  in find_free_channels()  argument
227 	for (pos = start; pos < end + 1; pos = ALIGN(pos, width)) {  in find_free_channels()
229 		if (pos + width > end + 1)  in find_free_channels()
232 		if (pos & (width - 1))  in find_free_channels()
235 		for (i = 1; i < width && !test_bit(pos + i, bitmap); i++)  in find_free_channels()
237 		if (i == width)  in find_free_channels()
244 	return -1;  in find_free_channels()
248 stm_find_master_chan(struct stm_device *stm, unsigned int width,  in stm_find_master_chan()  argument
265 		if (!master->nr_free)  in stm_find_master_chan()
268 		pos = find_free_channels(master->chan_map, *cstart, cend,  in stm_find_master_chan()
269 					 width);  in stm_find_master_chan()
278 	return -ENOSPC;  in stm_find_master_chan()
281 static int stm_output_assign(struct stm_device *stm, unsigned int width,  in stm_output_assign()  argument
286 	int ret = -EINVAL;  in stm_output_assign()
288 	if (width > stm->data->sw_nchannels)  in stm_output_assign()
289 		return -EINVAL;  in stm_output_assign()
293 		return -EINVAL;  in stm_output_assign()
301 	spin_lock(&stm->mc_lock);  in stm_output_assign()
302 	spin_lock(&output->lock);  in stm_output_assign()
303 	/* output is already assigned -- shouldn't happen */  in stm_output_assign()
304 	if (WARN_ON_ONCE(output->nr_chans))  in stm_output_assign()
307 	ret = stm_find_master_chan(stm, width, &midx, mend, &cidx, cend);  in stm_output_assign()
311 	output->master = midx;  in stm_output_assign()
312 	output->channel = cidx;  in stm_output_assign()
313 	output->nr_chans = width;  in stm_output_assign()
314 	if (stm->pdrv->output_open) {  in stm_output_assign()
321 		ret = stm->pdrv->output_open(priv, output);  in stm_output_assign()
327 	dev_dbg(&stm->dev, "assigned %u:%u (+%u)\n", midx, cidx, width);  in stm_output_assign()
332 		output->nr_chans = 0;  in stm_output_assign()
334 	spin_unlock(&output->lock);  in stm_output_assign()
335 	spin_unlock(&stm->mc_lock);  in stm_output_assign()
342 	spin_lock(&stm->mc_lock);  in stm_output_free()
343 	spin_lock(&output->lock);  in stm_output_free()
344 	if (output->nr_chans)  in stm_output_free()
346 	if (stm->pdrv && stm->pdrv->output_close)  in stm_output_free()
347 		stm->pdrv->output_close(output);  in stm_output_free()
348 	spin_unlock(&output->lock);  in stm_output_free()
349 	spin_unlock(&stm->mc_lock);  in stm_output_free()
354 	spin_lock_init(&output->lock);  in stm_output_init()
357 static int major_match(struct device *dev, const void *data)  in major_match()
361 	return MAJOR(dev->devt) == major;  in major_match()
366  * Modules can implement STM protocol drivers and (un-)register them
390 		if (!strcmp(name, pe->pdrv->name))  in __stm_lookup_protocol()
400 	int ret = -ENOMEM;  in stm_register_protocol()
404 	if (__stm_lookup_protocol(pdrv->name)) {  in stm_register_protocol()
405 		ret = -EEXIST;  in stm_register_protocol()
413 	if (pdrv->policy_attr) {  in stm_register_protocol()
414 		pe->node_type = get_policy_node_type(pdrv->policy_attr);  in stm_register_protocol()
415 		if (!pe->node_type)  in stm_register_protocol()
419 	list_add_tail(&pe->entry, &stm_pdrv_head);  in stm_register_protocol()
420 	pe->pdrv = pdrv;  in stm_register_protocol()
440 		if (pe->pdrv == pdrv) {  in stm_unregister_protocol()
441 			list_del(&pe->entry);  in stm_unregister_protocol()
443 			if (pe->node_type) {  in stm_unregister_protocol()
444 				kfree(pe->node_type->ct_attrs);  in stm_unregister_protocol()
445 				kfree(pe->node_type);  in stm_unregister_protocol()
458 	return try_module_get(pdrv->owner);  in stm_get_protocol()
463 	module_put(pdrv->owner);  in stm_put_protocol()
475 	if (pe && pe->pdrv && stm_get_protocol(pe->pdrv)) {  in stm_lookup_protocol()
476 		*pdrv = pe->pdrv;  in stm_lookup_protocol()
477 		*node_type = pe->node_type;  in stm_lookup_protocol()
482 	return pe ? 0 : -ENOENT;  in stm_lookup_protocol()
488 	struct device *dev;  in stm_char_open()
490 	int err = -ENOMEM;  in stm_char_open()
494 		return -ENODEV;  in stm_char_open()
500 	err = -ENODEV;  in stm_char_open()
501 	stm_output_init(&stmf->output);  in stm_char_open()
502 	stmf->stm = to_stm_device(dev);  in stm_char_open()
504 	if (!try_module_get(stmf->stm->owner))  in stm_char_open()
507 	file->private_data = stmf;  in stm_char_open()
522 	struct stm_file *stmf = file->private_data;  in stm_char_release()
523 	struct stm_device *stm = stmf->stm;  in stm_char_release()
525 	if (stm->data->unlink)  in stm_char_release()
526 		stm->data->unlink(stm->data, stmf->output.master,  in stm_char_release()
527 				  stmf->output.channel);  in stm_char_release()
529 	stm_output_free(stm, &stmf->output);  in stm_char_release()
543 			char **ids, unsigned int width)  in stm_assign_first_policy()  argument
551 	 * stp_policy_node_put(). This allows the pdrv->output_open() in  in stm_assign_first_policy()
558 		return -EINVAL;  in stm_assign_first_policy()
560 	err = stm_output_assign(stm, width, pn, output);  in stm_assign_first_policy()
568  * stm_data_write() - send the given payload as data packets
585 		sz = min_t(unsigned int, count - pos, 8);  in stm_data_write()
586 		sz = data->packet(data, m, c, STP_PACKET_DATA, flags, sz,  in stm_data_write()
607 	/* stm->pdrv is serialized against policy_mutex */  in stm_write()
608 	if (!stm->pdrv)  in stm_write()
609 		return -ENODEV;  in stm_write()
611 	err = stm->pdrv->write(stm->data, output, chan, buf, count, source);  in stm_write()
621 	struct stm_file *stmf = file->private_data;  in stm_char_write()
622 	struct stm_device *stm = stmf->stm;  in stm_char_write()
627 		count = PAGE_SIZE - 1;  in stm_char_write()
633 	if (!stmf->output.nr_chans) {  in stm_char_write()
634 		char comm[sizeof(current->comm)];  in stm_char_write()
639 		err = stm_assign_first_policy(stmf->stm, &stmf->output, ids, 1);  in stm_char_write()
650 		return -ENOMEM;  in stm_char_write()
655 		return -EFAULT;  in stm_char_write()
658 	pm_runtime_get_sync(&stm->dev);  in stm_char_write()
660 	count = stm_write(stm, &stmf->output, 0, kbuf, count, NULL);  in stm_char_write()
662 	pm_runtime_mark_last_busy(&stm->dev);  in stm_char_write()
663 	pm_runtime_put_autosuspend(&stm->dev);  in stm_char_write()
671 	struct stm_file *stmf = vma->vm_file->private_data;  in stm_mmap_open()
672 	struct stm_device *stm = stmf->stm;  in stm_mmap_open()
674 	pm_runtime_get(&stm->dev);  in stm_mmap_open()
679 	struct stm_file *stmf = vma->vm_file->private_data;  in stm_mmap_close()
680 	struct stm_device *stm = stmf->stm;  in stm_mmap_close()
682 	pm_runtime_mark_last_busy(&stm->dev);  in stm_mmap_close()
683 	pm_runtime_put_autosuspend(&stm->dev);  in stm_mmap_close()
693 	struct stm_file *stmf = file->private_data;  in stm_char_mmap()
694 	struct stm_device *stm = stmf->stm;  in stm_char_mmap()
697 	if (!stm->data->mmio_addr)  in stm_char_mmap()
698 		return -EOPNOTSUPP;  in stm_char_mmap()
700 	if (vma->vm_pgoff)  in stm_char_mmap()
701 		return -EINVAL;  in stm_char_mmap()
703 	size = vma->vm_end - vma->vm_start;  in stm_char_mmap()
705 	if (stmf->output.nr_chans * stm->data->sw_mmiosz != size)  in stm_char_mmap()
706 		return -EINVAL;  in stm_char_mmap()
708 	phys = stm->data->mmio_addr(stm->data, stmf->output.master,  in stm_char_mmap()
709 				    stmf->output.channel,  in stm_char_mmap()
710 				    stmf->output.nr_chans);  in stm_char_mmap()
713 		return -EINVAL;  in stm_char_mmap()
715 	pm_runtime_get_sync(&stm->dev);  in stm_char_mmap()
717 	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);  in stm_char_mmap()
719 	vma->vm_ops = &stm_mmap_vmops;  in stm_char_mmap()
727 	struct stm_device *stm = stmf->stm;  in stm_char_policy_set_ioctl()
730 	int ret = -EINVAL, wlimit = 1;  in stm_char_policy_set_ioctl()
733 	if (stmf->output.nr_chans)  in stm_char_policy_set_ioctl()
734 		return -EBUSY;  in stm_char_policy_set_ioctl()
737 		return -EFAULT;  in stm_char_policy_set_ioctl()
740 		return -EINVAL;  in stm_char_policy_set_ioctl()
748 		return -ENOMEM;  in stm_char_policy_set_ioctl()
751 		ret = -EFAULT;  in stm_char_policy_set_ioctl()
755 	if (id->__reserved_0 || id->__reserved_1)  in stm_char_policy_set_ioctl()
758 	if (stm->data->sw_mmiosz)  in stm_char_policy_set_ioctl()
759 		wlimit = PAGE_SIZE / stm->data->sw_mmiosz;  in stm_char_policy_set_ioctl()
761 	if (id->width < 1 || id->width > wlimit)  in stm_char_policy_set_ioctl()
764 	ids[0] = id->id;  in stm_char_policy_set_ioctl()
765 	ret = stm_assign_first_policy(stmf->stm, &stmf->output, ids,  in stm_char_policy_set_ioctl()
766 				      id->width);  in stm_char_policy_set_ioctl()
770 	if (stm->data->link)  in stm_char_policy_set_ioctl()
771 		ret = stm->data->link(stm->data, stmf->output.master,  in stm_char_policy_set_ioctl()
772 				      stmf->output.channel);  in stm_char_policy_set_ioctl()
775 		stm_output_free(stmf->stm, &stmf->output);  in stm_char_policy_set_ioctl()
787 		.master		= stmf->output.master,  in stm_char_policy_get_ioctl()
788 		.channel	= stmf->output.channel,  in stm_char_policy_get_ioctl()
789 		.width		= stmf->output.nr_chans,  in stm_char_policy_get_ioctl()
794 	return copy_to_user(arg, &id, id.size) ? -EFAULT : 0;  in stm_char_policy_get_ioctl()
800 	struct stm_file *stmf = file->private_data;  in stm_char_ioctl()
801 	struct stm_data *stm_data = stmf->stm->data;  in stm_char_ioctl()
802 	int err = -ENOTTY;  in stm_char_ioctl()
818 			return -EFAULT;  in stm_char_ioctl()
820 		if (stm_data->set_options)  in stm_char_ioctl()
821 			err = stm_data->set_options(stm_data,  in stm_char_ioctl()
822 						    stmf->output.master,  in stm_char_ioctl()
823 						    stmf->output.channel,  in stm_char_ioctl()
824 						    stmf->output.nr_chans,  in stm_char_ioctl()
844 static void stm_device_release(struct device *dev)  in stm_device_release()
851 int stm_register_device(struct device *parent, struct stm_data *stm_data,  in stm_register_device()
856 	int err = -ENOMEM;  in stm_register_device()
859 		return -EPROBE_DEFER;  in stm_register_device()
861 	if (!stm_data->packet || !stm_data->sw_nchannels)  in stm_register_device()
862 		return -EINVAL;  in stm_register_device()
864 	nmasters = stm_data->sw_end - stm_data->sw_start + 1;  in stm_register_device()
867 		return -ENOMEM;  in stm_register_device()
869 	stm->major = register_chrdev(0, stm_data->name, &stm_fops);  in stm_register_device()
870 	if (stm->major < 0) {  in stm_register_device()
871 		err = stm->major;  in stm_register_device()
876 	device_initialize(&stm->dev);  in stm_register_device()
877 	stm->dev.devt = MKDEV(stm->major, 0);  in stm_register_device()
878 	stm->dev.class = &stm_class;  in stm_register_device()
879 	stm->dev.parent = parent;  in stm_register_device()
880 	stm->dev.release = stm_device_release;  in stm_register_device()
882 	mutex_init(&stm->link_mutex);  in stm_register_device()
883 	spin_lock_init(&stm->link_lock);  in stm_register_device()
884 	INIT_LIST_HEAD(&stm->link_list);  in stm_register_device()
887 	spin_lock_init(&stm->mc_lock);  in stm_register_device()
888 	mutex_init(&stm->policy_mutex);  in stm_register_device()
889 	stm->sw_nmasters = nmasters;  in stm_register_device()
890 	stm->owner = owner;  in stm_register_device()
891 	stm->data = stm_data;  in stm_register_device()
892 	stm_data->stm = stm;  in stm_register_device()
894 	err = kobject_set_name(&stm->dev.kobj, "%s", stm_data->name);  in stm_register_device()
898 	err = device_add(&stm->dev);  in stm_register_device()
904 	 * on recurring character device writes, with the initial  in stm_register_device()
907 	pm_runtime_no_callbacks(&stm->dev);  in stm_register_device()
908 	pm_runtime_use_autosuspend(&stm->dev);  in stm_register_device()
909 	pm_runtime_set_autosuspend_delay(&stm->dev, 2000);  in stm_register_device()
910 	pm_runtime_set_suspended(&stm->dev);  in stm_register_device()
911 	pm_runtime_enable(&stm->dev);  in stm_register_device()
916 	unregister_chrdev(stm->major, stm_data->name);  in stm_register_device()
919 	put_device(&stm->dev);  in stm_register_device()
930 	struct stm_device *stm = stm_data->stm;  in stm_unregister_device()
934 	pm_runtime_dont_use_autosuspend(&stm->dev);  in stm_unregister_device()
935 	pm_runtime_disable(&stm->dev);  in stm_unregister_device()
937 	mutex_lock(&stm->link_mutex);  in stm_unregister_device()
938 	list_for_each_entry_safe(src, iter, &stm->link_list, link_entry) {  in stm_unregister_device()
941 		 * src <-> stm link must not change under the same  in stm_unregister_device()
945 		 * safe to proceed with the tear-down of stm.  in stm_unregister_device()
949 	mutex_unlock(&stm->link_mutex);  in stm_unregister_device()
953 	unregister_chrdev(stm->major, stm_data->name);  in stm_unregister_device()
955 	mutex_lock(&stm->policy_mutex);  in stm_unregister_device()
956 	if (stm->policy)  in stm_unregister_device()
957 		stp_policy_unbind(stm->policy);  in stm_unregister_device()
958 	mutex_unlock(&stm->policy_mutex);  in stm_unregister_device()
960 	for (i = stm->data->sw_start; i <= stm->data->sw_end; i++)  in stm_unregister_device()
963 	device_unregister(&stm->dev);  in stm_unregister_device()
964 	stm_data->stm = NULL;  in stm_unregister_device()
980  * stm_source_link_add() - connect an stm_source device to an stm device
981  * @src:	stm_source device
982  * @stm:	stm device
984  * This function establishes a link from stm_source to an stm device so that
987  * Return:	0 on success, -errno otherwise.
993 	int err = -ENOMEM;  in stm_source_link_add()
995 	mutex_lock(&stm->link_mutex);  in stm_source_link_add()
996 	spin_lock(&stm->link_lock);  in stm_source_link_add()
997 	spin_lock(&src->link_lock);  in stm_source_link_add()
999 	/* src->link is dereferenced under stm_source_srcu but not the list */  in stm_source_link_add()
1000 	rcu_assign_pointer(src->link, stm);  in stm_source_link_add()
1001 	list_add_tail(&src->link_entry, &stm->link_list);  in stm_source_link_add()
1003 	spin_unlock(&src->link_lock);  in stm_source_link_add()
1004 	spin_unlock(&stm->link_lock);  in stm_source_link_add()
1005 	mutex_unlock(&stm->link_mutex);  in stm_source_link_add()
1007 	ids[0] = kstrdup(src->data->name, GFP_KERNEL);  in stm_source_link_add()
1011 	err = stm_assign_first_policy(stm, &src->output, ids,  in stm_source_link_add()
1012 				      src->data->nr_chans);  in stm_source_link_add()
1018 	/* this is to notify the STM device that a new link has been made */  in stm_source_link_add()
1019 	if (stm->data->link)  in stm_source_link_add()
1020 		err = stm->data->link(stm->data, src->output.master,  in stm_source_link_add()
1021 				      src->output.channel);  in stm_source_link_add()
1027 	if (src->data->link)  in stm_source_link_add()
1028 		src->data->link(src->data);  in stm_source_link_add()
1033 	stm_output_free(stm, &src->output);  in stm_source_link_add()
1036 	mutex_lock(&stm->link_mutex);  in stm_source_link_add()
1037 	spin_lock(&stm->link_lock);  in stm_source_link_add()
1038 	spin_lock(&src->link_lock);  in stm_source_link_add()
1040 	rcu_assign_pointer(src->link, NULL);  in stm_source_link_add()
1041 	list_del_init(&src->link_entry);  in stm_source_link_add()
1043 	spin_unlock(&src->link_lock);  in stm_source_link_add()
1044 	spin_unlock(&stm->link_lock);  in stm_source_link_add()
1045 	mutex_unlock(&stm->link_mutex);  in stm_source_link_add()
1051  * __stm_source_link_drop() - detach stm_source from an stm device
1052  * @src:	stm_source device
1053  * @stm:	stm device
1056  * reference on the @stm device.
1066 	lockdep_assert_held(&stm->link_mutex);  in __stm_source_link_drop()
1069 	spin_lock(&stm->link_lock);  in __stm_source_link_drop()
1070 	spin_lock(&src->link_lock);  in __stm_source_link_drop()
1071 	link = srcu_dereference_check(src->link, &stm_source_srcu, 1);  in __stm_source_link_drop()
1074 	 * The linked device may have changed since we last looked, because  in __stm_source_link_drop()
1079 		ret = -EAGAIN;  in __stm_source_link_drop()
1083 	stm_output_free(link, &src->output);  in __stm_source_link_drop()
1084 	list_del_init(&src->link_entry);  in __stm_source_link_drop()
1085 	pm_runtime_mark_last_busy(&link->dev);  in __stm_source_link_drop()
1086 	pm_runtime_put_autosuspend(&link->dev);  in __stm_source_link_drop()
1089 	rcu_assign_pointer(src->link, NULL);  in __stm_source_link_drop()
1092 	spin_unlock(&src->link_lock);  in __stm_source_link_drop()
1093 	spin_unlock(&stm->link_lock);  in __stm_source_link_drop()
1100 		if (src->data->unlink)  in __stm_source_link_drop()
1101 			src->data->unlink(src->data);  in __stm_source_link_drop()
1103 		if (stm->data->unlink)  in __stm_source_link_drop()
1104 			stm->data->unlink(stm->data, src->output.master,  in __stm_source_link_drop()
1105 					  src->output.channel);  in __stm_source_link_drop()
1112  * stm_source_link_drop() - detach stm_source from its stm device
1113  * @src:	stm_source device
1115  * Unlinking means disconnecting from source's STM device; after this
1116  * writes will be unsuccessful until it is linked to a new STM device.
1119  * the existing link (if any), or on linked STM device's de-registration.
1129 	 * The stm device will be valid for the duration of this  in stm_source_link_drop()
1133 	stm = srcu_dereference(src->link, &stm_source_srcu);  in stm_source_link_drop()
1137 		mutex_lock(&stm->link_mutex);  in stm_source_link_drop()
1139 		mutex_unlock(&stm->link_mutex);  in stm_source_link_drop()
1145 	if (ret == -EAGAIN)  in stm_source_link_drop()
1149 static ssize_t stm_source_link_show(struct device *dev,  in stm_source_link_show()
1158 	stm = srcu_dereference(src->link, &stm_source_srcu);  in stm_source_link_show()
1160 		      stm ? dev_name(&stm->dev) : "<none>");  in stm_source_link_show()
1166 static ssize_t stm_source_link_store(struct device *dev,  in stm_source_link_store()
1178 		return -EINVAL;  in stm_source_link_store()
1180 	pm_runtime_get(&link->dev);  in stm_source_link_store()
1184 		pm_runtime_put_autosuspend(&link->dev);  in stm_source_link_store()
1206 static void stm_source_device_release(struct device *dev)  in stm_source_device_release()
1214  * stm_source_register_device() - register an stm_source device
1215  * @parent:	parent device
1216  * @data:	device description structure
1218  * This will create a device of stm_source class that can write
1219  * data to an stm device once linked.
1221  * Return:	0 on success, -errno otherwise.
1223 int stm_source_register_device(struct device *parent,  in stm_source_register_device()
1230 		return -EPROBE_DEFER;  in stm_source_register_device()
1234 		return -ENOMEM;  in stm_source_register_device()
1236 	device_initialize(&src->dev);  in stm_source_register_device()
1237 	src->dev.class = &stm_source_class;  in stm_source_register_device()
1238 	src->dev.parent = parent;  in stm_source_register_device()
1239 	src->dev.release = stm_source_device_release;  in stm_source_register_device()
1241 	err = kobject_set_name(&src->dev.kobj, "%s", data->name);  in stm_source_register_device()
1245 	pm_runtime_no_callbacks(&src->dev);  in stm_source_register_device()
1246 	pm_runtime_forbid(&src->dev);  in stm_source_register_device()
1248 	err = device_add(&src->dev);  in stm_source_register_device()
1252 	stm_output_init(&src->output);  in stm_source_register_device()
1253 	spin_lock_init(&src->link_lock);  in stm_source_register_device()
1254 	INIT_LIST_HEAD(&src->link_entry);  in stm_source_register_device()
1255 	src->data = data;  in stm_source_register_device()
1256 	data->src = src;  in stm_source_register_device()
1261 	put_device(&src->dev);  in stm_source_register_device()
1268  * stm_source_unregister_device() - unregister an stm_source device
1269  * @data:	device description that was used to register the device
1271  * This will remove a previously created stm_source device from the system.
1275 	struct stm_source_device *src = data->src;  in stm_source_unregister_device()
1279 	device_unregister(&src->dev);  in stm_source_unregister_device()
1287 	struct stm_source_device *src = data->src;  in stm_source_write()
1291 	if (!src->output.nr_chans)  in stm_source_write()
1292 		return -ENODEV;  in stm_source_write()
1294 	if (chan >= src->output.nr_chans)  in stm_source_write()
1295 		return -EINVAL;  in stm_source_write()
1299 	stm = srcu_dereference(src->link, &stm_source_srcu);  in stm_source_write()
1301 		count = stm_write(stm, &src->output, chan, buf, count, data);  in stm_source_write()
1303 		count = -ENODEV;  in stm_source_write()
1362 MODULE_DESCRIPTION("System Trace Module device class");