1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 1998, 2001 Nicolas Souchu
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 *
28 *
29 */
30
31 #include <sys/param.h>
32 #include <sys/systm.h>
33 #include <sys/lock.h>
34 #include <sys/module.h>
35 #include <sys/mutex.h>
36 #include <sys/bus.h>
37
38 #include <dev/smbus/smbconf.h>
39 #include <dev/smbus/smbus.h>
40 #include "smbus_if.h"
41
42 /*
43 * smbus_intr()
44 */
45 void
smbus_intr(device_t bus,u_char devaddr,char low,char high,int error)46 smbus_intr(device_t bus, u_char devaddr, char low, char high, int error)
47 {
48 struct smbus_softc *sc = device_get_softc(bus);
49
50 /* call owner's intr routine */
51 mtx_lock(&sc->lock);
52 if (sc->owner)
53 SMBUS_INTR(sc->owner, devaddr, low, high, error);
54 mtx_unlock(&sc->lock);
55 }
56
57 /*
58 * smbus_error()
59 *
60 * Converts an smbus error to a unix error.
61 */
62 int
smbus_error(int smb_error)63 smbus_error(int smb_error)
64 {
65 int error = 0;
66
67 if (smb_error == SMB_ENOERR)
68 return (0);
69
70 if (smb_error & (SMB_ENOTSUPP))
71 error = ENODEV;
72 else if (smb_error & (SMB_ENOACK))
73 error = ENXIO;
74 else if (smb_error & (SMB_ETIMEOUT))
75 error = EWOULDBLOCK;
76 else if (smb_error & (SMB_EBUSY))
77 error = EBUSY;
78 else if (smb_error & (SMB_EABORT | SMB_EBUSERR | SMB_ECOLLI))
79 error = EIO;
80 else
81 error = EINVAL;
82
83 return (error);
84 }
85
86 static int
smbus_poll(struct smbus_softc * sc,int how)87 smbus_poll(struct smbus_softc *sc, int how)
88 {
89 int error;
90
91 switch (how) {
92 case SMB_WAIT | SMB_INTR:
93 error = msleep(sc, &sc->lock, SMBPRI|PCATCH, "smbreq", 0);
94 break;
95
96 case SMB_WAIT | SMB_NOINTR:
97 error = msleep(sc, &sc->lock, SMBPRI, "smbreq", 0);
98 break;
99
100 default:
101 error = EWOULDBLOCK;
102 break;
103 }
104
105 return (error);
106 }
107
108 /*
109 * smbus_request_bus()
110 *
111 * Allocate the device to perform transfers.
112 *
113 * how : SMB_WAIT or SMB_DONTWAIT
114 */
115 int
smbus_request_bus(device_t bus,device_t dev,int how)116 smbus_request_bus(device_t bus, device_t dev, int how)
117 {
118 struct smbus_softc *sc = device_get_softc(bus);
119 device_t parent;
120 int error;
121
122 /* first, ask the underlying layers if the request is ok */
123 parent = device_get_parent(bus);
124 mtx_lock(&sc->lock);
125 do {
126 mtx_unlock(&sc->lock);
127 error = SMBUS_CALLBACK(parent, SMB_REQUEST_BUS, &how);
128 mtx_lock(&sc->lock);
129
130 if (error)
131 error = smbus_poll(sc, how);
132 } while (error == EWOULDBLOCK);
133
134 while (error == 0) {
135 if (sc->owner && sc->owner != dev)
136 error = smbus_poll(sc, how);
137 else {
138 sc->owner = dev;
139 break;
140 }
141
142 /* free any allocated resource */
143 if (error) {
144 mtx_unlock(&sc->lock);
145 SMBUS_CALLBACK(parent, SMB_RELEASE_BUS, &how);
146 return (error);
147 }
148 }
149 mtx_unlock(&sc->lock);
150
151 return (error);
152 }
153
154 /*
155 * smbus_release_bus()
156 *
157 * Release the device allocated with smbus_request_dev()
158 */
159 int
smbus_release_bus(device_t bus,device_t dev)160 smbus_release_bus(device_t bus, device_t dev)
161 {
162 struct smbus_softc *sc = device_get_softc(bus);
163 int error;
164
165 /* first, ask the underlying layers if the release is ok */
166 error = SMBUS_CALLBACK(device_get_parent(bus), SMB_RELEASE_BUS, NULL);
167
168 if (error)
169 return (error);
170
171 mtx_lock(&sc->lock);
172 if (sc->owner == dev) {
173 sc->owner = NULL;
174
175 /* wakeup waiting processes */
176 wakeup(sc);
177 } else
178 error = EACCES;
179 mtx_unlock(&sc->lock);
180
181 return (error);
182 }
183