1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright (C) 2015-2017 Pengutronix, Uwe Kleine-König <kernel@pengutronix.de>
  4 */
  5#include <linux/kernel.h>
  6#include <linux/device.h>
  7#include <linux/module.h>
  8#include <linux/slab.h>
  9#include <linux/sysfs.h>
 10
 11#include "siox.h"
 12
 13/*
 14 * The lowest bit in the SIOX status word signals if the in-device watchdog is
 15 * ok. If the bit is set, the device is functional.
 16 *
 17 * On writing the watchdog timer is reset when this bit toggles.
 18 */
 19#define SIOX_STATUS_WDG			0x01
 20
 21/*
 22 * Bits 1 to 3 of the status word read as the bitwise negation of what was
 23 * clocked in before. The value clocked in is changed in each cycle and so
 24 * allows to detect transmit/receive problems.
 25 */
 26#define SIOX_STATUS_COUNTER		0x0e
 27
 28/*
 29 * Each Siox-Device has a 4 bit type number that is neither 0 nor 15. This is
 30 * available in the upper nibble of the read status.
 31 *
 32 * On write these bits are DC.
 33 */
 34#define SIOX_STATUS_TYPE		0xf0
 35
 36#define CREATE_TRACE_POINTS
 37#include <trace/events/siox.h>
 38
 39static bool siox_is_registered;
 40
 41static void siox_master_lock(struct siox_master *smaster)
 42{
 43	mutex_lock(&smaster->lock);
 44}
 45
 46static void siox_master_unlock(struct siox_master *smaster)
 47{
 48	mutex_unlock(&smaster->lock);
 49}
 50
 51static inline u8 siox_status_clean(u8 status_read, u8 status_written)
 52{
 53	/*
 54	 * bits 3:1 of status sample the respective bit in the status
 55	 * byte written in the previous cycle but inverted. So if you wrote the
 56	 * status word as 0xa before (counter = 0b101), it is expected to get
 57	 * back the counter bits as 0b010.
 58	 *
 59	 * So given the last status written this function toggles the there
 60	 * unset counter bits in the read value such that the counter bits in
 61	 * the return value are all zero iff the bits were read as expected to
 62	 * simplify error detection.
 63	 */
 64
 65	return status_read ^ (~status_written & 0xe);
 66}
 67
 68static bool siox_device_counter_error(struct siox_device *sdevice,
 69				      u8 status_clean)
 70{
 71	return (status_clean & SIOX_STATUS_COUNTER) != 0;
 72}
 73
 74static bool siox_device_type_error(struct siox_device *sdevice, u8 status_clean)
 75{
 76	u8 statustype = (status_clean & SIOX_STATUS_TYPE) >> 4;
 77
 78	/*
 79	 * If the device knows which value the type bits should have, check
 80	 * against this value otherwise just rule out the invalid values 0b0000
 81	 * and 0b1111.
 82	 */
 83	if (sdevice->statustype) {
 84		if (statustype != sdevice->statustype)
 85			return true;
 86	} else {
 87		switch (statustype) {
 88		case 0:
 89		case 0xf:
 90			return true;
 91		}
 92	}
 93
 94	return false;
 95}
 96
 97static bool siox_device_wdg_error(struct siox_device *sdevice, u8 status_clean)
 98{
 99	return (status_clean & SIOX_STATUS_WDG) == 0;
100}
101
102/*
103 * If there is a type or counter error the device is called "unsynced".
104 */
105bool siox_device_synced(struct siox_device *sdevice)
106{
107	if (siox_device_type_error(sdevice, sdevice->status_read_clean))
108		return false;
109
110	return !siox_device_counter_error(sdevice, sdevice->status_read_clean);
111
112}
113EXPORT_SYMBOL_GPL(siox_device_synced);
114
115/*
116 * A device is called "connected" if it is synced and the watchdog is not
117 * asserted.
118 */
119bool siox_device_connected(struct siox_device *sdevice)
120{
121	if (!siox_device_synced(sdevice))
122		return false;
123
124	return !siox_device_wdg_error(sdevice, sdevice->status_read_clean);
125}
126EXPORT_SYMBOL_GPL(siox_device_connected);
127
128static void siox_poll(struct siox_master *smaster)
129{
130	struct siox_device *sdevice;
131	size_t i = smaster->setbuf_len;
132	unsigned int devno = 0;
133	int unsync_error = 0;
134
135	smaster->last_poll = jiffies;
136
137	/*
138	 * The counter bits change in each second cycle, the watchdog bit
139	 * toggles each time.
140	 * The counter bits hold values from [0, 6]. 7 would be possible
141	 * theoretically but the protocol designer considered that a bad idea
142	 * for reasons unknown today. (Maybe that's because then the status read
143	 * back has only zeros in the counter bits then which might be confused
144	 * with a stuck-at-0 error. But for the same reason (with s/0/1/) 0
145	 * could be skipped.)
146	 */
147	if (++smaster->status > 0x0d)
148		smaster->status = 0;
149
150	memset(smaster->buf, 0, smaster->setbuf_len);
151
152	/* prepare data pushed out to devices in buf[0..setbuf_len) */
153	list_for_each_entry(sdevice, &smaster->devices, node) {
154		struct siox_driver *sdriver =
155			to_siox_driver(sdevice->dev.driver);
156		sdevice->status_written = smaster->status;
157
158		i -= sdevice->inbytes;
159
160		/*
161		 * If the device or a previous one is unsynced, don't pet the
162		 * watchdog. This is done to ensure that the device is kept in
163		 * reset when something is wrong.
164		 */
165		if (!siox_device_synced(sdevice))
166			unsync_error = 1;
167
168		if (sdriver && !unsync_error)
169			sdriver->set_data(sdevice, sdevice->status_written,
170					  &smaster->buf[i + 1]);
171		else
172			/*
173			 * Don't trigger watchdog if there is no driver or a
174			 * sync problem
175			 */
176			sdevice->status_written &= ~SIOX_STATUS_WDG;
177
178		smaster->buf[i] = sdevice->status_written;
179
180		trace_siox_set_data(smaster, sdevice, devno, i);
181
182		devno++;
183	}
184
185	smaster->pushpull(smaster, smaster->setbuf_len, smaster->buf,
186			  smaster->getbuf_len,
187			  smaster->buf + smaster->setbuf_len);
188
189	unsync_error = 0;
190
191	/* interpret data pulled in from devices in buf[setbuf_len..] */
192	devno = 0;
193	i = smaster->setbuf_len;
194	list_for_each_entry(sdevice, &smaster->devices, node) {
195		struct siox_driver *sdriver =
196			to_siox_driver(sdevice->dev.driver);
197		u8 status = smaster->buf[i + sdevice->outbytes - 1];
198		u8 status_clean;
199		u8 prev_status_clean = sdevice->status_read_clean;
200		bool synced = true;
201		bool connected = true;
202
203		if (!siox_device_synced(sdevice))
204			unsync_error = 1;
205
206		/*
207		 * If the watchdog bit wasn't toggled in this cycle, report the
208		 * watchdog as active to give a consistent view for drivers and
209		 * sysfs consumers.
210		 */
211		if (!sdriver || unsync_error)
212			status &= ~SIOX_STATUS_WDG;
213
214		status_clean =
215			siox_status_clean(status,
216					  sdevice->status_written_lastcycle);
217
218		/* Check counter and type bits */
219		if (siox_device_counter_error(sdevice, status_clean) ||
220		    siox_device_type_error(sdevice, status_clean)) {
221			bool prev_error;
222
223			synced = false;
224
225			/* only report a new error if the last cycle was ok */
226			prev_error =
227				siox_device_counter_error(sdevice,
228							  prev_status_clean) ||
229				siox_device_type_error(sdevice,
230						       prev_status_clean);
231
232			if (!prev_error) {
233				sdevice->status_errors++;
234				sysfs_notify_dirent(sdevice->status_errors_kn);
235			}
236		}
237
238		/* If the device is unsynced report the watchdog as active */
239		if (!synced) {
240			status &= ~SIOX_STATUS_WDG;
241			status_clean &= ~SIOX_STATUS_WDG;
242		}
243
244		if (siox_device_wdg_error(sdevice, status_clean))
245			connected = false;
246
247		/* The watchdog state changed just now */
248		if ((status_clean ^ prev_status_clean) & SIOX_STATUS_WDG) {
249			sysfs_notify_dirent(sdevice->watchdog_kn);
250
251			if (siox_device_wdg_error(sdevice, status_clean)) {
252				struct kernfs_node *wd_errs =
253					sdevice->watchdog_errors_kn;
254
255				sdevice->watchdog_errors++;
256				sysfs_notify_dirent(wd_errs);
257			}
258		}
259
260		if (connected != sdevice->connected)
261			sysfs_notify_dirent(sdevice->connected_kn);
262
263		sdevice->status_read_clean = status_clean;
264		sdevice->status_written_lastcycle = sdevice->status_written;
265		sdevice->connected = connected;
266
267		trace_siox_get_data(smaster, sdevice, devno, status_clean, i);
268
269		/* only give data read to driver if the device is connected */
270		if (sdriver && connected)
271			sdriver->get_data(sdevice, &smaster->buf[i]);
272
273		devno++;
274		i += sdevice->outbytes;
275	}
276}
277
278static int siox_poll_thread(void *data)
279{
280	struct siox_master *smaster = data;
281	signed long timeout = 0;
282
283	get_device(&smaster->dev);
284
285	for (;;) {
286		if (kthread_should_stop()) {
287			put_device(&smaster->dev);
288			return 0;
289		}
290
291		siox_master_lock(smaster);
292
293		if (smaster->active) {
294			unsigned long next_poll =
295				smaster->last_poll + smaster->poll_interval;
296			if (time_is_before_eq_jiffies(next_poll))
297				siox_poll(smaster);
298
299			timeout = smaster->poll_interval -
300				(jiffies - smaster->last_poll);
301		} else {
302			timeout = MAX_SCHEDULE_TIMEOUT;
303		}
304
305		/*
306		 * Set the task to idle while holding the lock. This makes sure
307		 * that we don't sleep too long when the bus is reenabled before
308		 * schedule_timeout is reached.
309		 */
310		if (timeout > 0)
311			set_current_state(TASK_IDLE);
312
313		siox_master_unlock(smaster);
314
315		if (timeout > 0)
316			schedule_timeout(timeout);
317
318		/*
319		 * I'm not clear if/why it is important to set the state to
320		 * RUNNING again, but it fixes a "do not call blocking ops when
321		 * !TASK_RUNNING;"-warning.
322		 */
323		set_current_state(TASK_RUNNING);
324	}
325}
326
327static int __siox_start(struct siox_master *smaster)
328{
329	if (!(smaster->setbuf_len + smaster->getbuf_len))
330		return -ENODEV;
331
332	if (!smaster->buf)
333		return -ENOMEM;
334
335	if (smaster->active)
336		return 0;
337
338	smaster->active = 1;
339	wake_up_process(smaster->poll_thread);
340
341	return 1;
342}
343
344static int siox_start(struct siox_master *smaster)
345{
346	int ret;
347
348	siox_master_lock(smaster);
349	ret = __siox_start(smaster);
350	siox_master_unlock(smaster);
351
352	return ret;
353}
354
355static int __siox_stop(struct siox_master *smaster)
356{
357	if (smaster->active) {
358		struct siox_device *sdevice;
359
360		smaster->active = 0;
361
362		list_for_each_entry(sdevice, &smaster->devices, node) {
363			if (sdevice->connected)
364				sysfs_notify_dirent(sdevice->connected_kn);
365			sdevice->connected = false;
366		}
367
368		return 1;
369	}
370	return 0;
371}
372
373static int siox_stop(struct siox_master *smaster)
374{
375	int ret;
376
377	siox_master_lock(smaster);
378	ret = __siox_stop(smaster);
379	siox_master_unlock(smaster);
380
381	return ret;
382}
383
384static ssize_t type_show(struct device *dev,
385			 struct device_attribute *attr, char *buf)
386{
387	struct siox_device *sdev = to_siox_device(dev);
388
389	return sprintf(buf, "%s\n", sdev->type);
390}
391
392static DEVICE_ATTR_RO(type);
393
394static ssize_t inbytes_show(struct device *dev,
395			    struct device_attribute *attr, char *buf)
396{
397	struct siox_device *sdev = to_siox_device(dev);
398
399	return sprintf(buf, "%zu\n", sdev->inbytes);
400}
401
402static DEVICE_ATTR_RO(inbytes);
403
404static ssize_t outbytes_show(struct device *dev,
405			     struct device_attribute *attr, char *buf)
406{
407	struct siox_device *sdev = to_siox_device(dev);
408
409	return sprintf(buf, "%zu\n", sdev->outbytes);
410}
411
412static DEVICE_ATTR_RO(outbytes);
413
414static ssize_t status_errors_show(struct device *dev,
415				  struct device_attribute *attr, char *buf)
416{
417	struct siox_device *sdev = to_siox_device(dev);
418	unsigned int status_errors;
419
420	siox_master_lock(sdev->smaster);
421
422	status_errors = sdev->status_errors;
423
424	siox_master_unlock(sdev->smaster);
425
426	return sprintf(buf, "%u\n", status_errors);
427}
428
429static DEVICE_ATTR_RO(status_errors);
430
431static ssize_t connected_show(struct device *dev,
432			      struct device_attribute *attr, char *buf)
433{
434	struct siox_device *sdev = to_siox_device(dev);
435	bool connected;
436
437	siox_master_lock(sdev->smaster);
438
439	connected = sdev->connected;
440
441	siox_master_unlock(sdev->smaster);
442
443	return sprintf(buf, "%u\n", connected);
444}
445
446static DEVICE_ATTR_RO(connected);
447
448static ssize_t watchdog_show(struct device *dev,
449			     struct device_attribute *attr, char *buf)
450{
451	struct siox_device *sdev = to_siox_device(dev);
452	u8 status;
453
454	siox_master_lock(sdev->smaster);
455
456	status = sdev->status_read_clean;
457
458	siox_master_unlock(sdev->smaster);
459
460	return sprintf(buf, "%d\n", status & SIOX_STATUS_WDG);
461}
462
463static DEVICE_ATTR_RO(watchdog);
464
465static ssize_t watchdog_errors_show(struct device *dev,
466				    struct device_attribute *attr, char *buf)
467{
468	struct siox_device *sdev = to_siox_device(dev);
469	unsigned int watchdog_errors;
470
471	siox_master_lock(sdev->smaster);
472
473	watchdog_errors = sdev->watchdog_errors;
474
475	siox_master_unlock(sdev->smaster);
476
477	return sprintf(buf, "%u\n", watchdog_errors);
478}
479
480static DEVICE_ATTR_RO(watchdog_errors);
481
482static struct attribute *siox_device_attrs[] = {
483	&dev_attr_type.attr,
484	&dev_attr_inbytes.attr,
485	&dev_attr_outbytes.attr,
486	&dev_attr_status_errors.attr,
487	&dev_attr_connected.attr,
488	&dev_attr_watchdog.attr,
489	&dev_attr_watchdog_errors.attr,
490	NULL
491};
492ATTRIBUTE_GROUPS(siox_device);
493
494static void siox_device_release(struct device *dev)
495{
496	struct siox_device *sdevice = to_siox_device(dev);
497
498	kfree(sdevice);
499}
500
501static struct device_type siox_device_type = {
502	.groups = siox_device_groups,
503	.release = siox_device_release,
504};
505
506static int siox_match(struct device *dev, struct device_driver *drv)
507{
508	if (dev->type != &siox_device_type)
509		return 0;
510
511	/* up to now there is only a single driver so keeping this simple */
512	return 1;
513}
514
515static struct bus_type siox_bus_type = {
516	.name = "siox",
517	.match = siox_match,
518};
519
520static int siox_driver_probe(struct device *dev)
521{
522	struct siox_driver *sdriver = to_siox_driver(dev->driver);
523	struct siox_device *sdevice = to_siox_device(dev);
524	int ret;
525
526	ret = sdriver->probe(sdevice);
527	return ret;
528}
529
530static int siox_driver_remove(struct device *dev)
531{
532	struct siox_driver *sdriver =
533		container_of(dev->driver, struct siox_driver, driver);
534	struct siox_device *sdevice = to_siox_device(dev);
535	int ret;
536
537	ret = sdriver->remove(sdevice);
538	return ret;
 
 
539}
540
541static void siox_driver_shutdown(struct device *dev)
542{
543	struct siox_driver *sdriver =
544		container_of(dev->driver, struct siox_driver, driver);
545	struct siox_device *sdevice = to_siox_device(dev);
 
 
 
 
546
547	sdriver->shutdown(sdevice);
 
 
548}
549
 
 
 
 
 
 
 
 
550static ssize_t active_show(struct device *dev,
551			   struct device_attribute *attr, char *buf)
552{
553	struct siox_master *smaster = to_siox_master(dev);
554
555	return sprintf(buf, "%d\n", smaster->active);
556}
557
558static ssize_t active_store(struct device *dev,
559			    struct device_attribute *attr,
560			    const char *buf, size_t count)
561{
562	struct siox_master *smaster = to_siox_master(dev);
563	int ret;
564	int active;
565
566	ret = kstrtoint(buf, 0, &active);
567	if (ret < 0)
568		return ret;
569
570	if (active)
571		ret = siox_start(smaster);
572	else
573		ret = siox_stop(smaster);
574
575	if (ret < 0)
576		return ret;
577
578	return count;
579}
580
581static DEVICE_ATTR_RW(active);
582
583static struct siox_device *siox_device_add(struct siox_master *smaster,
584					   const char *type, size_t inbytes,
585					   size_t outbytes, u8 statustype);
586
587static ssize_t device_add_store(struct device *dev,
588				struct device_attribute *attr,
589				const char *buf, size_t count)
590{
591	struct siox_master *smaster = to_siox_master(dev);
592	int ret;
593	char type[20] = "";
594	size_t inbytes = 0, outbytes = 0;
595	u8 statustype = 0;
596
597	ret = sscanf(buf, "%19s %zu %zu %hhu", type, &inbytes,
598		     &outbytes, &statustype);
599	if (ret != 3 && ret != 4)
600		return -EINVAL;
601
602	if (strcmp(type, "siox-12x8") || inbytes != 2 || outbytes != 4)
603		return -EINVAL;
604
605	siox_device_add(smaster, "siox-12x8", inbytes, outbytes, statustype);
606
607	return count;
608}
609
610static DEVICE_ATTR_WO(device_add);
611
612static void siox_device_remove(struct siox_master *smaster);
613
614static ssize_t device_remove_store(struct device *dev,
615				   struct device_attribute *attr,
616				   const char *buf, size_t count)
617{
618	struct siox_master *smaster = to_siox_master(dev);
619
620	/* XXX? require to write <type> <inbytes> <outbytes> */
621	siox_device_remove(smaster);
622
623	return count;
624}
625
626static DEVICE_ATTR_WO(device_remove);
627
628static ssize_t poll_interval_ns_show(struct device *dev,
629				     struct device_attribute *attr, char *buf)
630{
631	struct siox_master *smaster = to_siox_master(dev);
632
633	return sprintf(buf, "%lld\n", jiffies_to_nsecs(smaster->poll_interval));
634}
635
636static ssize_t poll_interval_ns_store(struct device *dev,
637				      struct device_attribute *attr,
638				      const char *buf, size_t count)
639{
640	struct siox_master *smaster = to_siox_master(dev);
641	int ret;
642	u64 val;
643
644	ret = kstrtou64(buf, 0, &val);
645	if (ret < 0)
646		return ret;
647
648	siox_master_lock(smaster);
649
650	smaster->poll_interval = nsecs_to_jiffies(val);
651
652	siox_master_unlock(smaster);
653
654	return count;
655}
656
657static DEVICE_ATTR_RW(poll_interval_ns);
658
659static struct attribute *siox_master_attrs[] = {
660	&dev_attr_active.attr,
661	&dev_attr_device_add.attr,
662	&dev_attr_device_remove.attr,
663	&dev_attr_poll_interval_ns.attr,
664	NULL
665};
666ATTRIBUTE_GROUPS(siox_master);
667
668static void siox_master_release(struct device *dev)
669{
670	struct siox_master *smaster = to_siox_master(dev);
671
672	kfree(smaster);
673}
674
675static struct device_type siox_master_type = {
676	.groups = siox_master_groups,
677	.release = siox_master_release,
678};
679
680struct siox_master *siox_master_alloc(struct device *dev,
681				      size_t size)
682{
683	struct siox_master *smaster;
684
685	if (!dev)
686		return NULL;
687
688	smaster = kzalloc(sizeof(*smaster) + size, GFP_KERNEL);
689	if (!smaster)
690		return NULL;
691
692	device_initialize(&smaster->dev);
693
694	smaster->busno = -1;
695	smaster->dev.bus = &siox_bus_type;
696	smaster->dev.type = &siox_master_type;
697	smaster->dev.parent = dev;
698	smaster->poll_interval = DIV_ROUND_UP(HZ, 40);
699
700	dev_set_drvdata(&smaster->dev, &smaster[1]);
701
702	return smaster;
703}
704EXPORT_SYMBOL_GPL(siox_master_alloc);
705
706int siox_master_register(struct siox_master *smaster)
707{
708	int ret;
709
710	if (!siox_is_registered)
711		return -EPROBE_DEFER;
712
713	if (!smaster->pushpull)
714		return -EINVAL;
715
716	dev_set_name(&smaster->dev, "siox-%d", smaster->busno);
717
718	mutex_init(&smaster->lock);
719	INIT_LIST_HEAD(&smaster->devices);
720
721	smaster->last_poll = jiffies;
722	smaster->poll_thread = kthread_run(siox_poll_thread, smaster,
723					   "siox-%d", smaster->busno);
724	if (IS_ERR(smaster->poll_thread)) {
725		smaster->active = 0;
726		return PTR_ERR(smaster->poll_thread);
727	}
728
729	ret = device_add(&smaster->dev);
730	if (ret)
731		kthread_stop(smaster->poll_thread);
732
733	return ret;
734}
735EXPORT_SYMBOL_GPL(siox_master_register);
736
737void siox_master_unregister(struct siox_master *smaster)
738{
739	/* remove device */
740	device_del(&smaster->dev);
741
742	siox_master_lock(smaster);
743
744	__siox_stop(smaster);
745
746	while (smaster->num_devices) {
747		struct siox_device *sdevice;
748
749		sdevice = container_of(smaster->devices.prev,
750				       struct siox_device, node);
751		list_del(&sdevice->node);
752		smaster->num_devices--;
753
754		siox_master_unlock(smaster);
755
756		device_unregister(&sdevice->dev);
757
758		siox_master_lock(smaster);
759	}
760
761	siox_master_unlock(smaster);
762
763	put_device(&smaster->dev);
764}
765EXPORT_SYMBOL_GPL(siox_master_unregister);
766
767static struct siox_device *siox_device_add(struct siox_master *smaster,
768					   const char *type, size_t inbytes,
769					   size_t outbytes, u8 statustype)
770{
771	struct siox_device *sdevice;
772	int ret;
773	size_t buf_len;
774
775	sdevice = kzalloc(sizeof(*sdevice), GFP_KERNEL);
776	if (!sdevice)
777		return ERR_PTR(-ENOMEM);
778
779	sdevice->type = type;
780	sdevice->inbytes = inbytes;
781	sdevice->outbytes = outbytes;
782	sdevice->statustype = statustype;
783
784	sdevice->smaster = smaster;
785	sdevice->dev.parent = &smaster->dev;
786	sdevice->dev.bus = &siox_bus_type;
787	sdevice->dev.type = &siox_device_type;
788
789	siox_master_lock(smaster);
790
791	dev_set_name(&sdevice->dev, "siox-%d-%d",
792		     smaster->busno, smaster->num_devices);
793
794	buf_len = smaster->setbuf_len + inbytes +
795		smaster->getbuf_len + outbytes;
796	if (smaster->buf_len < buf_len) {
797		u8 *buf = krealloc(smaster->buf, buf_len, GFP_KERNEL);
798
799		if (!buf) {
800			dev_err(&smaster->dev,
801				"failed to realloc buffer to %zu\n", buf_len);
802			ret = -ENOMEM;
803			goto err_buf_alloc;
804		}
805
806		smaster->buf_len = buf_len;
807		smaster->buf = buf;
808	}
809
810	ret = device_register(&sdevice->dev);
811	if (ret) {
812		dev_err(&smaster->dev, "failed to register device: %d\n", ret);
813
814		goto err_device_register;
815	}
816
817	smaster->num_devices++;
818	list_add_tail(&sdevice->node, &smaster->devices);
819
820	smaster->setbuf_len += sdevice->inbytes;
821	smaster->getbuf_len += sdevice->outbytes;
822
823	sdevice->status_errors_kn = sysfs_get_dirent(sdevice->dev.kobj.sd,
824						     "status_errors");
825	sdevice->watchdog_kn = sysfs_get_dirent(sdevice->dev.kobj.sd,
826						"watchdog");
827	sdevice->watchdog_errors_kn = sysfs_get_dirent(sdevice->dev.kobj.sd,
828						       "watchdog_errors");
829	sdevice->connected_kn = sysfs_get_dirent(sdevice->dev.kobj.sd,
830						 "connected");
831
832	siox_master_unlock(smaster);
833
834	return sdevice;
835
836err_device_register:
837	/* don't care to make the buffer smaller again */
838
839err_buf_alloc:
840	siox_master_unlock(smaster);
841
842	kfree(sdevice);
843
844	return ERR_PTR(ret);
845}
846
847static void siox_device_remove(struct siox_master *smaster)
848{
849	struct siox_device *sdevice;
850
851	siox_master_lock(smaster);
852
853	if (!smaster->num_devices) {
854		siox_master_unlock(smaster);
855		return;
856	}
857
858	sdevice = container_of(smaster->devices.prev, struct siox_device, node);
859	list_del(&sdevice->node);
860	smaster->num_devices--;
861
862	smaster->setbuf_len -= sdevice->inbytes;
863	smaster->getbuf_len -= sdevice->outbytes;
864
865	if (!smaster->num_devices)
866		__siox_stop(smaster);
867
868	siox_master_unlock(smaster);
869
870	/*
871	 * This must be done without holding the master lock because we're
872	 * called from device_remove_store which also holds a sysfs mutex.
873	 * device_unregister tries to aquire the same lock.
874	 */
875	device_unregister(&sdevice->dev);
876}
877
878int __siox_driver_register(struct siox_driver *sdriver, struct module *owner)
879{
880	int ret;
881
882	if (unlikely(!siox_is_registered))
883		return -EPROBE_DEFER;
884
885	if (!sdriver->set_data && !sdriver->get_data) {
 
886		pr_err("Driver %s doesn't provide needed callbacks\n",
887		       sdriver->driver.name);
888		return -EINVAL;
889	}
890
891	sdriver->driver.owner = owner;
892	sdriver->driver.bus = &siox_bus_type;
893
894	if (sdriver->probe)
895		sdriver->driver.probe = siox_driver_probe;
896	if (sdriver->remove)
897		sdriver->driver.remove = siox_driver_remove;
898	if (sdriver->shutdown)
899		sdriver->driver.shutdown = siox_driver_shutdown;
900
901	ret = driver_register(&sdriver->driver);
902	if (ret)
903		pr_err("Failed to register siox driver %s (%d)\n",
904		       sdriver->driver.name, ret);
905
906	return ret;
907}
908EXPORT_SYMBOL_GPL(__siox_driver_register);
909
910static int __init siox_init(void)
911{
912	int ret;
913
914	ret = bus_register(&siox_bus_type);
915	if (ret) {
916		pr_err("Registration of SIOX bus type failed: %d\n", ret);
917		return ret;
918	}
919
920	siox_is_registered = true;
921
922	return 0;
923}
924subsys_initcall(siox_init);
925
926static void __exit siox_exit(void)
927{
928	bus_unregister(&siox_bus_type);
929}
930module_exit(siox_exit);
931
932MODULE_AUTHOR("Uwe Kleine-Koenig <u.kleine-koenig@pengutronix.de>");
933MODULE_DESCRIPTION("Eckelmann SIOX driver core");
934MODULE_LICENSE("GPL v2");