blob: 221bde03913aa7199a85c90fe63615c5e1421b66 [file] [log] [blame]
Paul Mundtca5481c62012-07-10 12:08:14 +09001/*
2 * SuperH Pin Function Controller pinmux support.
3 *
4 * Copyright (C) 2012 Paul Mundt
5 *
6 * This file is subject to the terms and conditions of the GNU General Public
7 * License. See the file "COPYING" in the main directory of this archive
8 * for more details.
9 */
Paul Mundt54407112012-07-20 16:18:21 +090010
Laurent Pinchartc6193ea2012-12-15 23:50:47 +010011#define DRV_NAME "sh-pfc"
Laurent Pinchartf9492fd2012-12-15 23:50:45 +010012#define pr_fmt(fmt) KBUILD_MODNAME " pinctrl: " fmt
Paul Mundtca5481c62012-07-10 12:08:14 +090013
Laurent Pinchart1724acf2012-12-15 23:50:48 +010014#include <linux/device.h>
Laurent Pinchart90efde22012-12-15 23:50:52 +010015#include <linux/err.h>
Paul Mundtca5481c62012-07-10 12:08:14 +090016#include <linux/init.h>
17#include <linux/module.h>
Laurent Pinchart90efde22012-12-15 23:50:52 +010018#include <linux/pinctrl/consumer.h>
19#include <linux/pinctrl/pinconf.h>
20#include <linux/pinctrl/pinconf-generic.h>
21#include <linux/pinctrl/pinctrl.h>
22#include <linux/pinctrl/pinmux.h>
Paul Mundtca5481c62012-07-10 12:08:14 +090023#include <linux/sh_pfc.h>
Paul Mundtca5481c62012-07-10 12:08:14 +090024#include <linux/slab.h>
Paul Mundtd93a8912012-07-11 17:17:10 +090025#include <linux/spinlock.h>
Paul Mundtca5481c62012-07-10 12:08:14 +090026
Laurent Pinchartf9165132012-12-15 23:50:44 +010027#include "core.h"
28
Paul Mundtca5481c62012-07-10 12:08:14 +090029struct sh_pfc_pinctrl {
30 struct pinctrl_dev *pctl;
31 struct sh_pfc *pfc;
32
Paul Mundtd93a8912012-07-11 17:17:10 +090033 struct pinmux_gpio **functions;
34 unsigned int nr_functions;
35
Paul Mundtca5481c62012-07-10 12:08:14 +090036 struct pinctrl_pin_desc *pads;
37 unsigned int nr_pads;
Paul Mundtd93a8912012-07-11 17:17:10 +090038
39 spinlock_t lock;
Paul Mundtca5481c62012-07-10 12:08:14 +090040};
41
Paul Mundte3f805e2012-07-17 15:48:18 +090042static int sh_pfc_get_groups_count(struct pinctrl_dev *pctldev)
Paul Mundtca5481c62012-07-10 12:08:14 +090043{
Paul Mundte3f805e2012-07-17 15:48:18 +090044 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
45
46 return pmx->nr_pads;
Paul Mundtca5481c62012-07-10 12:08:14 +090047}
48
Paul Mundte3f805e2012-07-17 15:48:18 +090049static const char *sh_pfc_get_group_name(struct pinctrl_dev *pctldev,
Paul Mundtca5481c62012-07-10 12:08:14 +090050 unsigned selector)
51{
Paul Mundte3f805e2012-07-17 15:48:18 +090052 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
53
54 return pmx->pads[selector].name;
Paul Mundtca5481c62012-07-10 12:08:14 +090055}
56
57static int sh_pfc_get_group_pins(struct pinctrl_dev *pctldev, unsigned group,
58 const unsigned **pins, unsigned *num_pins)
59{
Paul Mundte3f805e2012-07-17 15:48:18 +090060 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
61
62 *pins = &pmx->pads[group].number;
63 *num_pins = 1;
64
65 return 0;
Paul Mundtca5481c62012-07-10 12:08:14 +090066}
67
Paul Mundtfdd85ec2012-07-20 16:39:09 +090068static void sh_pfc_pin_dbg_show(struct pinctrl_dev *pctldev, struct seq_file *s,
69 unsigned offset)
70{
71 seq_printf(s, "%s", DRV_NAME);
72}
73
Paul Mundtca5481c62012-07-10 12:08:14 +090074static struct pinctrl_ops sh_pfc_pinctrl_ops = {
Paul Mundte3f805e2012-07-17 15:48:18 +090075 .get_groups_count = sh_pfc_get_groups_count,
76 .get_group_name = sh_pfc_get_group_name,
Paul Mundtca5481c62012-07-10 12:08:14 +090077 .get_group_pins = sh_pfc_get_group_pins,
Paul Mundtfdd85ec2012-07-20 16:39:09 +090078 .pin_dbg_show = sh_pfc_pin_dbg_show,
Paul Mundtca5481c62012-07-10 12:08:14 +090079};
80
Paul Mundtd93a8912012-07-11 17:17:10 +090081static int sh_pfc_get_functions_count(struct pinctrl_dev *pctldev)
82{
83 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
Paul Mundtca5481c62012-07-10 12:08:14 +090084
Paul Mundtd93a8912012-07-11 17:17:10 +090085 return pmx->nr_functions;
86}
87
88static const char *sh_pfc_get_function_name(struct pinctrl_dev *pctldev,
89 unsigned selector)
90{
91 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
92
93 return pmx->functions[selector]->name;
94}
95
Paul Mundtca5481c62012-07-10 12:08:14 +090096static int sh_pfc_get_function_groups(struct pinctrl_dev *pctldev, unsigned func,
97 const char * const **groups,
98 unsigned * const num_groups)
99{
Paul Mundtd93a8912012-07-11 17:17:10 +0900100 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
101
102 *groups = &pmx->functions[func]->name;
103 *num_groups = 1;
104
Paul Mundtca5481c62012-07-10 12:08:14 +0900105 return 0;
106}
107
108static int sh_pfc_noop_enable(struct pinctrl_dev *pctldev, unsigned func,
109 unsigned group)
110{
111 return 0;
112}
113
114static void sh_pfc_noop_disable(struct pinctrl_dev *pctldev, unsigned func,
115 unsigned group)
116{
117}
118
Laurent Pinchart4a2e0d12012-12-15 23:50:50 +0100119static int sh_pfc_config_function(struct sh_pfc *pfc, unsigned offset)
Paul Mundtd93a8912012-07-11 17:17:10 +0900120{
121 if (sh_pfc_config_gpio(pfc, offset,
122 PINMUX_TYPE_FUNCTION,
123 GPIO_CFG_DRYRUN) != 0)
124 return -EINVAL;
125
126 if (sh_pfc_config_gpio(pfc, offset,
127 PINMUX_TYPE_FUNCTION,
128 GPIO_CFG_REQ) != 0)
129 return -EINVAL;
130
131 return 0;
132}
133
Paul Mundtfdd85ec2012-07-20 16:39:09 +0900134static int sh_pfc_reconfig_pin(struct sh_pfc *pfc, unsigned offset,
135 int new_type)
136{
137 unsigned long flags;
138 int pinmux_type;
139 int ret = -EINVAL;
140
141 spin_lock_irqsave(&pfc->lock, flags);
142
Laurent Pinchartd4e62d02012-12-15 23:50:43 +0100143 pinmux_type = pfc->pdata->gpios[offset].flags & PINMUX_FLAG_TYPE;
Paul Mundtfdd85ec2012-07-20 16:39:09 +0900144
145 /*
146 * See if the present config needs to first be de-configured.
147 */
148 switch (pinmux_type) {
149 case PINMUX_TYPE_GPIO:
150 break;
151 case PINMUX_TYPE_OUTPUT:
152 case PINMUX_TYPE_INPUT:
153 case PINMUX_TYPE_INPUT_PULLUP:
154 case PINMUX_TYPE_INPUT_PULLDOWN:
155 sh_pfc_config_gpio(pfc, offset, pinmux_type, GPIO_CFG_FREE);
156 break;
157 default:
158 goto err;
159 }
160
161 /*
162 * Dry run
163 */
164 if (sh_pfc_config_gpio(pfc, offset, new_type,
165 GPIO_CFG_DRYRUN) != 0)
166 goto err;
167
168 /*
169 * Request
170 */
171 if (sh_pfc_config_gpio(pfc, offset, new_type,
172 GPIO_CFG_REQ) != 0)
173 goto err;
174
Laurent Pinchartd4e62d02012-12-15 23:50:43 +0100175 pfc->pdata->gpios[offset].flags &= ~PINMUX_FLAG_TYPE;
176 pfc->pdata->gpios[offset].flags |= new_type;
Paul Mundtfdd85ec2012-07-20 16:39:09 +0900177
178 ret = 0;
179
180err:
181 spin_unlock_irqrestore(&pfc->lock, flags);
182
183 return ret;
184}
185
186
Paul Mundtca5481c62012-07-10 12:08:14 +0900187static int sh_pfc_gpio_request_enable(struct pinctrl_dev *pctldev,
188 struct pinctrl_gpio_range *range,
189 unsigned offset)
190{
191 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
192 struct sh_pfc *pfc = pmx->pfc;
Paul Mundtca5481c62012-07-10 12:08:14 +0900193 unsigned long flags;
Paul Mundtd93a8912012-07-11 17:17:10 +0900194 int ret, pinmux_type;
Paul Mundtca5481c62012-07-10 12:08:14 +0900195
196 spin_lock_irqsave(&pfc->lock, flags);
197
Laurent Pinchartd4e62d02012-12-15 23:50:43 +0100198 pinmux_type = pfc->pdata->gpios[offset].flags & PINMUX_FLAG_TYPE;
Paul Mundtca5481c62012-07-10 12:08:14 +0900199
Paul Mundtd93a8912012-07-11 17:17:10 +0900200 switch (pinmux_type) {
201 case PINMUX_TYPE_FUNCTION:
202 pr_notice_once("Use of GPIO API for function requests is "
203 "deprecated, convert to pinctrl\n");
204 /* handle for now */
205 ret = sh_pfc_config_function(pfc, offset);
206 if (unlikely(ret < 0))
Paul Mundtca5481c62012-07-10 12:08:14 +0900207 goto err;
208
Paul Mundtd93a8912012-07-11 17:17:10 +0900209 break;
210 case PINMUX_TYPE_GPIO:
Paul Mundt16d74eb2012-09-25 11:51:05 +0900211 case PINMUX_TYPE_INPUT:
212 case PINMUX_TYPE_OUTPUT:
Paul Mundtd93a8912012-07-11 17:17:10 +0900213 break;
214 default:
215 pr_err("Unsupported mux type (%d), bailing...\n", pinmux_type);
Laurent Pinchart077664a2012-09-14 20:25:48 +0200216 ret = -ENOTSUPP;
217 goto err;
Paul Mundtd93a8912012-07-11 17:17:10 +0900218 }
Paul Mundtca5481c62012-07-10 12:08:14 +0900219
220 ret = 0;
221
222err:
223 spin_unlock_irqrestore(&pfc->lock, flags);
224
225 return ret;
226}
227
228static void sh_pfc_gpio_disable_free(struct pinctrl_dev *pctldev,
229 struct pinctrl_gpio_range *range,
230 unsigned offset)
231{
232 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
233 struct sh_pfc *pfc = pmx->pfc;
234 unsigned long flags;
235 int pinmux_type;
236
237 spin_lock_irqsave(&pfc->lock, flags);
238
Laurent Pinchartd4e62d02012-12-15 23:50:43 +0100239 pinmux_type = pfc->pdata->gpios[offset].flags & PINMUX_FLAG_TYPE;
Paul Mundtca5481c62012-07-10 12:08:14 +0900240
241 sh_pfc_config_gpio(pfc, offset, pinmux_type, GPIO_CFG_FREE);
242
Paul Mundtca5481c62012-07-10 12:08:14 +0900243 spin_unlock_irqrestore(&pfc->lock, flags);
244}
245
246static int sh_pfc_gpio_set_direction(struct pinctrl_dev *pctldev,
247 struct pinctrl_gpio_range *range,
248 unsigned offset, bool input)
249{
250 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
Paul Mundtfdd85ec2012-07-20 16:39:09 +0900251 int type = input ? PINMUX_TYPE_INPUT : PINMUX_TYPE_OUTPUT;
Paul Mundtca5481c62012-07-10 12:08:14 +0900252
Paul Mundtfdd85ec2012-07-20 16:39:09 +0900253 return sh_pfc_reconfig_pin(pmx->pfc, offset, type);
Paul Mundtca5481c62012-07-10 12:08:14 +0900254}
255
256static struct pinmux_ops sh_pfc_pinmux_ops = {
Paul Mundtd93a8912012-07-11 17:17:10 +0900257 .get_functions_count = sh_pfc_get_functions_count,
258 .get_function_name = sh_pfc_get_function_name,
Paul Mundtca5481c62012-07-10 12:08:14 +0900259 .get_function_groups = sh_pfc_get_function_groups,
260 .enable = sh_pfc_noop_enable,
261 .disable = sh_pfc_noop_disable,
262 .gpio_request_enable = sh_pfc_gpio_request_enable,
263 .gpio_disable_free = sh_pfc_gpio_disable_free,
264 .gpio_set_direction = sh_pfc_gpio_set_direction,
265};
266
267static int sh_pfc_pinconf_get(struct pinctrl_dev *pctldev, unsigned pin,
268 unsigned long *config)
269{
Paul Mundtfdd85ec2012-07-20 16:39:09 +0900270 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
271 struct sh_pfc *pfc = pmx->pfc;
Paul Mundtd93a8912012-07-11 17:17:10 +0900272
Laurent Pinchartd4e62d02012-12-15 23:50:43 +0100273 *config = pfc->pdata->gpios[pin].flags & PINMUX_FLAG_TYPE;
Paul Mundtd93a8912012-07-11 17:17:10 +0900274
Paul Mundtfdd85ec2012-07-20 16:39:09 +0900275 return 0;
Paul Mundtca5481c62012-07-10 12:08:14 +0900276}
277
278static int sh_pfc_pinconf_set(struct pinctrl_dev *pctldev, unsigned pin,
279 unsigned long config)
280{
Paul Mundtfdd85ec2012-07-20 16:39:09 +0900281 struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
Paul Mundtfdd85ec2012-07-20 16:39:09 +0900282
283 /* Validate the new type */
284 if (config >= PINMUX_FLAG_TYPE)
285 return -EINVAL;
286
287 return sh_pfc_reconfig_pin(pmx->pfc, pin, config);
288}
289
290static void sh_pfc_pinconf_dbg_show(struct pinctrl_dev *pctldev,
291 struct seq_file *s, unsigned pin)
292{
293 const char *pinmux_type_str[] = {
294 [PINMUX_TYPE_NONE] = "none",
295 [PINMUX_TYPE_FUNCTION] = "function",
296 [PINMUX_TYPE_GPIO] = "gpio",
297 [PINMUX_TYPE_OUTPUT] = "output",
298 [PINMUX_TYPE_INPUT] = "input",
299 [PINMUX_TYPE_INPUT_PULLUP] = "input bias pull up",
300 [PINMUX_TYPE_INPUT_PULLDOWN] = "input bias pull down",
301 };
302 unsigned long config;
303 int rc;
304
305 rc = sh_pfc_pinconf_get(pctldev, pin, &config);
306 if (unlikely(rc != 0))
307 return;
308
309 seq_printf(s, " %s", pinmux_type_str[config]);
Paul Mundtca5481c62012-07-10 12:08:14 +0900310}
311
312static struct pinconf_ops sh_pfc_pinconf_ops = {
Paul Mundtca5481c62012-07-10 12:08:14 +0900313 .pin_config_get = sh_pfc_pinconf_get,
314 .pin_config_set = sh_pfc_pinconf_set,
Paul Mundtfdd85ec2012-07-20 16:39:09 +0900315 .pin_config_dbg_show = sh_pfc_pinconf_dbg_show,
Paul Mundtca5481c62012-07-10 12:08:14 +0900316};
317
318static struct pinctrl_gpio_range sh_pfc_gpio_range = {
Paul Mundt54407112012-07-20 16:18:21 +0900319 .name = DRV_NAME,
Paul Mundtca5481c62012-07-10 12:08:14 +0900320 .id = 0,
321};
322
323static struct pinctrl_desc sh_pfc_pinctrl_desc = {
Paul Mundt54407112012-07-20 16:18:21 +0900324 .name = DRV_NAME,
Paul Mundtca5481c62012-07-10 12:08:14 +0900325 .owner = THIS_MODULE,
326 .pctlops = &sh_pfc_pinctrl_ops,
327 .pmxops = &sh_pfc_pinmux_ops,
328 .confops = &sh_pfc_pinconf_ops,
329};
330
Laurent Pinchart4a2e0d12012-12-15 23:50:50 +0100331static void sh_pfc_map_one_gpio(struct sh_pfc *pfc, struct sh_pfc_pinctrl *pmx,
332 struct pinmux_gpio *gpio, unsigned offset)
Paul Mundtd93a8912012-07-11 17:17:10 +0900333{
334 struct pinmux_data_reg *dummy;
335 unsigned long flags;
336 int bit;
337
338 gpio->flags &= ~PINMUX_FLAG_TYPE;
339
340 if (sh_pfc_get_data_reg(pfc, offset, &dummy, &bit) == 0)
341 gpio->flags |= PINMUX_TYPE_GPIO;
342 else {
343 gpio->flags |= PINMUX_TYPE_FUNCTION;
344
345 spin_lock_irqsave(&pmx->lock, flags);
346 pmx->nr_functions++;
347 spin_unlock_irqrestore(&pmx->lock, flags);
348 }
349}
350
Paul Mundtca5481c62012-07-10 12:08:14 +0900351/* pinmux ranges -> pinctrl pin descs */
Greg Kroah-Hartman0fe763c2012-12-21 15:14:44 -0800352static int sh_pfc_map_gpios(struct sh_pfc *pfc, struct sh_pfc_pinctrl *pmx)
Paul Mundtca5481c62012-07-10 12:08:14 +0900353{
Paul Mundtd93a8912012-07-11 17:17:10 +0900354 unsigned long flags;
Paul Mundtca5481c62012-07-10 12:08:14 +0900355 int i;
356
Laurent Pinchartd4e62d02012-12-15 23:50:43 +0100357 pmx->nr_pads = pfc->pdata->last_gpio - pfc->pdata->first_gpio + 1;
Paul Mundtca5481c62012-07-10 12:08:14 +0900358
Laurent Pinchart1724acf2012-12-15 23:50:48 +0100359 pmx->pads = devm_kzalloc(pfc->dev, sizeof(*pmx->pads) * pmx->nr_pads,
360 GFP_KERNEL);
Paul Mundtca5481c62012-07-10 12:08:14 +0900361 if (unlikely(!pmx->pads)) {
362 pmx->nr_pads = 0;
363 return -ENOMEM;
364 }
365
Paul Mundtd93a8912012-07-11 17:17:10 +0900366 spin_lock_irqsave(&pfc->lock, flags);
367
Paul Mundtca5481c62012-07-10 12:08:14 +0900368 /*
369 * We don't necessarily have a 1:1 mapping between pin and linux
370 * GPIO number, as the latter maps to the associated enum_id.
371 * Care needs to be taken to translate back to pin space when
372 * dealing with any pin configurations.
373 */
374 for (i = 0; i < pmx->nr_pads; i++) {
375 struct pinctrl_pin_desc *pin = pmx->pads + i;
Laurent Pinchartd4e62d02012-12-15 23:50:43 +0100376 struct pinmux_gpio *gpio = pfc->pdata->gpios + i;
Paul Mundtca5481c62012-07-10 12:08:14 +0900377
Laurent Pinchartd4e62d02012-12-15 23:50:43 +0100378 pin->number = pfc->pdata->first_gpio + i;
Paul Mundtca5481c62012-07-10 12:08:14 +0900379 pin->name = gpio->name;
Paul Mundtd93a8912012-07-11 17:17:10 +0900380
Paul Mundte3e79452012-07-17 15:23:11 +0900381 /* XXX */
382 if (unlikely(!gpio->enum_id))
383 continue;
384
Paul Mundtd93a8912012-07-11 17:17:10 +0900385 sh_pfc_map_one_gpio(pfc, pmx, gpio, i);
Paul Mundtca5481c62012-07-10 12:08:14 +0900386 }
387
Paul Mundtd93a8912012-07-11 17:17:10 +0900388 spin_unlock_irqrestore(&pfc->lock, flags);
389
Paul Mundtca5481c62012-07-10 12:08:14 +0900390 sh_pfc_pinctrl_desc.pins = pmx->pads;
391 sh_pfc_pinctrl_desc.npins = pmx->nr_pads;
392
393 return 0;
394}
395
Greg Kroah-Hartman0fe763c2012-12-21 15:14:44 -0800396static int sh_pfc_map_functions(struct sh_pfc *pfc, struct sh_pfc_pinctrl *pmx)
Paul Mundtd93a8912012-07-11 17:17:10 +0900397{
398 unsigned long flags;
399 int i, fn;
400
Laurent Pinchart1724acf2012-12-15 23:50:48 +0100401 pmx->functions = devm_kzalloc(pfc->dev, pmx->nr_functions *
402 sizeof(*pmx->functions), GFP_KERNEL);
Paul Mundtd93a8912012-07-11 17:17:10 +0900403 if (unlikely(!pmx->functions))
404 return -ENOMEM;
405
406 spin_lock_irqsave(&pmx->lock, flags);
407
408 for (i = fn = 0; i < pmx->nr_pads; i++) {
Laurent Pinchartd4e62d02012-12-15 23:50:43 +0100409 struct pinmux_gpio *gpio = pfc->pdata->gpios + i;
Paul Mundtd93a8912012-07-11 17:17:10 +0900410
411 if ((gpio->flags & PINMUX_FLAG_TYPE) == PINMUX_TYPE_FUNCTION)
412 pmx->functions[fn++] = gpio;
413 }
414
415 spin_unlock_irqrestore(&pmx->lock, flags);
416
417 return 0;
418}
419
Laurent Pinchartc6193ea2012-12-15 23:50:47 +0100420int sh_pfc_register_pinctrl(struct sh_pfc *pfc)
Paul Mundtca5481c62012-07-10 12:08:14 +0900421{
Laurent Pinchartc6193ea2012-12-15 23:50:47 +0100422 struct sh_pfc_pinctrl *pmx;
Paul Mundtca5481c62012-07-10 12:08:14 +0900423 int ret;
424
Laurent Pinchart1724acf2012-12-15 23:50:48 +0100425 pmx = devm_kzalloc(pfc->dev, sizeof(*pmx), GFP_KERNEL);
Laurent Pinchartc6193ea2012-12-15 23:50:47 +0100426 if (unlikely(!pmx))
427 return -ENOMEM;
Paul Mundtca5481c62012-07-10 12:08:14 +0900428
Laurent Pinchartc6193ea2012-12-15 23:50:47 +0100429 spin_lock_init(&pmx->lock);
Paul Mundtca5481c62012-07-10 12:08:14 +0900430
Laurent Pinchartc6193ea2012-12-15 23:50:47 +0100431 pmx->pfc = pfc;
432 pfc->pinctrl = pmx;
433
434 ret = sh_pfc_map_gpios(pfc, pmx);
Paul Mundtca5481c62012-07-10 12:08:14 +0900435 if (unlikely(ret != 0))
436 return ret;
437
Laurent Pinchartc6193ea2012-12-15 23:50:47 +0100438 ret = sh_pfc_map_functions(pfc, pmx);
Paul Mundtd93a8912012-07-11 17:17:10 +0900439 if (unlikely(ret != 0))
Laurent Pinchart1724acf2012-12-15 23:50:48 +0100440 return ret;
Paul Mundtd93a8912012-07-11 17:17:10 +0900441
Laurent Pinchartc6193ea2012-12-15 23:50:47 +0100442 pmx->pctl = pinctrl_register(&sh_pfc_pinctrl_desc, pfc->dev, pmx);
Laurent Pinchart1724acf2012-12-15 23:50:48 +0100443 if (IS_ERR(pmx->pctl))
444 return PTR_ERR(pmx->pctl);
Paul Mundtca5481c62012-07-10 12:08:14 +0900445
Laurent Pinchartd4e62d02012-12-15 23:50:43 +0100446 sh_pfc_gpio_range.npins = pfc->pdata->last_gpio
447 - pfc->pdata->first_gpio + 1;
448 sh_pfc_gpio_range.base = pfc->pdata->first_gpio;
449 sh_pfc_gpio_range.pin_base = pfc->pdata->first_gpio;
Paul Mundtca5481c62012-07-10 12:08:14 +0900450
Laurent Pinchartc6193ea2012-12-15 23:50:47 +0100451 pinctrl_add_gpio_range(pmx->pctl, &sh_pfc_gpio_range);
Paul Mundtca5481c62012-07-10 12:08:14 +0900452
453 return 0;
Paul Mundtca5481c62012-07-10 12:08:14 +0900454}
455
Laurent Pinchartc6193ea2012-12-15 23:50:47 +0100456int sh_pfc_unregister_pinctrl(struct sh_pfc *pfc)
Paul Mundtca5481c62012-07-10 12:08:14 +0900457{
Laurent Pinchartc6193ea2012-12-15 23:50:47 +0100458 struct sh_pfc_pinctrl *pmx = pfc->pinctrl;
Paul Mundtca5481c62012-07-10 12:08:14 +0900459
Paul Mundtca5481c62012-07-10 12:08:14 +0900460 pinctrl_unregister(pmx->pctl);
461
Laurent Pinchartc6193ea2012-12-15 23:50:47 +0100462 pfc->pinctrl = NULL;
Paul Mundtca5481c62012-07-10 12:08:14 +0900463 return 0;
464}