blob: 895a41e2f30aefc8aff171d5a12861656cc8bf99 [file] [log] [blame]
Magnus Damm2967dab2008-10-08 20:41:43 +09001/*
Paul Mundtb3c185a2012-06-20 17:29:04 +09002 * SuperH Pin Function Controller support.
Magnus Damm2967dab2008-10-08 20:41:43 +09003 *
4 * Copyright (C) 2008 Magnus Damm
Paul Mundtb3c185a2012-06-20 17:29:04 +09005 * Copyright (C) 2009 - 2012 Paul Mundt
Magnus Damm2967dab2008-10-08 20:41:43 +09006 *
7 * This file is subject to the terms and conditions of the GNU General Public
8 * License. See the file "COPYING" in the main directory of this archive
9 * for more details.
10 */
Laurent Pinchartc6193ea2012-12-15 23:50:47 +010011
12#define DRV_NAME "sh-pfc"
Paul Mundtb72421d2010-10-04 03:54:56 +090013
Magnus Damm2967dab2008-10-08 20:41:43 +090014#include <linux/bitops.h>
Laurent Pinchart90efde22012-12-15 23:50:52 +010015#include <linux/err.h>
16#include <linux/errno.h>
17#include <linux/io.h>
Magnus Dammb0e10212011-12-09 12:14:27 +090018#include <linux/ioport.h>
Laurent Pinchart90efde22012-12-15 23:50:52 +010019#include <linux/kernel.h>
20#include <linux/module.h>
Laurent Pinchartfe1c9a82013-06-17 20:50:02 +020021#include <linux/of.h>
22#include <linux/of_device.h>
Paul Mundtca5481c62012-07-10 12:08:14 +090023#include <linux/pinctrl/machine.h>
Laurent Pinchartc6193ea2012-12-15 23:50:47 +010024#include <linux/platform_device.h>
Laurent Pinchart90efde22012-12-15 23:50:52 +010025#include <linux/slab.h>
Magnus Dammb0e10212011-12-09 12:14:27 +090026
Laurent Pinchartf9165132012-12-15 23:50:44 +010027#include "core.h"
28
Laurent Pinchart70c8f012013-12-11 04:26:26 +010029static int sh_pfc_map_resources(struct sh_pfc *pfc,
30 struct platform_device *pdev)
Magnus Dammb0e10212011-12-09 12:14:27 +090031{
Laurent Pinchart70c8f012013-12-11 04:26:26 +010032 unsigned int num_windows = 0;
33 unsigned int num_irqs = 0;
34 struct sh_pfc_window *windows;
35 unsigned int *irqs = NULL;
Magnus Dammb0e10212011-12-09 12:14:27 +090036 struct resource *res;
Laurent Pinchart70c8f012013-12-11 04:26:26 +010037 unsigned int i;
Magnus Dammb0e10212011-12-09 12:14:27 +090038
Laurent Pinchart70c8f012013-12-11 04:26:26 +010039 /* Count the MEM and IRQ resources. */
40 for (i = 0; i < pdev->num_resources; ++i) {
41 switch (resource_type(&pdev->resource[i])) {
42 case IORESOURCE_MEM:
43 num_windows++;
44 break;
45
46 case IORESOURCE_IRQ:
47 num_irqs++;
48 break;
49 }
50 }
51
52 if (num_windows == 0)
Laurent Pinchartbee9f222013-02-16 23:39:07 +010053 return -EINVAL;
Laurent Pinchart973931a2012-12-15 23:50:55 +010054
Laurent Pinchart70c8f012013-12-11 04:26:26 +010055 /* Allocate memory windows and IRQs arrays. */
56 windows = devm_kzalloc(pfc->dev, num_windows * sizeof(*windows),
57 GFP_KERNEL);
58 if (windows == NULL)
Laurent Pinchart1724acf2012-12-15 23:50:48 +010059 return -ENOMEM;
Magnus Dammb0e10212011-12-09 12:14:27 +090060
Laurent Pinchart70c8f012013-12-11 04:26:26 +010061 pfc->num_windows = num_windows;
62 pfc->windows = windows;
Laurent Pinchart973931a2012-12-15 23:50:55 +010063
Laurent Pinchart70c8f012013-12-11 04:26:26 +010064 if (num_irqs) {
65 irqs = devm_kzalloc(pfc->dev, num_irqs * sizeof(*irqs),
66 GFP_KERNEL);
67 if (irqs == NULL)
Laurent Pinchart1724acf2012-12-15 23:50:48 +010068 return -ENOMEM;
Laurent Pinchart70c8f012013-12-11 04:26:26 +010069
70 pfc->num_irqs = num_irqs;
71 pfc->irqs = irqs;
72 }
73
74 /* Fill them. */
75 for (i = 0, res = pdev->resource; i < pdev->num_resources; i++, res++) {
76 switch (resource_type(res)) {
77 case IORESOURCE_MEM:
78 windows->phys = res->start;
79 windows->size = resource_size(res);
80 windows->virt = devm_ioremap_resource(pfc->dev, res);
81 if (IS_ERR(windows->virt))
82 return -ENOMEM;
83 windows++;
84 break;
85
86 case IORESOURCE_IRQ:
87 *irqs++ = res->start;
88 break;
89 }
Magnus Dammb0e10212011-12-09 12:14:27 +090090 }
91
92 return 0;
Magnus Dammb0e10212011-12-09 12:14:27 +090093}
94
Laurent Pincharte51d5342013-02-17 00:26:33 +010095static void __iomem *sh_pfc_phys_to_virt(struct sh_pfc *pfc,
96 unsigned long address)
Magnus Dammb0e10212011-12-09 12:14:27 +090097{
Laurent Pinchart4aeacd52012-12-15 23:50:53 +010098 struct sh_pfc_window *window;
Laurent Pinchartbee9f222013-02-16 23:39:07 +010099 unsigned int i;
Magnus Dammb0e10212011-12-09 12:14:27 +0900100
101 /* scan through physical windows and convert address */
Laurent Pinchartbee9f222013-02-16 23:39:07 +0100102 for (i = 0; i < pfc->num_windows; i++) {
Laurent Pinchart5b46ac32013-12-11 04:26:25 +0100103 window = pfc->windows + i;
Magnus Dammb0e10212011-12-09 12:14:27 +0900104
105 if (address < window->phys)
106 continue;
107
108 if (address >= (window->phys + window->size))
109 continue;
110
111 return window->virt + (address - window->phys);
112 }
113
Laurent Pinchartbee9f222013-02-16 23:39:07 +0100114 BUG();
Laurent Pinchart1960d582013-03-26 01:44:52 +0100115 return NULL;
Magnus Dammb0e10212011-12-09 12:14:27 +0900116}
Magnus Damm2967dab2008-10-08 20:41:43 +0900117
Laurent Pinchart1a0039d2013-03-08 17:43:54 +0100118int sh_pfc_get_pin_index(struct sh_pfc *pfc, unsigned int pin)
Laurent Pinchart934cb022013-02-14 22:35:09 +0100119{
Laurent Pinchart63d57382013-02-15 01:33:38 +0100120 unsigned int offset;
121 unsigned int i;
122
Laurent Pinchartacac8ed2013-07-15 18:38:30 +0200123 for (i = 0, offset = 0; i < pfc->nr_ranges; ++i) {
124 const struct sh_pfc_pin_range *range = &pfc->ranges[i];
Laurent Pinchart63d57382013-02-15 01:33:38 +0100125
126 if (pin <= range->end)
Laurent Pinchartacac8ed2013-07-15 18:38:30 +0200127 return pin >= range->start
128 ? offset + pin - range->start : -1;
Laurent Pinchart63d57382013-02-15 01:33:38 +0100129
Laurent Pinchartacac8ed2013-07-15 18:38:30 +0200130 offset += range->end - range->start + 1;
Laurent Pinchart63d57382013-02-15 01:33:38 +0100131 }
132
Laurent Pinchartb705c052013-03-10 16:38:23 +0100133 return -EINVAL;
Laurent Pinchart934cb022013-02-14 22:35:09 +0100134}
135
Laurent Pinchart533743d2013-07-15 13:03:20 +0200136static int sh_pfc_enum_in_range(u16 enum_id, const struct pinmux_range *r)
Magnus Damm2967dab2008-10-08 20:41:43 +0900137{
138 if (enum_id < r->begin)
139 return 0;
140
141 if (enum_id > r->end)
142 return 0;
143
144 return 1;
145}
146
Geert Uytterhoevenfc889362015-02-27 18:38:04 +0100147u32 sh_pfc_read_raw_reg(void __iomem *mapped_reg, unsigned long reg_width)
Magnus Damm32920942008-12-25 18:17:26 +0900148{
149 switch (reg_width) {
150 case 8:
Magnus Dammb0e10212011-12-09 12:14:27 +0900151 return ioread8(mapped_reg);
Magnus Damm32920942008-12-25 18:17:26 +0900152 case 16:
Magnus Dammb0e10212011-12-09 12:14:27 +0900153 return ioread16(mapped_reg);
Magnus Damm32920942008-12-25 18:17:26 +0900154 case 32:
Magnus Dammb0e10212011-12-09 12:14:27 +0900155 return ioread32(mapped_reg);
Magnus Damm32920942008-12-25 18:17:26 +0900156 }
157
158 BUG();
159 return 0;
160}
161
Laurent Pinchart41f12192013-02-15 02:04:55 +0100162void sh_pfc_write_raw_reg(void __iomem *mapped_reg, unsigned long reg_width,
Geert Uytterhoevenfc889362015-02-27 18:38:04 +0100163 u32 data)
Magnus Damm32920942008-12-25 18:17:26 +0900164{
165 switch (reg_width) {
166 case 8:
Magnus Dammb0e10212011-12-09 12:14:27 +0900167 iowrite8(data, mapped_reg);
Magnus Damm32920942008-12-25 18:17:26 +0900168 return;
169 case 16:
Magnus Dammb0e10212011-12-09 12:14:27 +0900170 iowrite16(data, mapped_reg);
Magnus Damm32920942008-12-25 18:17:26 +0900171 return;
172 case 32:
Magnus Dammb0e10212011-12-09 12:14:27 +0900173 iowrite32(data, mapped_reg);
Magnus Damm32920942008-12-25 18:17:26 +0900174 return;
175 }
176
177 BUG();
178}
179
Laurent Pinchart4aeacd52012-12-15 23:50:53 +0100180static void sh_pfc_config_reg_helper(struct sh_pfc *pfc,
Laurent Pinchartcd3c1be2013-02-16 18:47:05 +0100181 const struct pinmux_cfg_reg *crp,
Laurent Pinchart4aeacd52012-12-15 23:50:53 +0100182 unsigned long in_pos,
Geert Uytterhoevenfc889362015-02-27 18:38:04 +0100183 void __iomem **mapped_regp, u32 *maskp,
Laurent Pinchart4aeacd52012-12-15 23:50:53 +0100184 unsigned long *posp)
Magnus Damm2967dab2008-10-08 20:41:43 +0900185{
Laurent Pinchart8d72a7f2013-12-11 04:26:21 +0100186 unsigned int k;
Magnus Dammf78a26f2011-12-14 01:01:05 +0900187
Laurent Pinchart4aeacd52012-12-15 23:50:53 +0100188 *mapped_regp = sh_pfc_phys_to_virt(pfc, crp->reg);
Magnus Damm2967dab2008-10-08 20:41:43 +0900189
Magnus Dammf78a26f2011-12-14 01:01:05 +0900190 if (crp->field_width) {
191 *maskp = (1 << crp->field_width) - 1;
192 *posp = crp->reg_width - ((in_pos + 1) * crp->field_width);
193 } else {
194 *maskp = (1 << crp->var_field_width[in_pos]) - 1;
195 *posp = crp->reg_width;
196 for (k = 0; k <= in_pos; k++)
197 *posp -= crp->var_field_width[k];
198 }
Magnus Damm0fc64cc2008-12-25 18:17:18 +0900199}
Magnus Damm2967dab2008-10-08 20:41:43 +0900200
Laurent Pinchart4aeacd52012-12-15 23:50:53 +0100201static void sh_pfc_write_config_reg(struct sh_pfc *pfc,
Laurent Pinchartcd3c1be2013-02-16 18:47:05 +0100202 const struct pinmux_cfg_reg *crp,
Geert Uytterhoevenfc889362015-02-27 18:38:04 +0100203 unsigned long field, u32 value)
Magnus Damm18925e12011-12-14 01:00:55 +0900204{
205 void __iomem *mapped_reg;
Geert Uytterhoevenfc889362015-02-27 18:38:04 +0100206 unsigned long pos;
207 u32 mask, data;
Magnus Damm18925e12011-12-14 01:00:55 +0900208
Laurent Pinchart4aeacd52012-12-15 23:50:53 +0100209 sh_pfc_config_reg_helper(pfc, crp, field, &mapped_reg, &mask, &pos);
Magnus Damm18925e12011-12-14 01:00:55 +0900210
Geert Uytterhoevenfc889362015-02-27 18:38:04 +0100211 dev_dbg(pfc->dev, "write_reg addr = %lx, value = 0x%x, field = %ld, "
Laurent Pinchart9a643c92013-03-10 18:00:02 +0100212 "r_width = %ld, f_width = %ld\n",
213 crp->reg, value, field, crp->reg_width, crp->field_width);
Magnus Damm0fc64cc2008-12-25 18:17:18 +0900214
215 mask = ~(mask << pos);
216 value = value << pos;
Magnus Damm2967dab2008-10-08 20:41:43 +0900217
Laurent Pinchart4aeacd52012-12-15 23:50:53 +0100218 data = sh_pfc_read_raw_reg(mapped_reg, crp->reg_width);
Magnus Damme499ada2011-12-14 01:01:14 +0900219 data &= mask;
220 data |= value;
221
Laurent Pinchart19bb7fe32012-12-15 23:51:20 +0100222 if (pfc->info->unlock_reg)
Laurent Pinchart4aeacd52012-12-15 23:50:53 +0100223 sh_pfc_write_raw_reg(
Laurent Pinchart19bb7fe32012-12-15 23:51:20 +0100224 sh_pfc_phys_to_virt(pfc, pfc->info->unlock_reg), 32,
Laurent Pinchart4aeacd52012-12-15 23:50:53 +0100225 ~data);
Magnus Damme499ada2011-12-14 01:01:14 +0900226
Laurent Pinchart4aeacd52012-12-15 23:50:53 +0100227 sh_pfc_write_raw_reg(mapped_reg, crp->reg_width, data);
Magnus Damm2967dab2008-10-08 20:41:43 +0900228}
229
Laurent Pinchart533743d2013-07-15 13:03:20 +0200230static int sh_pfc_get_config_reg(struct sh_pfc *pfc, u16 enum_id,
Laurent Pinchartcd3c1be2013-02-16 18:47:05 +0100231 const struct pinmux_cfg_reg **crp, int *fieldp,
Geert Uytterhoevenfc889362015-02-27 18:38:04 +0100232 u32 *valuep)
Magnus Damm2967dab2008-10-08 20:41:43 +0900233{
Laurent Pinchartcd3c1be2013-02-16 18:47:05 +0100234 const struct pinmux_cfg_reg *config_reg;
Geert Uytterhoevenfc889362015-02-27 18:38:04 +0100235 unsigned long r_width, f_width, curr_width;
236 unsigned int k, m, pos, bit_pos;
237 u32 ncomb, n;
Magnus Damm2967dab2008-10-08 20:41:43 +0900238
239 k = 0;
240 while (1) {
Laurent Pinchart19bb7fe32012-12-15 23:51:20 +0100241 config_reg = pfc->info->cfg_regs + k;
Magnus Damm2967dab2008-10-08 20:41:43 +0900242
243 r_width = config_reg->reg_width;
244 f_width = config_reg->field_width;
245
246 if (!r_width)
247 break;
Magnus Dammf78a26f2011-12-14 01:01:05 +0900248
249 pos = 0;
250 m = 0;
251 for (bit_pos = 0; bit_pos < r_width; bit_pos += curr_width) {
252 if (f_width)
253 curr_width = f_width;
254 else
255 curr_width = config_reg->var_field_width[m];
256
257 ncomb = 1 << curr_width;
258 for (n = 0; n < ncomb; n++) {
259 if (config_reg->enum_ids[pos + n] == enum_id) {
260 *crp = config_reg;
261 *fieldp = m;
262 *valuep = n;
Magnus Dammf78a26f2011-12-14 01:01:05 +0900263 return 0;
264 }
Magnus Damm2967dab2008-10-08 20:41:43 +0900265 }
Magnus Dammf78a26f2011-12-14 01:01:05 +0900266 pos += ncomb;
267 m++;
Magnus Damm2967dab2008-10-08 20:41:43 +0900268 }
269 k++;
270 }
271
Laurent Pinchartb705c052013-03-10 16:38:23 +0100272 return -EINVAL;
Magnus Damm2967dab2008-10-08 20:41:43 +0900273}
274
Laurent Pinchart533743d2013-07-15 13:03:20 +0200275static int sh_pfc_mark_to_enum(struct sh_pfc *pfc, u16 mark, int pos,
276 u16 *enum_idp)
Magnus Damm2967dab2008-10-08 20:41:43 +0900277{
Laurent Pinchart533743d2013-07-15 13:03:20 +0200278 const u16 *data = pfc->info->gpio_data;
Laurent Pinchart8d72a7f2013-12-11 04:26:21 +0100279 unsigned int k;
Magnus Damm2967dab2008-10-08 20:41:43 +0900280
Magnus Damm2967dab2008-10-08 20:41:43 +0900281 if (pos) {
282 *enum_idp = data[pos + 1];
283 return pos + 1;
284 }
285
Laurent Pinchart19bb7fe32012-12-15 23:51:20 +0100286 for (k = 0; k < pfc->info->gpio_data_size; k++) {
Laurent Pincharta68fdca92013-02-14 17:36:56 +0100287 if (data[k] == mark) {
Magnus Damm2967dab2008-10-08 20:41:43 +0900288 *enum_idp = data[k + 1];
289 return k + 1;
290 }
291 }
292
Laurent Pinchart9a643c92013-03-10 18:00:02 +0100293 dev_err(pfc->dev, "cannot locate data/mark enum_id for mark %d\n",
294 mark);
Laurent Pinchartb705c052013-03-10 16:38:23 +0100295 return -EINVAL;
Magnus Damm2967dab2008-10-08 20:41:43 +0900296}
297
Laurent Pinchart861601d2013-03-10 15:29:14 +0100298int sh_pfc_config_mux(struct sh_pfc *pfc, unsigned mark, int pinmux_type)
Magnus Damm2967dab2008-10-08 20:41:43 +0900299{
Laurent Pinchartcd3c1be2013-02-16 18:47:05 +0100300 const struct pinmux_cfg_reg *cr = NULL;
Laurent Pinchart533743d2013-07-15 13:03:20 +0200301 u16 enum_id;
Laurent Pinchartcd3c1be2013-02-16 18:47:05 +0100302 const struct pinmux_range *range;
Geert Uytterhoevenfc889362015-02-27 18:38:04 +0100303 int in_range, pos, field;
304 u32 value;
Laurent Pinchartb705c052013-03-10 16:38:23 +0100305 int ret;
Magnus Damm2967dab2008-10-08 20:41:43 +0900306
307 switch (pinmux_type) {
Laurent Pincharte3c47052013-03-10 17:30:25 +0100308 case PINMUX_TYPE_GPIO:
Magnus Damm2967dab2008-10-08 20:41:43 +0900309 case PINMUX_TYPE_FUNCTION:
310 range = NULL;
311 break;
312
313 case PINMUX_TYPE_OUTPUT:
Laurent Pinchart19bb7fe32012-12-15 23:51:20 +0100314 range = &pfc->info->output;
Magnus Damm2967dab2008-10-08 20:41:43 +0900315 break;
316
317 case PINMUX_TYPE_INPUT:
Laurent Pinchart19bb7fe32012-12-15 23:51:20 +0100318 range = &pfc->info->input;
Magnus Damm2967dab2008-10-08 20:41:43 +0900319 break;
320
Magnus Damm2967dab2008-10-08 20:41:43 +0900321 default:
Laurent Pinchartb705c052013-03-10 16:38:23 +0100322 return -EINVAL;
Magnus Damm2967dab2008-10-08 20:41:43 +0900323 }
324
325 pos = 0;
326 enum_id = 0;
Magnus Dammad4a07f2011-12-14 01:00:46 +0900327 field = 0;
328 value = 0;
Laurent Pincharte3c47052013-03-10 17:30:25 +0100329
330 /* Iterate over all the configuration fields we need to update. */
Magnus Damm2967dab2008-10-08 20:41:43 +0900331 while (1) {
Laurent Pincharta68fdca92013-02-14 17:36:56 +0100332 pos = sh_pfc_mark_to_enum(pfc, mark, pos, &enum_id);
Laurent Pinchartb705c052013-03-10 16:38:23 +0100333 if (pos < 0)
334 return pos;
Magnus Damm2967dab2008-10-08 20:41:43 +0900335
336 if (!enum_id)
337 break;
338
Laurent Pincharte3c47052013-03-10 17:30:25 +0100339 /* Check if the configuration field selects a function. If it
340 * doesn't, skip the field if it's not applicable to the
341 * requested pinmux type.
342 */
Laurent Pinchart19bb7fe32012-12-15 23:51:20 +0100343 in_range = sh_pfc_enum_in_range(enum_id, &pfc->info->function);
Magnus Damm50dd3142010-01-19 13:52:28 +0000344 if (!in_range) {
Laurent Pincharte3c47052013-03-10 17:30:25 +0100345 if (pinmux_type == PINMUX_TYPE_FUNCTION) {
346 /* Functions are allowed to modify all
347 * fields.
348 */
349 in_range = 1;
350 } else if (pinmux_type != PINMUX_TYPE_GPIO) {
351 /* Input/output types can only modify fields
352 * that correspond to their respective ranges.
Magnus Damm50dd3142010-01-19 13:52:28 +0000353 */
Laurent Pinchart4aeacd52012-12-15 23:50:53 +0100354 in_range = sh_pfc_enum_in_range(enum_id, range);
Magnus Damm2967dab2008-10-08 20:41:43 +0900355
Magnus Damm50dd3142010-01-19 13:52:28 +0000356 /*
357 * special case pass through for fixed
358 * input-only or output-only pins without
359 * function enum register association.
360 */
361 if (in_range && enum_id == range->force)
362 continue;
Magnus Damm50dd3142010-01-19 13:52:28 +0000363 }
Laurent Pincharte3c47052013-03-10 17:30:25 +0100364 /* GPIOs are only allowed to modify function fields. */
Magnus Damm42eed422008-10-22 18:29:17 +0900365 }
366
Magnus Damm2967dab2008-10-08 20:41:43 +0900367 if (!in_range)
368 continue;
369
Laurent Pinchartb705c052013-03-10 16:38:23 +0100370 ret = sh_pfc_get_config_reg(pfc, enum_id, &cr, &field, &value);
371 if (ret < 0)
372 return ret;
Magnus Damm2967dab2008-10-08 20:41:43 +0900373
Laurent Pinchart861601d2013-03-10 15:29:14 +0100374 sh_pfc_write_config_reg(pfc, cr, field, value);
Magnus Damm2967dab2008-10-08 20:41:43 +0900375 }
376
377 return 0;
Magnus Damm2967dab2008-10-08 20:41:43 +0900378}
379
Laurent Pinchartacac8ed2013-07-15 18:38:30 +0200380static int sh_pfc_init_ranges(struct sh_pfc *pfc)
381{
382 struct sh_pfc_pin_range *range;
383 unsigned int nr_ranges;
384 unsigned int i;
385
386 if (pfc->info->pins[0].pin == (u16)-1) {
387 /* Pin number -1 denotes that the SoC doesn't report pin numbers
388 * in its pin arrays yet. Consider the pin numbers range as
389 * continuous and allocate a single range.
390 */
391 pfc->nr_ranges = 1;
392 pfc->ranges = devm_kzalloc(pfc->dev, sizeof(*pfc->ranges),
393 GFP_KERNEL);
394 if (pfc->ranges == NULL)
395 return -ENOMEM;
396
397 pfc->ranges->start = 0;
398 pfc->ranges->end = pfc->info->nr_pins - 1;
399 pfc->nr_gpio_pins = pfc->info->nr_pins;
400
401 return 0;
402 }
403
Laurent Pinchart4f82e3e2013-07-15 21:10:54 +0200404 /* Count, allocate and fill the ranges. The PFC SoC data pins array must
405 * be sorted by pin numbers, and pins without a GPIO port must come
406 * last.
407 */
Laurent Pinchartacac8ed2013-07-15 18:38:30 +0200408 for (i = 1, nr_ranges = 1; i < pfc->info->nr_pins; ++i) {
409 if (pfc->info->pins[i-1].pin != pfc->info->pins[i].pin - 1)
410 nr_ranges++;
411 }
412
413 pfc->nr_ranges = nr_ranges;
414 pfc->ranges = devm_kzalloc(pfc->dev, sizeof(*pfc->ranges) * nr_ranges,
415 GFP_KERNEL);
416 if (pfc->ranges == NULL)
417 return -ENOMEM;
418
419 range = pfc->ranges;
420 range->start = pfc->info->pins[0].pin;
421
422 for (i = 1; i < pfc->info->nr_pins; ++i) {
Laurent Pinchart4f82e3e2013-07-15 21:10:54 +0200423 if (pfc->info->pins[i-1].pin == pfc->info->pins[i].pin - 1)
424 continue;
425
426 range->end = pfc->info->pins[i-1].pin;
427 if (!(pfc->info->pins[i-1].configs & SH_PFC_PIN_CFG_NO_GPIO))
428 pfc->nr_gpio_pins = range->end + 1;
429
430 range++;
431 range->start = pfc->info->pins[i].pin;
Laurent Pinchartacac8ed2013-07-15 18:38:30 +0200432 }
433
434 range->end = pfc->info->pins[i-1].pin;
Laurent Pinchart4f82e3e2013-07-15 21:10:54 +0200435 if (!(pfc->info->pins[i-1].configs & SH_PFC_PIN_CFG_NO_GPIO))
436 pfc->nr_gpio_pins = range->end + 1;
Laurent Pinchartacac8ed2013-07-15 18:38:30 +0200437
438 return 0;
439}
440
Laurent Pinchartfe1c9a82013-06-17 20:50:02 +0200441#ifdef CONFIG_OF
442static const struct of_device_id sh_pfc_of_table[] = {
Niklas Söderlund1e7d5d82015-01-25 14:49:52 +0100443#ifdef CONFIG_PINCTRL_PFC_EMEV2
444 {
445 .compatible = "renesas,pfc-emev2",
446 .data = &emev2_pinmux_info,
447 },
448#endif
Laurent Pinchartfe1c9a82013-06-17 20:50:02 +0200449#ifdef CONFIG_PINCTRL_PFC_R8A73A4
450 {
451 .compatible = "renesas,pfc-r8a73a4",
452 .data = &r8a73a4_pinmux_info,
453 },
454#endif
455#ifdef CONFIG_PINCTRL_PFC_R8A7740
456 {
457 .compatible = "renesas,pfc-r8a7740",
458 .data = &r8a7740_pinmux_info,
459 },
460#endif
461#ifdef CONFIG_PINCTRL_PFC_R8A7778
462 {
463 .compatible = "renesas,pfc-r8a7778",
464 .data = &r8a7778_pinmux_info,
465 },
466#endif
467#ifdef CONFIG_PINCTRL_PFC_R8A7779
468 {
469 .compatible = "renesas,pfc-r8a7779",
470 .data = &r8a7779_pinmux_info,
471 },
472#endif
473#ifdef CONFIG_PINCTRL_PFC_R8A7790
474 {
475 .compatible = "renesas,pfc-r8a7790",
476 .data = &r8a7790_pinmux_info,
477 },
478#endif
Hisashi Nakamura50884512013-10-17 06:46:05 +0900479#ifdef CONFIG_PINCTRL_PFC_R8A7791
480 {
481 .compatible = "renesas,pfc-r8a7791",
482 .data = &r8a7791_pinmux_info,
483 },
484#endif
Laurent Pinchartfe1c9a82013-06-17 20:50:02 +0200485#ifdef CONFIG_PINCTRL_PFC_SH73A0
486 {
487 .compatible = "renesas,pfc-sh73a0",
488 .data = &sh73a0_pinmux_info,
489 },
490#endif
491 { },
492};
493MODULE_DEVICE_TABLE(of, sh_pfc_of_table);
494#endif
495
Laurent Pinchartc6193ea2012-12-15 23:50:47 +0100496static int sh_pfc_probe(struct platform_device *pdev)
Magnus Damm2967dab2008-10-08 20:41:43 +0900497{
Laurent Pinchartfe1c9a82013-06-17 20:50:02 +0200498 const struct platform_device_id *platid = platform_get_device_id(pdev);
499#ifdef CONFIG_OF
500 struct device_node *np = pdev->dev.of_node;
501#endif
Laurent Pinchartcd3c1be2013-02-16 18:47:05 +0100502 const struct sh_pfc_soc_info *info;
Laurent Pinchartc6193ea2012-12-15 23:50:47 +0100503 struct sh_pfc *pfc;
Magnus Damm0fc64cc2008-12-25 18:17:18 +0900504 int ret;
Magnus Damm2967dab2008-10-08 20:41:43 +0900505
Laurent Pinchartfe1c9a82013-06-17 20:50:02 +0200506#ifdef CONFIG_OF
507 if (np)
508 info = of_match_device(sh_pfc_of_table, &pdev->dev)->data;
509 else
510#endif
511 info = platid ? (const void *)platid->driver_data : NULL;
512
Laurent Pinchart19bb7fe32012-12-15 23:51:20 +0100513 if (info == NULL)
Laurent Pinchartc6193ea2012-12-15 23:50:47 +0100514 return -ENODEV;
Magnus Damm0fc64cc2008-12-25 18:17:18 +0900515
Magnus Damm8c43fcc2013-02-14 21:23:47 +0900516 pfc = devm_kzalloc(&pdev->dev, sizeof(*pfc), GFP_KERNEL);
Laurent Pinchartc6193ea2012-12-15 23:50:47 +0100517 if (pfc == NULL)
518 return -ENOMEM;
Magnus Dammb0e10212011-12-09 12:14:27 +0900519
Laurent Pinchart19bb7fe32012-12-15 23:51:20 +0100520 pfc->info = info;
Laurent Pinchartc6193ea2012-12-15 23:50:47 +0100521 pfc->dev = &pdev->dev;
522
Laurent Pinchart70c8f012013-12-11 04:26:26 +0100523 ret = sh_pfc_map_resources(pfc, pdev);
Laurent Pinchartc6193ea2012-12-15 23:50:47 +0100524 if (unlikely(ret < 0))
Laurent Pinchartd4e62d02012-12-15 23:50:43 +0100525 return ret;
Laurent Pinchartd4e62d02012-12-15 23:50:43 +0100526
Laurent Pinchartc6193ea2012-12-15 23:50:47 +0100527 spin_lock_init(&pfc->lock);
Magnus Damm69edbba2008-12-25 18:17:34 +0900528
Laurent Pinchart0c151062013-04-21 20:21:57 +0200529 if (info->ops && info->ops->init) {
530 ret = info->ops->init(pfc);
531 if (ret < 0)
532 return ret;
533 }
534
Paul Mundtca5481c62012-07-10 12:08:14 +0900535 pinctrl_provide_dummies();
Magnus Damm69edbba2008-12-25 18:17:34 +0900536
Laurent Pinchartacac8ed2013-07-15 18:38:30 +0200537 ret = sh_pfc_init_ranges(pfc);
538 if (ret < 0)
539 return ret;
540
Paul Mundtca5481c62012-07-10 12:08:14 +0900541 /*
542 * Initialize pinctrl bindings first
543 */
Laurent Pinchartc6193ea2012-12-15 23:50:47 +0100544 ret = sh_pfc_register_pinctrl(pfc);
Laurent Pinchartf9492fd2012-12-15 23:50:45 +0100545 if (unlikely(ret != 0))
Laurent Pinchart0a332c92014-09-11 00:55:55 +0300546 return ret;
Magnus Damm69edbba2008-12-25 18:17:34 +0900547
Laurent Pinchart6f6a4a62012-12-15 23:50:46 +0100548#ifdef CONFIG_GPIO_SH_PFC
Paul Mundtca5481c62012-07-10 12:08:14 +0900549 /*
550 * Then the GPIO chip
551 */
Laurent Pinchartc6193ea2012-12-15 23:50:47 +0100552 ret = sh_pfc_register_gpiochip(pfc);
Laurent Pinchart6f6a4a62012-12-15 23:50:46 +0100553 if (unlikely(ret != 0)) {
Paul Mundtca5481c62012-07-10 12:08:14 +0900554 /*
555 * If the GPIO chip fails to come up we still leave the
556 * PFC state as it is, given that there are already
557 * extant users of it that have succeeded by this point.
558 */
Laurent Pinchart9a643c92013-03-10 18:00:02 +0100559 dev_notice(pfc->dev, "failed to init GPIO chip, ignoring...\n");
Paul Mundtca5481c62012-07-10 12:08:14 +0900560 }
Laurent Pinchart6f6a4a62012-12-15 23:50:46 +0100561#endif
Paul Mundtca5481c62012-07-10 12:08:14 +0900562
Laurent Pinchartc6193ea2012-12-15 23:50:47 +0100563 platform_set_drvdata(pdev, pfc);
564
Laurent Pinchart9a643c92013-03-10 18:00:02 +0100565 dev_info(pfc->dev, "%s support registered\n", info->name);
Paul Mundtca5481c62012-07-10 12:08:14 +0900566
Paul Mundtb3c185a2012-06-20 17:29:04 +0900567 return 0;
Paul Mundtb72421d2010-10-04 03:54:56 +0900568}
Laurent Pinchart6f6a4a62012-12-15 23:50:46 +0100569
Laurent Pinchartc6193ea2012-12-15 23:50:47 +0100570static int sh_pfc_remove(struct platform_device *pdev)
571{
572 struct sh_pfc *pfc = platform_get_drvdata(pdev);
573
574#ifdef CONFIG_GPIO_SH_PFC
575 sh_pfc_unregister_gpiochip(pfc);
576#endif
577 sh_pfc_unregister_pinctrl(pfc);
578
Laurent Pinchartc6193ea2012-12-15 23:50:47 +0100579 return 0;
580}
581
582static const struct platform_device_id sh_pfc_id_table[] = {
Niklas Söderlund1e7d5d82015-01-25 14:49:52 +0100583#ifdef CONFIG_PINCTRL_PFC_EMEV2
584 { "pfc-emev2", (kernel_ulong_t)&emev2_pinmux_info },
585#endif
Magnus Dammc98f6c22013-03-26 22:49:49 +0900586#ifdef CONFIG_PINCTRL_PFC_R8A73A4
587 { "pfc-r8a73a4", (kernel_ulong_t)&r8a73a4_pinmux_info },
588#endif
Laurent Pinchartd5b15212012-12-15 23:51:21 +0100589#ifdef CONFIG_PINCTRL_PFC_R8A7740
590 { "pfc-r8a7740", (kernel_ulong_t)&r8a7740_pinmux_info },
591#endif
Kuninori Morimoto87f8c982013-04-12 05:37:20 +0000592#ifdef CONFIG_PINCTRL_PFC_R8A7778
593 { "pfc-r8a7778", (kernel_ulong_t)&r8a7778_pinmux_info },
594#endif
Laurent Pinchart881023d2012-12-15 23:51:22 +0100595#ifdef CONFIG_PINCTRL_PFC_R8A7779
596 { "pfc-r8a7779", (kernel_ulong_t)&r8a7779_pinmux_info },
597#endif
Koji Matsuoka58c229e2013-04-08 11:08:53 +0900598#ifdef CONFIG_PINCTRL_PFC_R8A7790
599 { "pfc-r8a7790", (kernel_ulong_t)&r8a7790_pinmux_info },
600#endif
Laurent Pinchartccda5522012-12-15 23:51:29 +0100601#ifdef CONFIG_PINCTRL_PFC_SH7203
602 { "pfc-sh7203", (kernel_ulong_t)&sh7203_pinmux_info },
603#endif
Laurent Pincharta8d42fc2012-12-15 23:51:30 +0100604#ifdef CONFIG_PINCTRL_PFC_SH7264
605 { "pfc-sh7264", (kernel_ulong_t)&sh7264_pinmux_info },
606#endif
Laurent Pinchartf5e811f2012-12-15 23:51:31 +0100607#ifdef CONFIG_PINCTRL_PFC_SH7269
608 { "pfc-sh7269", (kernel_ulong_t)&sh7269_pinmux_info },
609#endif
Laurent Pinchart5d5166d2012-12-15 23:51:24 +0100610#ifdef CONFIG_PINCTRL_PFC_SH73A0
611 { "pfc-sh73a0", (kernel_ulong_t)&sh73a0_pinmux_info },
612#endif
Laurent Pinchart74cad602012-12-15 23:51:32 +0100613#ifdef CONFIG_PINCTRL_PFC_SH7720
614 { "pfc-sh7720", (kernel_ulong_t)&sh7720_pinmux_info },
615#endif
Laurent Pinchartf5e25ae2012-12-15 23:51:33 +0100616#ifdef CONFIG_PINCTRL_PFC_SH7722
617 { "pfc-sh7722", (kernel_ulong_t)&sh7722_pinmux_info },
618#endif
Laurent Pinchartd05afa02012-12-15 23:51:34 +0100619#ifdef CONFIG_PINCTRL_PFC_SH7723
620 { "pfc-sh7723", (kernel_ulong_t)&sh7723_pinmux_info },
621#endif
Laurent Pinchart0ff25ba2012-12-15 23:51:35 +0100622#ifdef CONFIG_PINCTRL_PFC_SH7724
623 { "pfc-sh7724", (kernel_ulong_t)&sh7724_pinmux_info },
624#endif
Laurent Pinchartac1ebc22012-12-15 23:51:36 +0100625#ifdef CONFIG_PINCTRL_PFC_SH7734
626 { "pfc-sh7734", (kernel_ulong_t)&sh7734_pinmux_info },
627#endif
Laurent Pinchart0bb92672012-12-15 23:51:37 +0100628#ifdef CONFIG_PINCTRL_PFC_SH7757
629 { "pfc-sh7757", (kernel_ulong_t)&sh7757_pinmux_info },
630#endif
Laurent Pincharta56398e2012-12-15 23:51:38 +0100631#ifdef CONFIG_PINCTRL_PFC_SH7785
632 { "pfc-sh7785", (kernel_ulong_t)&sh7785_pinmux_info },
633#endif
Laurent Pinchartd2a31bd2012-12-15 23:51:39 +0100634#ifdef CONFIG_PINCTRL_PFC_SH7786
635 { "pfc-sh7786", (kernel_ulong_t)&sh7786_pinmux_info },
636#endif
Laurent Pinchartd5d9a812012-12-15 23:51:40 +0100637#ifdef CONFIG_PINCTRL_PFC_SHX3
638 { "pfc-shx3", (kernel_ulong_t)&shx3_pinmux_info },
639#endif
Laurent Pinchartc6193ea2012-12-15 23:50:47 +0100640 { "sh-pfc", 0 },
641 { },
642};
643MODULE_DEVICE_TABLE(platform, sh_pfc_id_table);
644
645static struct platform_driver sh_pfc_driver = {
646 .probe = sh_pfc_probe,
647 .remove = sh_pfc_remove,
648 .id_table = sh_pfc_id_table,
649 .driver = {
650 .name = DRV_NAME,
Laurent Pinchartfe1c9a82013-06-17 20:50:02 +0200651 .of_match_table = of_match_ptr(sh_pfc_of_table),
Laurent Pinchartc6193ea2012-12-15 23:50:47 +0100652 },
653};
654
Laurent Pinchart40ee6fc2012-12-15 23:50:54 +0100655static int __init sh_pfc_init(void)
656{
657 return platform_driver_register(&sh_pfc_driver);
658}
659postcore_initcall(sh_pfc_init);
660
Laurent Pinchartc6193ea2012-12-15 23:50:47 +0100661static void __exit sh_pfc_exit(void)
662{
663 platform_driver_unregister(&sh_pfc_driver);
664}
665module_exit(sh_pfc_exit);
666
Laurent Pinchart6f6a4a62012-12-15 23:50:46 +0100667MODULE_AUTHOR("Magnus Damm, Paul Mundt, Laurent Pinchart");
668MODULE_DESCRIPTION("Pin Control and GPIO driver for SuperH pin function controller");
669MODULE_LICENSE("GPL v2");