1 /*-
2 * Copyright (c) 2016 Michal Meloun <mmel@FreeBSD.org>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
29
30 #include <sys/param.h>
31 #include <sys/systm.h>
32 #include <sys/bus.h>
33 #include <sys/gpio.h>
34 #include <sys/kernel.h>
35 #include <sys/malloc.h>
36 #include <sys/sx.h>
37
38 #include <machine/bus.h>
39
40 #include <dev/fdt/fdt_common.h>
41 #include <dev/gpio/gpiobusvar.h>
42
43 #include "as3722.h"
44
45 MALLOC_DEFINE(M_AS3722_GPIO, "AS3722 gpio", "AS3722 GPIO");
46
47 /* AS3722_GPIOx_CONTROL MODE and IOSF definition. */
48 #define AS3722_IOSF_GPIO 0x00
49 #define AS3722_IOSF_INTERRUPT_OUT 0x01
50 #define AS3722_IOSF_VSUP_VBAT_LOW_UNDEBOUNCE_OUT 0x02
51 #define AS3722_IOSF_GPIO_IN_INTERRUPT 0x03
52 #define AS3722_IOSF_PWM_IN 0x04
53 #define AS3722_IOSF_VOLTAGE_IN_STANDBY 0x05
54 #define AS3722_IOSF_OC_PG_SD0 0x06
55 #define AS3722_IOSF_POWERGOOD_OUT 0x07
56 #define AS3722_IOSF_CLK32K_OUT 0x08
57 #define AS3722_IOSF_WATCHDOG_IN 0x09
58 #define AS3722_IOSF_SOFT_RESET_IN 0x0b
59 #define AS3722_IOSF_PWM_OUT 0x0c
60 #define AS3722_IOSF_VSUP_VBAT_LOW_DEBOUNCE_OUT 0x0d
61 #define AS3722_IOSF_OC_PG_SD6 0x0e
62
63 #define AS3722_MODE_INPUT 0
64 #define AS3722_MODE_PUSH_PULL 1
65 #define AS3722_MODE_OPEN_DRAIN 2
66 #define AS3722_MODE_TRISTATE 3
67 #define AS3722_MODE_INPUT_PULL_UP_LV 4
68 #define AS3722_MODE_INPUT_PULL_DOWN 5
69 #define AS3722_MODE_OPEN_DRAIN_LV 6
70 #define AS3722_MODE_PUSH_PULL_LV 7
71
72 #define NGPIO 8
73
74 #define GPIO_LOCK(_sc) sx_slock(&(_sc)->gpio_lock)
75 #define GPIO_UNLOCK(_sc) sx_unlock(&(_sc)->gpio_lock)
76 #define GPIO_ASSERT(_sc) sx_assert(&(_sc)->gpio_lock, SA_LOCKED)
77
78 #define AS3722_CFG_BIAS_DISABLE 0x0001
79 #define AS3722_CFG_BIAS_PULL_UP 0x0002
80 #define AS3722_CFG_BIAS_PULL_DOWN 0x0004
81 #define AS3722_CFG_BIAS_HIGH_IMPEDANCE 0x0008
82 #define AS3722_CFG_OPEN_DRAIN 0x0010
83
84 static const struct {
85 const char *name;
86 int config; /* AS3722_CFG_ */
87 } as3722_cfg_names[] = {
88 {"bias-disable", AS3722_CFG_BIAS_DISABLE},
89 {"bias-pull-up", AS3722_CFG_BIAS_PULL_UP},
90 {"bias-pull-down", AS3722_CFG_BIAS_PULL_DOWN},
91 {"bias-high-impedance", AS3722_CFG_BIAS_HIGH_IMPEDANCE},
92 {"drive-open-drain", AS3722_CFG_OPEN_DRAIN},
93 };
94
95 static struct {
96 const char *name;
97 int fnc_val;
98 } as3722_fnc_table[] = {
99 {"gpio", AS3722_IOSF_GPIO},
100 {"interrupt-out", AS3722_IOSF_INTERRUPT_OUT},
101 {"vsup-vbat-low-undebounce-out", AS3722_IOSF_VSUP_VBAT_LOW_UNDEBOUNCE_OUT},
102 {"gpio-in-interrupt", AS3722_IOSF_GPIO_IN_INTERRUPT},
103 {"pwm-in", AS3722_IOSF_PWM_IN},
104 {"voltage-in-standby", AS3722_IOSF_VOLTAGE_IN_STANDBY},
105 {"oc-pg-sd0", AS3722_IOSF_OC_PG_SD0},
106 {"powergood-out", AS3722_IOSF_POWERGOOD_OUT},
107 {"clk32k-out", AS3722_IOSF_CLK32K_OUT},
108 {"watchdog-in", AS3722_IOSF_WATCHDOG_IN},
109 {"soft-reset-in", AS3722_IOSF_SOFT_RESET_IN},
110 {"pwm-out", AS3722_IOSF_PWM_OUT},
111 {"vsup-vbat-low-debounce-out", AS3722_IOSF_VSUP_VBAT_LOW_DEBOUNCE_OUT},
112 {"oc-pg-sd6", AS3722_IOSF_OC_PG_SD6},
113 };
114
115 struct as3722_pincfg {
116 char *function;
117 int flags;
118 };
119
120 struct as3722_gpio_pin {
121 int pin_caps;
122 uint8_t pin_ctrl_reg;
123 char pin_name[GPIOMAXNAME];
124 int pin_cfg_flags;
125 };
126
127 /* --------------------------------------------------------------------------
128 *
129 * Pinmux functions.
130 */
131 static int
132 as3722_pinmux_get_function(struct as3722_softc *sc, char *name)
133 {
134 int i;
135
136 for (i = 0; i < nitems(as3722_fnc_table); i++) {
137 if (strcmp(as3722_fnc_table[i].name, name) == 0)
138 return (as3722_fnc_table[i].fnc_val);
139 }
140 return (-1);
141 }
142
143 static int
144 as3722_pinmux_config_node(struct as3722_softc *sc, char *pin_name,
145 struct as3722_pincfg *cfg)
146 {
147 uint8_t ctrl;
148 int rv, fnc, pin;
149
150 for (pin = 0; pin < sc->gpio_npins; pin++) {
151 if (strcmp(sc->gpio_pins[pin]->pin_name, pin_name) == 0)
152 break;
153 }
154 if (pin >= sc->gpio_npins) {
155 device_printf(sc->dev, "Unknown pin: %s\n", pin_name);
156 return (ENXIO);
157 }
158
159 ctrl = sc->gpio_pins[pin]->pin_ctrl_reg;
160 sc->gpio_pins[pin]->pin_cfg_flags = cfg->flags;
161 if (cfg->function != NULL) {
162 fnc = as3722_pinmux_get_function(sc, cfg->function);
163 if (fnc == -1) {
164 device_printf(sc->dev,
165 "Unknown function %s for pin %s\n", cfg->function,
166 sc->gpio_pins[pin]->pin_name);
167 return (ENXIO);
168 }
169 switch (fnc) {
170 case AS3722_IOSF_INTERRUPT_OUT:
171 case AS3722_IOSF_VSUP_VBAT_LOW_UNDEBOUNCE_OUT:
172 case AS3722_IOSF_OC_PG_SD0:
173 case AS3722_IOSF_POWERGOOD_OUT:
174 case AS3722_IOSF_CLK32K_OUT:
175 case AS3722_IOSF_PWM_OUT:
176 case AS3722_IOSF_OC_PG_SD6:
177 ctrl &= ~(AS3722_GPIO_MODE_MASK <<
178 AS3722_GPIO_MODE_SHIFT);
179 ctrl |= AS3722_MODE_PUSH_PULL << AS3722_GPIO_MODE_SHIFT;
180 /* XXX Handle flags (OC + pullup) */
181 break;
182 case AS3722_IOSF_GPIO_IN_INTERRUPT:
183 case AS3722_IOSF_PWM_IN:
184 case AS3722_IOSF_VOLTAGE_IN_STANDBY:
185 case AS3722_IOSF_WATCHDOG_IN:
186 case AS3722_IOSF_SOFT_RESET_IN:
187 ctrl &= ~(AS3722_GPIO_MODE_MASK <<
188 AS3722_GPIO_MODE_SHIFT);
189 ctrl |= AS3722_MODE_INPUT << AS3722_GPIO_MODE_SHIFT;
190 /* XXX Handle flags (pulldown + pullup) */
191
192 default:
193 break;
194 }
195 ctrl &= ~(AS3722_GPIO_IOSF_MASK << AS3722_GPIO_IOSF_SHIFT);
196 ctrl |= fnc << AS3722_GPIO_IOSF_SHIFT;
197 }
198 rv = 0;
199 if (ctrl != sc->gpio_pins[pin]->pin_ctrl_reg) {
200 rv = WR1(sc, AS3722_GPIO0_CONTROL + pin, ctrl);
201 sc->gpio_pins[pin]->pin_ctrl_reg = ctrl;
202 }
203 return (rv);
204 }
205
206 static int
207 as3722_pinmux_read_node(struct as3722_softc *sc, phandle_t node,
208 struct as3722_pincfg *cfg, char **pins, int *lpins)
209 {
210 int rv, i;
211
212 *lpins = OF_getprop_alloc(node, "pins", (void **)pins);
213 if (*lpins <= 0)
214 return (ENOENT);
215
216 /* Read function (mux) settings. */
217 rv = OF_getprop_alloc(node, "function", (void **)&cfg->function);
218 if (rv <= 0)
219 cfg->function = NULL;
220
221 /* Read boolean properties. */
222 for (i = 0; i < nitems(as3722_cfg_names); i++) {
223 if (OF_hasprop(node, as3722_cfg_names[i].name))
224 cfg->flags |= as3722_cfg_names[i].config;
225 }
226 return (0);
227 }
228
229 static int
230 as3722_pinmux_process_node(struct as3722_softc *sc, phandle_t node)
231 {
232 struct as3722_pincfg cfg;
233 char *pins, *pname;
234 int i, len, lpins, rv;
235
236 rv = as3722_pinmux_read_node(sc, node, &cfg, &pins, &lpins);
237 if (rv != 0)
238 return (rv);
239
240 len = 0;
241 pname = pins;
242 do {
243 i = strlen(pname) + 1;
244 rv = as3722_pinmux_config_node(sc, pname, &cfg);
245 if (rv != 0) {
246 device_printf(sc->dev,
247 "Cannot configure pin: %s: %d\n", pname, rv);
248 }
249 len += i;
250 pname += i;
251 } while (len < lpins);
252
253 if (pins != NULL)
254 OF_prop_free(pins);
255 if (cfg.function != NULL)
256 OF_prop_free(cfg.function);
257
258 return (rv);
259 }
260
261 int as3722_pinmux_configure(device_t dev, phandle_t cfgxref)
262 {
263 struct as3722_softc *sc;
264 phandle_t node, cfgnode;
265 int rv;
266
267 sc = device_get_softc(dev);
268 cfgnode = OF_node_from_xref(cfgxref);
269
270 for (node = OF_child(cfgnode); node != 0; node = OF_peer(node)) {
271 if (!ofw_bus_node_status_okay(node))
272 continue;
273 rv = as3722_pinmux_process_node(sc, node);
274 if (rv != 0)
275 device_printf(dev, "Failed to process pinmux");
276 }
277 return (0);
278 }
279
280 /* --------------------------------------------------------------------------
281 *
282 * GPIO
283 */
284 device_t
285 as3722_gpio_get_bus(device_t dev)
286 {
287 struct as3722_softc *sc;
288
289 sc = device_get_softc(dev);
290 return (sc->gpio_busdev);
291 }
292
293 int
294 as3722_gpio_pin_max(device_t dev, int *maxpin)
295 {
296
297 *maxpin = NGPIO - 1;
298 return (0);
299 }
300
301 int
302 as3722_gpio_pin_getcaps(device_t dev, uint32_t pin, uint32_t *caps)
303 {
304 struct as3722_softc *sc;
305
306 sc = device_get_softc(dev);
307 if (pin >= sc->gpio_npins)
308 return (EINVAL);
309 GPIO_LOCK(sc);
310 *caps = sc->gpio_pins[pin]->pin_caps;
311 GPIO_UNLOCK(sc);
312 return (0);
313 }
314
315 int
316 as3722_gpio_pin_getname(device_t dev, uint32_t pin, char *name)
317 {
318 struct as3722_softc *sc;
319
320 sc = device_get_softc(dev);
321 if (pin >= sc->gpio_npins)
322 return (EINVAL);
323 GPIO_LOCK(sc);
324 memcpy(name, sc->gpio_pins[pin]->pin_name, GPIOMAXNAME);
325 GPIO_UNLOCK(sc);
326 return (0);
327 }
328
329 int
330 as3722_gpio_pin_getflags(device_t dev, uint32_t pin, uint32_t *out_flags)
331 {
332 struct as3722_softc *sc;
333 uint8_t tmp, mode, iosf;
334 uint32_t flags;
335 bool inverted;
336
337 sc = device_get_softc(dev);
338 if (pin >= sc->gpio_npins)
339 return (EINVAL);
340
341 GPIO_LOCK(sc);
342 tmp = sc->gpio_pins[pin]->pin_ctrl_reg;
343 GPIO_UNLOCK(sc);
344 iosf = (tmp >> AS3722_GPIO_IOSF_SHIFT) & AS3722_GPIO_IOSF_MASK;
345 mode = (tmp >> AS3722_GPIO_MODE_SHIFT) & AS3722_GPIO_MODE_MASK;
346 inverted = (tmp & AS3722_GPIO_INVERT) != 0;
347 /* Is pin in GPIO mode ? */
348 if (iosf != AS3722_IOSF_GPIO)
349 return (ENXIO);
350
351 flags = 0;
352 switch (mode) {
353 case AS3722_MODE_INPUT:
354 flags = GPIO_PIN_INPUT;
355 break;
356 case AS3722_MODE_PUSH_PULL:
357 case AS3722_MODE_PUSH_PULL_LV:
358 flags = GPIO_PIN_OUTPUT;
359 break;
360 case AS3722_MODE_OPEN_DRAIN:
361 case AS3722_MODE_OPEN_DRAIN_LV:
362 flags = GPIO_PIN_INPUT | GPIO_PIN_OUTPUT | GPIO_PIN_OPENDRAIN;
363 break;
364 case AS3722_MODE_TRISTATE:
365 flags = GPIO_PIN_TRISTATE;
366 break;
367 case AS3722_MODE_INPUT_PULL_UP_LV:
368 flags = GPIO_PIN_INPUT | GPIO_PIN_PULLUP;
369 break;
370
371 case AS3722_MODE_INPUT_PULL_DOWN:
372 flags = GPIO_PIN_OUTPUT | GPIO_PIN_PULLDOWN;
373 break;
374 }
375 if (inverted)
376 flags |= GPIO_PIN_INVIN | GPIO_PIN_INVOUT;
377 *out_flags = flags;
378 return (0);
379 }
380
381 static int
382 as3722_gpio_get_mode(struct as3722_softc *sc, uint32_t pin, uint32_t gpio_flags)
383 {
384 uint8_t ctrl;
385 int flags;
386
387 ctrl = sc->gpio_pins[pin]->pin_ctrl_reg;
388 flags = sc->gpio_pins[pin]->pin_cfg_flags;
389
390 /* Tristate mode. */
391 if (flags & AS3722_CFG_BIAS_HIGH_IMPEDANCE ||
392 gpio_flags & GPIO_PIN_TRISTATE)
393 return (AS3722_MODE_TRISTATE);
394
395 /* Open drain modes. */
396 if (flags & AS3722_CFG_OPEN_DRAIN || gpio_flags & GPIO_PIN_OPENDRAIN) {
397 /* Only pull up have effect */
398 if (flags & AS3722_CFG_BIAS_PULL_UP ||
399 gpio_flags & GPIO_PIN_PULLUP)
400 return (AS3722_MODE_OPEN_DRAIN_LV);
401 return (AS3722_MODE_OPEN_DRAIN);
402 }
403 /* Input modes. */
404 if (gpio_flags & GPIO_PIN_INPUT) {
405 /* Accept pull up or pull down. */
406 if (flags & AS3722_CFG_BIAS_PULL_UP ||
407 gpio_flags & GPIO_PIN_PULLUP)
408 return (AS3722_MODE_INPUT_PULL_UP_LV);
409
410 if (flags & AS3722_CFG_BIAS_PULL_DOWN ||
411 gpio_flags & GPIO_PIN_PULLDOWN)
412 return (AS3722_MODE_INPUT_PULL_DOWN);
413 return (AS3722_MODE_INPUT);
414 }
415 /*
416 * Output modes.
417 * Pull down is used as indicator of low voltage output.
418 */
419 if (flags & AS3722_CFG_BIAS_PULL_DOWN ||
420 gpio_flags & GPIO_PIN_PULLDOWN)
421 return (AS3722_MODE_PUSH_PULL_LV);
422 return (AS3722_MODE_PUSH_PULL);
423 }
424
425 int
426 as3722_gpio_pin_setflags(device_t dev, uint32_t pin, uint32_t flags)
427 {
428 struct as3722_softc *sc;
429 uint8_t ctrl, mode, iosf;
430 int rv;
431
432 sc = device_get_softc(dev);
433 if (pin >= sc->gpio_npins)
434 return (EINVAL);
435
436 GPIO_LOCK(sc);
437 ctrl = sc->gpio_pins[pin]->pin_ctrl_reg;
438 iosf = (ctrl >> AS3722_GPIO_IOSF_SHIFT) & AS3722_GPIO_IOSF_MASK;
439 /* Is pin in GPIO mode ? */
440 if (iosf != AS3722_IOSF_GPIO) {
441 GPIO_UNLOCK(sc);
442 return (ENXIO);
443 }
444 mode = as3722_gpio_get_mode(sc, pin, flags);
445 ctrl &= ~(AS3722_GPIO_MODE_MASK << AS3722_GPIO_MODE_SHIFT);
446 ctrl |= AS3722_MODE_PUSH_PULL << AS3722_GPIO_MODE_SHIFT;
447 rv = 0;
448 if (ctrl != sc->gpio_pins[pin]->pin_ctrl_reg) {
449 rv = WR1(sc, AS3722_GPIO0_CONTROL + pin, ctrl);
450 sc->gpio_pins[pin]->pin_ctrl_reg = ctrl;
451 }
452 GPIO_UNLOCK(sc);
453 return (rv);
454 }
455
456 int
457 as3722_gpio_pin_set(device_t dev, uint32_t pin, uint32_t val)
458 {
459 struct as3722_softc *sc;
460 uint8_t tmp;
461 int rv;
462
463 sc = device_get_softc(dev);
464 if (pin >= sc->gpio_npins)
465 return (EINVAL);
466
467 tmp = (val != 0) ? 1 : 0;
468 if (sc->gpio_pins[pin]->pin_ctrl_reg & AS3722_GPIO_INVERT)
469 tmp ^= 1;
470
471 GPIO_LOCK(sc);
472 rv = RM1(sc, AS3722_GPIO_SIGNAL_OUT, (1 << pin), (tmp << pin));
473 GPIO_UNLOCK(sc);
474 return (rv);
475 }
476
477 int
478 as3722_gpio_pin_get(device_t dev, uint32_t pin, uint32_t *val)
479 {
480 struct as3722_softc *sc;
481 uint8_t tmp, mode, ctrl;
482 int rv;
483
484 sc = device_get_softc(dev);
485 if (pin >= sc->gpio_npins)
486 return (EINVAL);
487
488 GPIO_LOCK(sc);
489 ctrl = sc->gpio_pins[pin]->pin_ctrl_reg;
490 mode = (ctrl >> AS3722_GPIO_MODE_SHIFT) & AS3722_GPIO_MODE_MASK;
491 if ((mode == AS3722_MODE_PUSH_PULL) ||
492 (mode == AS3722_MODE_PUSH_PULL_LV))
493 rv = RD1(sc, AS3722_GPIO_SIGNAL_OUT, &tmp);
494 else
495 rv = RD1(sc, AS3722_GPIO_SIGNAL_IN, &tmp);
496 GPIO_UNLOCK(sc);
497 if (rv != 0)
498 return (rv);
499
500 *val = tmp & (1 << pin) ? 1 : 0;
501 if (ctrl & AS3722_GPIO_INVERT)
502 *val ^= 1;
503 return (0);
504 }
505
506 int
507 as3722_gpio_pin_toggle(device_t dev, uint32_t pin)
508 {
509 struct as3722_softc *sc;
510 uint8_t tmp;
511 int rv;
512
513 sc = device_get_softc(dev);
514 if (pin >= sc->gpio_npins)
515 return (EINVAL);
516
517 GPIO_LOCK(sc);
518 rv = RD1(sc, AS3722_GPIO_SIGNAL_OUT, &tmp);
519 if (rv != 0) {
520 GPIO_UNLOCK(sc);
521 return (rv);
522 }
523 tmp ^= (1 <<pin);
524 rv = RM1(sc, AS3722_GPIO_SIGNAL_OUT, (1 << pin), tmp);
525 GPIO_UNLOCK(sc);
526 return (0);
527 }
528
529 int
530 as3722_gpio_map_gpios(device_t dev, phandle_t pdev, phandle_t gparent,
531 int gcells, pcell_t *gpios, uint32_t *pin, uint32_t *flags)
532 {
533
534 if (gcells != 2)
535 return (ERANGE);
536 *pin = gpios[0];
537 *flags= gpios[1];
538 return (0);
539 }
540
541 int
542 as3722_gpio_attach(struct as3722_softc *sc, phandle_t node)
543 {
544 struct as3722_gpio_pin *pin;
545 int i, rv;
546
547 sx_init(&sc->gpio_lock, "AS3722 GPIO lock");
548 sc->gpio_npins = NGPIO;
549 sc->gpio_pins = malloc(sizeof(struct as3722_gpio_pin *) *
550 sc->gpio_npins, M_AS3722_GPIO, M_WAITOK | M_ZERO);
551
552 sc->gpio_busdev = gpiobus_attach_bus(sc->dev);
553 if (sc->gpio_busdev == NULL)
554 return (ENXIO);
555 for (i = 0; i < sc->gpio_npins; i++) {
556 sc->gpio_pins[i] = malloc(sizeof(struct as3722_gpio_pin),
557 M_AS3722_GPIO, M_WAITOK | M_ZERO);
558 pin = sc->gpio_pins[i];
559 sprintf(pin->pin_name, "gpio%d", i);
560 pin->pin_caps = GPIO_PIN_INPUT | GPIO_PIN_OUTPUT |
561 GPIO_PIN_OPENDRAIN | GPIO_PIN_PUSHPULL | GPIO_PIN_TRISTATE |
562 GPIO_PIN_PULLUP | GPIO_PIN_PULLDOWN | GPIO_PIN_INVIN |
563 GPIO_PIN_INVOUT;
564 rv = RD1(sc, AS3722_GPIO0_CONTROL + i, &pin->pin_ctrl_reg);
565 if (rv != 0) {
566 device_printf(sc->dev,
567 "Cannot read configuration for pin %s\n",
568 sc->gpio_pins[i]->pin_name);
569 }
570 }
571 return (0);
572 }
Cache object: b502e4d70d3c1e2aea3c01e2c85524e6
|