Merge tag 'acpi-extra-4.12-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git...
[muen/linux.git] / drivers / i2c / busses / i2c-designware-platdrv.c
1 /*
2  * Synopsys DesignWare I2C adapter driver (master only).
3  *
4  * Based on the TI DAVINCI I2C adapter driver.
5  *
6  * Copyright (C) 2006 Texas Instruments.
7  * Copyright (C) 2007 MontaVista Software Inc.
8  * Copyright (C) 2009 Provigent Ltd.
9  *
10  * ----------------------------------------------------------------------------
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation; either version 2 of the License, or
15  * (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  * ----------------------------------------------------------------------------
22  *
23  */
24 #include <linux/kernel.h>
25 #include <linux/module.h>
26 #include <linux/delay.h>
27 #include <linux/dmi.h>
28 #include <linux/i2c.h>
29 #include <linux/clk.h>
30 #include <linux/clk-provider.h>
31 #include <linux/errno.h>
32 #include <linux/sched.h>
33 #include <linux/err.h>
34 #include <linux/interrupt.h>
35 #include <linux/of.h>
36 #include <linux/platform_device.h>
37 #include <linux/pm.h>
38 #include <linux/pm_runtime.h>
39 #include <linux/property.h>
40 #include <linux/io.h>
41 #include <linux/reset.h>
42 #include <linux/slab.h>
43 #include <linux/acpi.h>
44 #include <linux/platform_data/i2c-designware.h>
45 #include "i2c-designware-core.h"
46
47 static u32 i2c_dw_get_clk_rate_khz(struct dw_i2c_dev *dev)
48 {
49         return clk_get_rate(dev->clk)/1000;
50 }
51
52 #ifdef CONFIG_ACPI
53 /*
54  * The HCNT/LCNT information coming from ACPI should be the most accurate
55  * for given platform. However, some systems get it wrong. On such systems
56  * we get better results by calculating those based on the input clock.
57  */
58 static const struct dmi_system_id dw_i2c_no_acpi_params[] = {
59         {
60                 .ident = "Dell Inspiron 7348",
61                 .matches = {
62                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
63                         DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 7348"),
64                 },
65         },
66         { }
67 };
68
69 static void dw_i2c_acpi_params(struct platform_device *pdev, char method[],
70                                u16 *hcnt, u16 *lcnt, u32 *sda_hold)
71 {
72         struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER };
73         acpi_handle handle = ACPI_HANDLE(&pdev->dev);
74         union acpi_object *obj;
75
76         if (dmi_check_system(dw_i2c_no_acpi_params))
77                 return;
78
79         if (ACPI_FAILURE(acpi_evaluate_object(handle, method, NULL, &buf)))
80                 return;
81
82         obj = (union acpi_object *)buf.pointer;
83         if (obj->type == ACPI_TYPE_PACKAGE && obj->package.count == 3) {
84                 const union acpi_object *objs = obj->package.elements;
85
86                 *hcnt = (u16)objs[0].integer.value;
87                 *lcnt = (u16)objs[1].integer.value;
88                 *sda_hold = (u32)objs[2].integer.value;
89         }
90
91         kfree(buf.pointer);
92 }
93
94 static int dw_i2c_acpi_configure(struct platform_device *pdev)
95 {
96         struct dw_i2c_dev *dev = platform_get_drvdata(pdev);
97         acpi_handle handle = ACPI_HANDLE(&pdev->dev);
98         const struct acpi_device_id *id;
99         struct acpi_device *adev;
100         const char *uid;
101
102         dev->adapter.nr = -1;
103         dev->tx_fifo_depth = 32;
104         dev->rx_fifo_depth = 32;
105
106         /*
107          * Try to get SDA hold time and *CNT values from an ACPI method for
108          * selected speed modes.
109          */
110         switch (dev->clk_freq) {
111         case 100000:
112                 dw_i2c_acpi_params(pdev, "SSCN", &dev->ss_hcnt, &dev->ss_lcnt,
113                                    &dev->sda_hold_time);
114                 break;
115         case 1000000:
116                 dw_i2c_acpi_params(pdev, "FPCN", &dev->fp_hcnt, &dev->fp_lcnt,
117                                    &dev->sda_hold_time);
118                 break;
119         case 3400000:
120                 dw_i2c_acpi_params(pdev, "HSCN", &dev->hs_hcnt, &dev->hs_lcnt,
121                                    &dev->sda_hold_time);
122                 break;
123         case 400000:
124         default:
125                 dw_i2c_acpi_params(pdev, "FMCN", &dev->fs_hcnt, &dev->fs_lcnt,
126                                    &dev->sda_hold_time);
127                 break;
128         }
129
130         id = acpi_match_device(pdev->dev.driver->acpi_match_table, &pdev->dev);
131         if (id && id->driver_data)
132                 dev->flags |= (u32)id->driver_data;
133
134         if (acpi_bus_get_device(handle, &adev))
135                 return -ENODEV;
136
137         /*
138          * Cherrytrail I2C7 gets used for the PMIC which gets accessed
139          * through ACPI opregions during late suspend / early resume
140          * disable pm for it.
141          */
142         uid = adev->pnp.unique_id;
143         if ((dev->flags & MODEL_CHERRYTRAIL) && !strcmp(uid, "7"))
144                 dev->pm_disabled = true;
145
146         return 0;
147 }
148
149 static const struct acpi_device_id dw_i2c_acpi_match[] = {
150         { "INT33C2", 0 },
151         { "INT33C3", 0 },
152         { "INT3432", 0 },
153         { "INT3433", 0 },
154         { "80860F41", 0 },
155         { "808622C1", MODEL_CHERRYTRAIL },
156         { "AMD0010", ACCESS_INTR_MASK },
157         { "AMDI0010", ACCESS_INTR_MASK },
158         { "AMDI0510", 0 },
159         { "APMC0D0F", 0 },
160         { "HISI02A1", 0 },
161         { "HISI02A2", 0 },
162         { }
163 };
164 MODULE_DEVICE_TABLE(acpi, dw_i2c_acpi_match);
165 #else
166 static inline int dw_i2c_acpi_configure(struct platform_device *pdev)
167 {
168         return -ENODEV;
169 }
170 #endif
171
172 static int i2c_dw_plat_prepare_clk(struct dw_i2c_dev *i_dev, bool prepare)
173 {
174         if (IS_ERR(i_dev->clk))
175                 return PTR_ERR(i_dev->clk);
176
177         if (prepare)
178                 return clk_prepare_enable(i_dev->clk);
179
180         clk_disable_unprepare(i_dev->clk);
181         return 0;
182 }
183
184 static void dw_i2c_set_fifo_size(struct dw_i2c_dev *dev, int id)
185 {
186         u32 param, tx_fifo_depth, rx_fifo_depth;
187
188         /*
189          * Try to detect the FIFO depth if not set by interface driver,
190          * the depth could be from 2 to 256 from HW spec.
191          */
192         param = i2c_dw_read_comp_param(dev);
193         tx_fifo_depth = ((param >> 16) & 0xff) + 1;
194         rx_fifo_depth = ((param >> 8)  & 0xff) + 1;
195         if (!dev->tx_fifo_depth) {
196                 dev->tx_fifo_depth = tx_fifo_depth;
197                 dev->rx_fifo_depth = rx_fifo_depth;
198                 dev->adapter.nr = id;
199         } else if (tx_fifo_depth >= 2) {
200                 dev->tx_fifo_depth = min_t(u32, dev->tx_fifo_depth,
201                                 tx_fifo_depth);
202                 dev->rx_fifo_depth = min_t(u32, dev->rx_fifo_depth,
203                                 rx_fifo_depth);
204         }
205 }
206
207 static int dw_i2c_plat_probe(struct platform_device *pdev)
208 {
209         struct dw_i2c_platform_data *pdata = dev_get_platdata(&pdev->dev);
210         struct dw_i2c_dev *dev;
211         struct i2c_adapter *adap;
212         struct resource *mem;
213         int irq, r;
214         u32 acpi_speed, ht = 0;
215
216         irq = platform_get_irq(pdev, 0);
217         if (irq < 0)
218                 return irq;
219
220         dev = devm_kzalloc(&pdev->dev, sizeof(struct dw_i2c_dev), GFP_KERNEL);
221         if (!dev)
222                 return -ENOMEM;
223
224         mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
225         dev->base = devm_ioremap_resource(&pdev->dev, mem);
226         if (IS_ERR(dev->base))
227                 return PTR_ERR(dev->base);
228
229         dev->dev = &pdev->dev;
230         dev->irq = irq;
231         platform_set_drvdata(pdev, dev);
232
233         dev->rst = devm_reset_control_get_optional_exclusive(&pdev->dev, NULL);
234         if (IS_ERR(dev->rst)) {
235                 if (PTR_ERR(dev->rst) == -EPROBE_DEFER)
236                         return -EPROBE_DEFER;
237         } else {
238                 reset_control_deassert(dev->rst);
239         }
240
241         if (pdata) {
242                 dev->clk_freq = pdata->i2c_scl_freq;
243         } else {
244                 device_property_read_u32(&pdev->dev, "i2c-sda-hold-time-ns",
245                                          &ht);
246                 device_property_read_u32(&pdev->dev, "i2c-sda-falling-time-ns",
247                                          &dev->sda_falling_time);
248                 device_property_read_u32(&pdev->dev, "i2c-scl-falling-time-ns",
249                                          &dev->scl_falling_time);
250                 device_property_read_u32(&pdev->dev, "clock-frequency",
251                                          &dev->clk_freq);
252         }
253
254         acpi_speed = i2c_acpi_find_bus_speed(&pdev->dev);
255         /*
256          * Find bus speed from the "clock-frequency" device property, ACPI
257          * or by using fast mode if neither is set.
258          */
259         if (acpi_speed && dev->clk_freq)
260                 dev->clk_freq = min(dev->clk_freq, acpi_speed);
261         else if (acpi_speed || dev->clk_freq)
262                 dev->clk_freq = max(dev->clk_freq, acpi_speed);
263         else
264                 dev->clk_freq = 400000;
265
266         if (has_acpi_companion(&pdev->dev))
267                 dw_i2c_acpi_configure(pdev);
268
269         /*
270          * Only standard mode at 100kHz, fast mode at 400kHz,
271          * fast mode plus at 1MHz and high speed mode at 3.4MHz are supported.
272          */
273         if (dev->clk_freq != 100000 && dev->clk_freq != 400000
274             && dev->clk_freq != 1000000 && dev->clk_freq != 3400000) {
275                 dev_err(&pdev->dev,
276                         "Only 100kHz, 400kHz, 1MHz and 3.4MHz supported");
277                 r = -EINVAL;
278                 goto exit_reset;
279         }
280
281         r = i2c_dw_probe_lock_support(dev);
282         if (r)
283                 goto exit_reset;
284
285         dev->functionality = I2C_FUNC_10BIT_ADDR | DW_IC_DEFAULT_FUNCTIONALITY;
286
287         dev->master_cfg = DW_IC_CON_MASTER | DW_IC_CON_SLAVE_DISABLE |
288                           DW_IC_CON_RESTART_EN;
289
290         switch (dev->clk_freq) {
291         case 100000:
292                 dev->master_cfg |= DW_IC_CON_SPEED_STD;
293                 break;
294         case 3400000:
295                 dev->master_cfg |= DW_IC_CON_SPEED_HIGH;
296                 break;
297         default:
298                 dev->master_cfg |= DW_IC_CON_SPEED_FAST;
299         }
300
301         dev->clk = devm_clk_get(&pdev->dev, NULL);
302         if (!i2c_dw_plat_prepare_clk(dev, true)) {
303                 dev->get_clk_rate_khz = i2c_dw_get_clk_rate_khz;
304
305                 if (!dev->sda_hold_time && ht)
306                         dev->sda_hold_time = div_u64(
307                                 (u64)dev->get_clk_rate_khz(dev) * ht + 500000,
308                                 1000000);
309         }
310
311         dw_i2c_set_fifo_size(dev, pdev->id);
312
313         adap = &dev->adapter;
314         adap->owner = THIS_MODULE;
315         adap->class = I2C_CLASS_DEPRECATED;
316         ACPI_COMPANION_SET(&adap->dev, ACPI_COMPANION(&pdev->dev));
317         adap->dev.of_node = pdev->dev.of_node;
318
319         if (dev->pm_disabled) {
320                 pm_runtime_forbid(&pdev->dev);
321         } else {
322                 pm_runtime_set_autosuspend_delay(&pdev->dev, 1000);
323                 pm_runtime_use_autosuspend(&pdev->dev);
324                 pm_runtime_set_active(&pdev->dev);
325                 pm_runtime_enable(&pdev->dev);
326         }
327
328         r = i2c_dw_probe(dev);
329         if (r)
330                 goto exit_probe;
331
332         return r;
333
334 exit_probe:
335         if (!dev->pm_disabled)
336                 pm_runtime_disable(&pdev->dev);
337 exit_reset:
338         if (!IS_ERR_OR_NULL(dev->rst))
339                 reset_control_assert(dev->rst);
340         return r;
341 }
342
343 static int dw_i2c_plat_remove(struct platform_device *pdev)
344 {
345         struct dw_i2c_dev *dev = platform_get_drvdata(pdev);
346
347         pm_runtime_get_sync(&pdev->dev);
348
349         i2c_del_adapter(&dev->adapter);
350
351         i2c_dw_disable(dev);
352
353         pm_runtime_dont_use_autosuspend(&pdev->dev);
354         pm_runtime_put_sync(&pdev->dev);
355         if (!dev->pm_disabled)
356                 pm_runtime_disable(&pdev->dev);
357         if (!IS_ERR_OR_NULL(dev->rst))
358                 reset_control_assert(dev->rst);
359
360         i2c_dw_remove_lock_support(dev);
361
362         return 0;
363 }
364
365 #ifdef CONFIG_OF
366 static const struct of_device_id dw_i2c_of_match[] = {
367         { .compatible = "snps,designware-i2c", },
368         {},
369 };
370 MODULE_DEVICE_TABLE(of, dw_i2c_of_match);
371 #endif
372
373 #ifdef CONFIG_PM_SLEEP
374 static int dw_i2c_plat_prepare(struct device *dev)
375 {
376         return pm_runtime_suspended(dev);
377 }
378
379 static void dw_i2c_plat_complete(struct device *dev)
380 {
381         if (dev->power.direct_complete)
382                 pm_request_resume(dev);
383 }
384 #else
385 #define dw_i2c_plat_prepare     NULL
386 #define dw_i2c_plat_complete    NULL
387 #endif
388
389 #ifdef CONFIG_PM
390 static int dw_i2c_plat_suspend(struct device *dev)
391 {
392         struct platform_device *pdev = to_platform_device(dev);
393         struct dw_i2c_dev *i_dev = platform_get_drvdata(pdev);
394
395         i2c_dw_disable(i_dev);
396         i2c_dw_plat_prepare_clk(i_dev, false);
397
398         return 0;
399 }
400
401 static int dw_i2c_plat_resume(struct device *dev)
402 {
403         struct platform_device *pdev = to_platform_device(dev);
404         struct dw_i2c_dev *i_dev = platform_get_drvdata(pdev);
405
406         i2c_dw_plat_prepare_clk(i_dev, true);
407         i2c_dw_init(i_dev);
408
409         return 0;
410 }
411
412 static const struct dev_pm_ops dw_i2c_dev_pm_ops = {
413         .prepare = dw_i2c_plat_prepare,
414         .complete = dw_i2c_plat_complete,
415         SET_SYSTEM_SLEEP_PM_OPS(dw_i2c_plat_suspend, dw_i2c_plat_resume)
416         SET_RUNTIME_PM_OPS(dw_i2c_plat_suspend, dw_i2c_plat_resume, NULL)
417 };
418
419 #define DW_I2C_DEV_PMOPS (&dw_i2c_dev_pm_ops)
420 #else
421 #define DW_I2C_DEV_PMOPS NULL
422 #endif
423
424 /* work with hotplug and coldplug */
425 MODULE_ALIAS("platform:i2c_designware");
426
427 static struct platform_driver dw_i2c_driver = {
428         .probe = dw_i2c_plat_probe,
429         .remove = dw_i2c_plat_remove,
430         .driver         = {
431                 .name   = "i2c_designware",
432                 .of_match_table = of_match_ptr(dw_i2c_of_match),
433                 .acpi_match_table = ACPI_PTR(dw_i2c_acpi_match),
434                 .pm     = DW_I2C_DEV_PMOPS,
435         },
436 };
437
438 static int __init dw_i2c_init_driver(void)
439 {
440         return platform_driver_register(&dw_i2c_driver);
441 }
442 subsys_initcall(dw_i2c_init_driver);
443
444 static void __exit dw_i2c_exit_driver(void)
445 {
446         platform_driver_unregister(&dw_i2c_driver);
447 }
448 module_exit(dw_i2c_exit_driver);
449
450 MODULE_AUTHOR("Baruch Siach <baruch@tkos.co.il>");
451 MODULE_DESCRIPTION("Synopsys DesignWare I2C bus adapter");
452 MODULE_LICENSE("GPL");