1// SPDX-License-Identifier: GPL-2.0
  2/**
  3 * configfs to configure the PCI endpoint
  4 *
  5 * Copyright (C) 2017 Texas Instruments
  6 * Author: Kishon Vijay Abraham I <kishon@ti.com>
  7 */
  8
  9#include <linux/module.h>
 10#include <linux/idr.h>
 11#include <linux/slab.h>
 12
 13#include <linux/pci-epc.h>
 14#include <linux/pci-epf.h>
 15#include <linux/pci-ep-cfs.h>
 16
 17static DEFINE_IDR(functions_idr);
 18static DEFINE_MUTEX(functions_mutex);
 19static struct config_group *functions_group;
 20static struct config_group *controllers_group;
 21
 22struct pci_epf_group {
 23	struct config_group group;
 24	struct pci_epf *epf;
 25	int index;
 26};
 27
 28struct pci_epc_group {
 29	struct config_group group;
 30	struct pci_epc *epc;
 31	bool start;
 32	unsigned long function_num_map;
 33};
 34
 35static inline struct pci_epf_group *to_pci_epf_group(struct config_item *item)
 36{
 37	return container_of(to_config_group(item), struct pci_epf_group, group);
 38}
 39
 40static inline struct pci_epc_group *to_pci_epc_group(struct config_item *item)
 41{
 42	return container_of(to_config_group(item), struct pci_epc_group, group);
 43}
 44
 45static ssize_t pci_epc_start_store(struct config_item *item, const char *page,
 46				   size_t len)
 47{
 48	int ret;
 49	bool start;
 50	struct pci_epc *epc;
 51	struct pci_epc_group *epc_group = to_pci_epc_group(item);
 52
 53	epc = epc_group->epc;
 54
 55	ret = kstrtobool(page, &start);
 56	if (ret)
 57		return ret;
 58
 59	if (!start) {
 60		pci_epc_stop(epc);
 61		return len;
 62	}
 63
 64	ret = pci_epc_start(epc);
 65	if (ret) {
 66		dev_err(&epc->dev, "failed to start endpoint controller\n");
 67		return -EINVAL;
 68	}
 69
 70	epc_group->start = start;
 71
 72	return len;
 73}
 74
 75static ssize_t pci_epc_start_show(struct config_item *item, char *page)
 76{
 77	return sprintf(page, "%d\n",
 78		       to_pci_epc_group(item)->start);
 79}
 80
 81CONFIGFS_ATTR(pci_epc_, start);
 82
 83static struct configfs_attribute *pci_epc_attrs[] = {
 84	&pci_epc_attr_start,
 85	NULL,
 86};
 87
 88static int pci_epc_epf_link(struct config_item *epc_item,
 89			    struct config_item *epf_item)
 90{
 91	int ret;
 92	u32 func_no = 0;
 93	struct pci_epf_group *epf_group = to_pci_epf_group(epf_item);
 94	struct pci_epc_group *epc_group = to_pci_epc_group(epc_item);
 95	struct pci_epc *epc = epc_group->epc;
 96	struct pci_epf *epf = epf_group->epf;
 97
 98	func_no = find_first_zero_bit(&epc_group->function_num_map,
 99				      BITS_PER_LONG);
100	if (func_no >= BITS_PER_LONG)
101		return -EINVAL;
102
103	set_bit(func_no, &epc_group->function_num_map);
104	epf->func_no = func_no;
105
106	ret = pci_epc_add_epf(epc, epf);
107	if (ret)
108		goto err_add_epf;
109
110	ret = pci_epf_bind(epf);
111	if (ret)
112		goto err_epf_bind;
113
114	return 0;
115
116err_epf_bind:
117	pci_epc_remove_epf(epc, epf);
118
119err_add_epf:
120	clear_bit(func_no, &epc_group->function_num_map);
121
122	return ret;
123}
124
125static void pci_epc_epf_unlink(struct config_item *epc_item,
126			       struct config_item *epf_item)
127{
128	struct pci_epc *epc;
129	struct pci_epf *epf;
130	struct pci_epf_group *epf_group = to_pci_epf_group(epf_item);
131	struct pci_epc_group *epc_group = to_pci_epc_group(epc_item);
132
133	WARN_ON_ONCE(epc_group->start);
134
135	epc = epc_group->epc;
136	epf = epf_group->epf;
137	clear_bit(epf->func_no, &epc_group->function_num_map);
138	pci_epf_unbind(epf);
139	pci_epc_remove_epf(epc, epf);
140}
141
142static struct configfs_item_operations pci_epc_item_ops = {
143	.allow_link	= pci_epc_epf_link,
144	.drop_link	= pci_epc_epf_unlink,
145};
146
147static const struct config_item_type pci_epc_type = {
148	.ct_item_ops	= &pci_epc_item_ops,
149	.ct_attrs	= pci_epc_attrs,
150	.ct_owner	= THIS_MODULE,
151};
152
153struct config_group *pci_ep_cfs_add_epc_group(const char *name)
154{
155	int ret;
156	struct pci_epc *epc;
157	struct config_group *group;
158	struct pci_epc_group *epc_group;
159
160	epc_group = kzalloc(sizeof(*epc_group), GFP_KERNEL);
161	if (!epc_group) {
162		ret = -ENOMEM;
163		goto err;
164	}
165
166	group = &epc_group->group;
167
168	config_group_init_type_name(group, name, &pci_epc_type);
169	ret = configfs_register_group(controllers_group, group);
170	if (ret) {
171		pr_err("failed to register configfs group for %s\n", name);
172		goto err_register_group;
173	}
174
175	epc = pci_epc_get(name);
176	if (IS_ERR(epc)) {
177		ret = PTR_ERR(epc);
178		goto err_epc_get;
179	}
180
181	epc_group->epc = epc;
182
183	return group;
184
185err_epc_get:
186	configfs_unregister_group(group);
187
188err_register_group:
189	kfree(epc_group);
190
191err:
192	return ERR_PTR(ret);
193}
194EXPORT_SYMBOL(pci_ep_cfs_add_epc_group);
195
196void pci_ep_cfs_remove_epc_group(struct config_group *group)
197{
198	struct pci_epc_group *epc_group;
199
200	if (!group)
201		return;
202
203	epc_group = container_of(group, struct pci_epc_group, group);
204	pci_epc_put(epc_group->epc);
205	configfs_unregister_group(&epc_group->group);
206	kfree(epc_group);
207}
208EXPORT_SYMBOL(pci_ep_cfs_remove_epc_group);
209
210#define PCI_EPF_HEADER_R(_name)						       \
211static ssize_t pci_epf_##_name##_show(struct config_item *item,	char *page)    \
212{									       \
213	struct pci_epf *epf = to_pci_epf_group(item)->epf;		       \
214	if (WARN_ON_ONCE(!epf->header))					       \
215		return -EINVAL;						       \
216	return sprintf(page, "0x%04x\n", epf->header->_name);		       \
217}
218
219#define PCI_EPF_HEADER_W_u32(_name)					       \
220static ssize_t pci_epf_##_name##_store(struct config_item *item,	       \
221				       const char *page, size_t len)	       \
222{									       \
223	u32 val;							       \
224	int ret;							       \
225	struct pci_epf *epf = to_pci_epf_group(item)->epf;		       \
226	if (WARN_ON_ONCE(!epf->header))					       \
227		return -EINVAL;						       \
228	ret = kstrtou32(page, 0, &val);					       \
229	if (ret)							       \
230		return ret;						       \
231	epf->header->_name = val;					       \
232	return len;							       \
233}
234
235#define PCI_EPF_HEADER_W_u16(_name)					       \
236static ssize_t pci_epf_##_name##_store(struct config_item *item,	       \
237				       const char *page, size_t len)	       \
238{									       \
239	u16 val;							       \
240	int ret;							       \
241	struct pci_epf *epf = to_pci_epf_group(item)->epf;		       \
242	if (WARN_ON_ONCE(!epf->header))					       \
243		return -EINVAL;						       \
244	ret = kstrtou16(page, 0, &val);					       \
245	if (ret)							       \
246		return ret;						       \
247	epf->header->_name = val;					       \
248	return len;							       \
249}
250
251#define PCI_EPF_HEADER_W_u8(_name)					       \
252static ssize_t pci_epf_##_name##_store(struct config_item *item,	       \
253				       const char *page, size_t len)	       \
254{									       \
255	u8 val;								       \
256	int ret;							       \
257	struct pci_epf *epf = to_pci_epf_group(item)->epf;		       \
258	if (WARN_ON_ONCE(!epf->header))					       \
259		return -EINVAL;						       \
260	ret = kstrtou8(page, 0, &val);					       \
261	if (ret)							       \
262		return ret;						       \
263	epf->header->_name = val;					       \
264	return len;							       \
265}
266
267static ssize_t pci_epf_msi_interrupts_store(struct config_item *item,
268					    const char *page, size_t len)
269{
270	u8 val;
271	int ret;
272
273	ret = kstrtou8(page, 0, &val);
274	if (ret)
275		return ret;
276
277	to_pci_epf_group(item)->epf->msi_interrupts = val;
278
279	return len;
280}
281
282static ssize_t pci_epf_msi_interrupts_show(struct config_item *item,
283					   char *page)
284{
285	return sprintf(page, "%d\n",
286		       to_pci_epf_group(item)->epf->msi_interrupts);
287}
288
289static ssize_t pci_epf_msix_interrupts_store(struct config_item *item,
290					     const char *page, size_t len)
291{
292	u16 val;
293	int ret;
294
295	ret = kstrtou16(page, 0, &val);
296	if (ret)
297		return ret;
298
299	to_pci_epf_group(item)->epf->msix_interrupts = val;
300
301	return len;
302}
303
304static ssize_t pci_epf_msix_interrupts_show(struct config_item *item,
305					    char *page)
306{
307	return sprintf(page, "%d\n",
308		       to_pci_epf_group(item)->epf->msix_interrupts);
309}
310
311PCI_EPF_HEADER_R(vendorid)
312PCI_EPF_HEADER_W_u16(vendorid)
313
314PCI_EPF_HEADER_R(deviceid)
315PCI_EPF_HEADER_W_u16(deviceid)
316
317PCI_EPF_HEADER_R(revid)
318PCI_EPF_HEADER_W_u8(revid)
319
320PCI_EPF_HEADER_R(progif_code)
321PCI_EPF_HEADER_W_u8(progif_code)
322
323PCI_EPF_HEADER_R(subclass_code)
324PCI_EPF_HEADER_W_u8(subclass_code)
325
326PCI_EPF_HEADER_R(baseclass_code)
327PCI_EPF_HEADER_W_u8(baseclass_code)
328
329PCI_EPF_HEADER_R(cache_line_size)
330PCI_EPF_HEADER_W_u8(cache_line_size)
331
332PCI_EPF_HEADER_R(subsys_vendor_id)
333PCI_EPF_HEADER_W_u16(subsys_vendor_id)
334
335PCI_EPF_HEADER_R(subsys_id)
336PCI_EPF_HEADER_W_u16(subsys_id)
337
338PCI_EPF_HEADER_R(interrupt_pin)
339PCI_EPF_HEADER_W_u8(interrupt_pin)
340
341CONFIGFS_ATTR(pci_epf_, vendorid);
342CONFIGFS_ATTR(pci_epf_, deviceid);
343CONFIGFS_ATTR(pci_epf_, revid);
344CONFIGFS_ATTR(pci_epf_, progif_code);
345CONFIGFS_ATTR(pci_epf_, subclass_code);
346CONFIGFS_ATTR(pci_epf_, baseclass_code);
347CONFIGFS_ATTR(pci_epf_, cache_line_size);
348CONFIGFS_ATTR(pci_epf_, subsys_vendor_id);
349CONFIGFS_ATTR(pci_epf_, subsys_id);
350CONFIGFS_ATTR(pci_epf_, interrupt_pin);
351CONFIGFS_ATTR(pci_epf_, msi_interrupts);
352CONFIGFS_ATTR(pci_epf_, msix_interrupts);
353
354static struct configfs_attribute *pci_epf_attrs[] = {
355	&pci_epf_attr_vendorid,
356	&pci_epf_attr_deviceid,
357	&pci_epf_attr_revid,
358	&pci_epf_attr_progif_code,
359	&pci_epf_attr_subclass_code,
360	&pci_epf_attr_baseclass_code,
361	&pci_epf_attr_cache_line_size,
362	&pci_epf_attr_subsys_vendor_id,
363	&pci_epf_attr_subsys_id,
364	&pci_epf_attr_interrupt_pin,
365	&pci_epf_attr_msi_interrupts,
366	&pci_epf_attr_msix_interrupts,
367	NULL,
368};
369
370static void pci_epf_release(struct config_item *item)
371{
372	struct pci_epf_group *epf_group = to_pci_epf_group(item);
373
374	mutex_lock(&functions_mutex);
375	idr_remove(&functions_idr, epf_group->index);
376	mutex_unlock(&functions_mutex);
377	pci_epf_destroy(epf_group->epf);
378	kfree(epf_group);
379}
380
381static struct configfs_item_operations pci_epf_ops = {
382	.release		= pci_epf_release,
383};
384
385static const struct config_item_type pci_epf_type = {
386	.ct_item_ops	= &pci_epf_ops,
387	.ct_attrs	= pci_epf_attrs,
388	.ct_owner	= THIS_MODULE,
389};
390
391static struct config_group *pci_epf_make(struct config_group *group,
392					 const char *name)
393{
394	struct pci_epf_group *epf_group;
395	struct pci_epf *epf;
396	char *epf_name;
397	int index, err;
398
399	epf_group = kzalloc(sizeof(*epf_group), GFP_KERNEL);
400	if (!epf_group)
401		return ERR_PTR(-ENOMEM);
402
403	mutex_lock(&functions_mutex);
404	index = idr_alloc(&functions_idr, epf_group, 0, 0, GFP_KERNEL);
405	mutex_unlock(&functions_mutex);
406	if (index < 0) {
407		err = index;
408		goto free_group;
409	}
410
411	epf_group->index = index;
412
413	config_group_init_type_name(&epf_group->group, name, &pci_epf_type);
414
415	epf_name = kasprintf(GFP_KERNEL, "%s.%d",
416			     group->cg_item.ci_name, epf_group->index);
417	if (!epf_name) {
418		err = -ENOMEM;
419		goto remove_idr;
420	}
421
422	epf = pci_epf_create(epf_name);
423	if (IS_ERR(epf)) {
424		pr_err("failed to create endpoint function device\n");
425		err = -EINVAL;
426		goto free_name;
427	}
428
429	epf_group->epf = epf;
430
431	kfree(epf_name);
432
433	return &epf_group->group;
434
435free_name:
436	kfree(epf_name);
437
438remove_idr:
439	mutex_lock(&functions_mutex);
440	idr_remove(&functions_idr, epf_group->index);
441	mutex_unlock(&functions_mutex);
442
443free_group:
444	kfree(epf_group);
445
446	return ERR_PTR(err);
447}
448
449static void pci_epf_drop(struct config_group *group, struct config_item *item)
450{
451	config_item_put(item);
452}
453
454static struct configfs_group_operations pci_epf_group_ops = {
455	.make_group     = &pci_epf_make,
456	.drop_item      = &pci_epf_drop,
457};
458
459static const struct config_item_type pci_epf_group_type = {
460	.ct_group_ops	= &pci_epf_group_ops,
461	.ct_owner	= THIS_MODULE,
462};
463
464struct config_group *pci_ep_cfs_add_epf_group(const char *name)
465{
466	struct config_group *group;
467
468	group = configfs_register_default_group(functions_group, name,
469						&pci_epf_group_type);
470	if (IS_ERR(group))
471		pr_err("failed to register configfs group for %s function\n",
472		       name);
473
474	return group;
475}
476EXPORT_SYMBOL(pci_ep_cfs_add_epf_group);
477
478void pci_ep_cfs_remove_epf_group(struct config_group *group)
479{
480	if (IS_ERR_OR_NULL(group))
481		return;
482
483	configfs_unregister_default_group(group);
484}
485EXPORT_SYMBOL(pci_ep_cfs_remove_epf_group);
486
487static const struct config_item_type pci_functions_type = {
488	.ct_owner	= THIS_MODULE,
489};
490
491static const struct config_item_type pci_controllers_type = {
492	.ct_owner	= THIS_MODULE,
493};
494
495static const struct config_item_type pci_ep_type = {
496	.ct_owner	= THIS_MODULE,
497};
498
499static struct configfs_subsystem pci_ep_cfs_subsys = {
500	.su_group = {
501		.cg_item = {
502			.ci_namebuf = "pci_ep",
503			.ci_type = &pci_ep_type,
504		},
505	},
506	.su_mutex = __MUTEX_INITIALIZER(pci_ep_cfs_subsys.su_mutex),
507};
508
509static int __init pci_ep_cfs_init(void)
510{
511	int ret;
512	struct config_group *root = &pci_ep_cfs_subsys.su_group;
513
514	config_group_init(root);
515
516	ret = configfs_register_subsystem(&pci_ep_cfs_subsys);
517	if (ret) {
518		pr_err("Error %d while registering subsystem %s\n",
519		       ret, root->cg_item.ci_namebuf);
520		goto err;
521	}
522
523	functions_group = configfs_register_default_group(root, "functions",
524							  &pci_functions_type);
525	if (IS_ERR(functions_group)) {
526		ret = PTR_ERR(functions_group);
527		pr_err("Error %d while registering functions group\n",
528		       ret);
529		goto err_functions_group;
530	}
531
532	controllers_group =
533		configfs_register_default_group(root, "controllers",
534						&pci_controllers_type);
535	if (IS_ERR(controllers_group)) {
536		ret = PTR_ERR(controllers_group);
537		pr_err("Error %d while registering controllers group\n",
538		       ret);
539		goto err_controllers_group;
540	}
541
542	return 0;
543
544err_controllers_group:
545	configfs_unregister_default_group(functions_group);
546
547err_functions_group:
548	configfs_unregister_subsystem(&pci_ep_cfs_subsys);
549
550err:
551	return ret;
552}
553module_init(pci_ep_cfs_init);
554
555static void __exit pci_ep_cfs_exit(void)
556{
557	configfs_unregister_default_group(controllers_group);
558	configfs_unregister_default_group(functions_group);
559	configfs_unregister_subsystem(&pci_ep_cfs_subsys);
560}
561module_exit(pci_ep_cfs_exit);
562
563MODULE_DESCRIPTION("PCI EP CONFIGFS");
564MODULE_AUTHOR("Kishon Vijay Abraham I <kishon@ti.com>");
565MODULE_LICENSE("GPL v2");