Merge tag 'ti-k3-soc-for-v5.3' of git://git.kernel.org/pub/scm/linux/kernel/git/krist...
[linux-2.6-microblaze.git] / drivers / ata / pata_ftide010.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Faraday Technology FTIDE010 driver
4  * Copyright (C) 2017 Linus Walleij <linus.walleij@linaro.org>
5  *
6  * Includes portions of the SL2312/SL3516/Gemini PATA driver
7  * Copyright (C) 2003 StorLine, Inc <jason@storlink.com.tw>
8  * Copyright (C) 2009 Janos Laube <janos.dev@gmail.com>
9  * Copyright (C) 2010 Frederic Pecourt <opengemini@free.fr>
10  * Copyright (C) 2011 Tobias Waldvogel <tobias.waldvogel@gmail.com>
11  */
12
13 #include <linux/platform_device.h>
14 #include <linux/module.h>
15 #include <linux/libata.h>
16 #include <linux/bitops.h>
17 #include <linux/of_address.h>
18 #include <linux/of_device.h>
19 #include <linux/clk.h>
20 #include "sata_gemini.h"
21
22 #define DRV_NAME "pata_ftide010"
23
24 /**
25  * struct ftide010 - state container for the Faraday FTIDE010
26  * @dev: pointer back to the device representing this controller
27  * @base: remapped I/O space address
28  * @pclk: peripheral clock for the IDE block
29  * @host: pointer to the ATA host for this device
30  * @master_cbl: master cable type
31  * @slave_cbl: slave cable type
32  * @sg: Gemini SATA bridge pointer, if running on the Gemini
33  * @master_to_sata0: Gemini SATA bridge: the ATA master is connected
34  * to the SATA0 bridge
35  * @slave_to_sata0: Gemini SATA bridge: the ATA slave is connected
36  * to the SATA0 bridge
37  * @master_to_sata1: Gemini SATA bridge: the ATA master is connected
38  * to the SATA1 bridge
39  * @slave_to_sata1: Gemini SATA bridge: the ATA slave is connected
40  * to the SATA1 bridge
41  */
42 struct ftide010 {
43         struct device *dev;
44         void __iomem *base;
45         struct clk *pclk;
46         struct ata_host *host;
47         unsigned int master_cbl;
48         unsigned int slave_cbl;
49         /* Gemini-specific properties */
50         struct sata_gemini *sg;
51         bool master_to_sata0;
52         bool slave_to_sata0;
53         bool master_to_sata1;
54         bool slave_to_sata1;
55 };
56
57 #define FTIDE010_DMA_REG        0x00
58 #define FTIDE010_DMA_STATUS     0x02
59 #define FTIDE010_IDE_BMDTPR     0x04
60 #define FTIDE010_IDE_DEVICE_ID  0x08
61 #define FTIDE010_PIO_TIMING     0x10
62 #define FTIDE010_MWDMA_TIMING   0x11
63 #define FTIDE010_UDMA_TIMING0   0x12 /* Master */
64 #define FTIDE010_UDMA_TIMING1   0x13 /* Slave */
65 #define FTIDE010_CLK_MOD        0x14
66 /* These registers are mapped directly to the IDE registers */
67 #define FTIDE010_CMD_DATA       0x20
68 #define FTIDE010_ERROR_FEATURES 0x21
69 #define FTIDE010_NSECT          0x22
70 #define FTIDE010_LBAL           0x23
71 #define FTIDE010_LBAM           0x24
72 #define FTIDE010_LBAH           0x25
73 #define FTIDE010_DEVICE         0x26
74 #define FTIDE010_STATUS_COMMAND 0x27
75 #define FTIDE010_ALTSTAT_CTRL   0x36
76
77 /* Set this bit for UDMA mode 5 and 6 */
78 #define FTIDE010_UDMA_TIMING_MODE_56    BIT(7)
79
80 /* 0 = 50 MHz, 1 = 66 MHz */
81 #define FTIDE010_CLK_MOD_DEV0_CLK_SEL   BIT(0)
82 #define FTIDE010_CLK_MOD_DEV1_CLK_SEL   BIT(1)
83 /* Enable UDMA on a device */
84 #define FTIDE010_CLK_MOD_DEV0_UDMA_EN   BIT(4)
85 #define FTIDE010_CLK_MOD_DEV1_UDMA_EN   BIT(5)
86
87 static struct scsi_host_template pata_ftide010_sht = {
88         ATA_BMDMA_SHT(DRV_NAME),
89 };
90
91 /*
92  * Bus timings
93  *
94  * The unit of the below required timings is two clock periods of the ATA
95  * reference clock which is 30 nanoseconds per unit at 66MHz and 20
96  * nanoseconds per unit at 50 MHz. The PIO timings assume 33MHz speed for
97  * PIO.
98  *
99  * pio_active_time: array of 5 elements for T2 timing for Mode 0,
100  * 1, 2, 3 and 4. Range 0..15.
101  * pio_recovery_time: array of 5 elements for T2l timing for Mode 0,
102  * 1, 2, 3 and 4. Range 0..15.
103  * mdma_50_active_time: array of 4 elements for Td timing for multi
104  * word DMA, Mode 0, 1, and 2 at 50 MHz. Range 0..15.
105  * mdma_50_recovery_time: array of 4 elements for Tk timing for
106  * multi word DMA, Mode 0, 1 and 2 at 50 MHz. Range 0..15.
107  * mdma_66_active_time: array of 4 elements for Td timing for multi
108  * word DMA, Mode 0, 1 and 2 at 66 MHz. Range 0..15.
109  * mdma_66_recovery_time: array of 4 elements for Tk timing for
110  * multi word DMA, Mode 0, 1 and 2 at 66 MHz. Range 0..15.
111  * udma_50_setup_time: array of 4 elements for Tvds timing for ultra
112  * DMA, Mode 0, 1, 2, 3, 4 and 5 at 50 MHz. Range 0..7.
113  * udma_50_hold_time: array of 4 elements for Tdvh timing for
114  * multi word DMA, Mode 0, 1, 2, 3, 4 and 5 at 50 MHz, Range 0..7.
115  * udma_66_setup_time: array of 4 elements for Tvds timing for multi
116  * word DMA, Mode 0, 1, 2, 3, 4, 5 and 6 at 66 MHz. Range 0..7.
117  * udma_66_hold_time: array of 4 elements for Tdvh timing for
118  * multi word DMA, Mode 0, 1, 2, 3, 4, 5 and 6 at 66 MHz. Range 0..7.
119  */
120 static const u8 pio_active_time[5] = {10, 10, 10, 3, 3};
121 static const u8 pio_recovery_time[5] = {10, 3, 1, 3, 1};
122 static const u8 mwdma_50_active_time[3] = {6, 2, 2};
123 static const u8 mwdma_50_recovery_time[3] = {6, 2, 1};
124 static const u8 mwdma_66_active_time[3] = {8, 3, 3};
125 static const u8 mwdma_66_recovery_time[3] = {8, 2, 1};
126 static const u8 udma_50_setup_time[6] = {3, 3, 2, 2, 1, 1};
127 static const u8 udma_50_hold_time[6] = {3, 1, 1, 1, 1, 1};
128 static const u8 udma_66_setup_time[7] = {4, 4, 3, 2, };
129 static const u8 udma_66_hold_time[7] = {};
130
131 /*
132  * We set 66 MHz for all MWDMA modes
133  */
134 static const bool set_mdma_66_mhz[] = { true, true, true, true };
135
136 /*
137  * We set 66 MHz for UDMA modes 3, 4 and 6 and no others
138  */
139 static const bool set_udma_66_mhz[] = { false, false, false, true, true, false, true };
140
141 static void ftide010_set_dmamode(struct ata_port *ap, struct ata_device *adev)
142 {
143         struct ftide010 *ftide = ap->host->private_data;
144         u8 speed = adev->dma_mode;
145         u8 devno = adev->devno & 1;
146         u8 udma_en_mask;
147         u8 f66m_en_mask;
148         u8 clkreg;
149         u8 timreg;
150         u8 i;
151
152         /* Target device 0 (master) or 1 (slave) */
153         if (!devno) {
154                 udma_en_mask = FTIDE010_CLK_MOD_DEV0_UDMA_EN;
155                 f66m_en_mask = FTIDE010_CLK_MOD_DEV0_CLK_SEL;
156         } else {
157                 udma_en_mask = FTIDE010_CLK_MOD_DEV1_UDMA_EN;
158                 f66m_en_mask = FTIDE010_CLK_MOD_DEV1_CLK_SEL;
159         }
160
161         clkreg = readb(ftide->base + FTIDE010_CLK_MOD);
162         clkreg &= ~udma_en_mask;
163         clkreg &= ~f66m_en_mask;
164
165         if (speed & XFER_UDMA_0) {
166                 i = speed & ~XFER_UDMA_0;
167                 dev_dbg(ftide->dev, "set UDMA mode %02x, index %d\n",
168                         speed, i);
169
170                 clkreg |= udma_en_mask;
171                 if (set_udma_66_mhz[i]) {
172                         clkreg |= f66m_en_mask;
173                         timreg = udma_66_setup_time[i] << 4 |
174                                 udma_66_hold_time[i];
175                 } else {
176                         timreg = udma_50_setup_time[i] << 4 |
177                                 udma_50_hold_time[i];
178                 }
179
180                 /* A special bit needs to be set for modes 5 and 6 */
181                 if (i >= 5)
182                         timreg |= FTIDE010_UDMA_TIMING_MODE_56;
183
184                 dev_dbg(ftide->dev, "UDMA write clkreg = %02x, timreg = %02x\n",
185                         clkreg, timreg);
186
187                 writeb(clkreg, ftide->base + FTIDE010_CLK_MOD);
188                 writeb(timreg, ftide->base + FTIDE010_UDMA_TIMING0 + devno);
189         } else {
190                 i = speed & ~XFER_MW_DMA_0;
191                 dev_dbg(ftide->dev, "set MWDMA mode %02x, index %d\n",
192                         speed, i);
193
194                 if (set_mdma_66_mhz[i]) {
195                         clkreg |= f66m_en_mask;
196                         timreg = mwdma_66_active_time[i] << 4 |
197                                 mwdma_66_recovery_time[i];
198                 } else {
199                         timreg = mwdma_50_active_time[i] << 4 |
200                                 mwdma_50_recovery_time[i];
201                 }
202                 dev_dbg(ftide->dev,
203                         "MWDMA write clkreg = %02x, timreg = %02x\n",
204                         clkreg, timreg);
205                 /* This will affect all devices */
206                 writeb(clkreg, ftide->base + FTIDE010_CLK_MOD);
207                 writeb(timreg, ftide->base + FTIDE010_MWDMA_TIMING);
208         }
209
210         /*
211          * Store the current device (master or slave) in ap->private_data
212          * so that .qc_issue() can detect if this changes and reprogram
213          * the DMA settings.
214          */
215         ap->private_data = adev;
216
217         return;
218 }
219
220 static void ftide010_set_piomode(struct ata_port *ap, struct ata_device *adev)
221 {
222         struct ftide010 *ftide = ap->host->private_data;
223         u8 pio = adev->pio_mode - XFER_PIO_0;
224
225         dev_dbg(ftide->dev, "set PIO mode %02x, index %d\n",
226                 adev->pio_mode, pio);
227         writeb(pio_active_time[pio] << 4 | pio_recovery_time[pio],
228                ftide->base + FTIDE010_PIO_TIMING);
229 }
230
231 /*
232  * We implement our own qc_issue() callback since we may need to set up
233  * the timings differently for master and slave transfers: the CLK_MOD_REG
234  * and MWDMA_TIMING_REG is shared between master and slave, so reprogramming
235  * this may be necessary.
236  */
237 static unsigned int ftide010_qc_issue(struct ata_queued_cmd *qc)
238 {
239         struct ata_port *ap = qc->ap;
240         struct ata_device *adev = qc->dev;
241
242         /*
243          * If the device changed, i.e. slave->master, master->slave,
244          * then set up the DMA mode again so we are sure the timings
245          * are correct.
246          */
247         if (adev != ap->private_data && ata_dma_enabled(adev))
248                 ftide010_set_dmamode(ap, adev);
249
250         return ata_bmdma_qc_issue(qc);
251 }
252
253 static struct ata_port_operations pata_ftide010_port_ops = {
254         .inherits       = &ata_bmdma_port_ops,
255         .set_dmamode    = ftide010_set_dmamode,
256         .set_piomode    = ftide010_set_piomode,
257         .qc_issue       = ftide010_qc_issue,
258 };
259
260 static struct ata_port_info ftide010_port_info = {
261         .flags          = ATA_FLAG_SLAVE_POSS,
262         .mwdma_mask     = ATA_MWDMA2,
263         .udma_mask      = ATA_UDMA6,
264         .pio_mask       = ATA_PIO4,
265         .port_ops       = &pata_ftide010_port_ops,
266 };
267
268 #if IS_ENABLED(CONFIG_SATA_GEMINI)
269
270 static int pata_ftide010_gemini_port_start(struct ata_port *ap)
271 {
272         struct ftide010 *ftide = ap->host->private_data;
273         struct device *dev = ftide->dev;
274         struct sata_gemini *sg = ftide->sg;
275         int bridges = 0;
276         int ret;
277
278         ret = ata_bmdma_port_start(ap);
279         if (ret)
280                 return ret;
281
282         if (ftide->master_to_sata0) {
283                 dev_info(dev, "SATA0 (master) start\n");
284                 ret = gemini_sata_start_bridge(sg, 0);
285                 if (!ret)
286                         bridges++;
287         }
288         if (ftide->master_to_sata1) {
289                 dev_info(dev, "SATA1 (master) start\n");
290                 ret = gemini_sata_start_bridge(sg, 1);
291                 if (!ret)
292                         bridges++;
293         }
294         /* Avoid double-starting */
295         if (ftide->slave_to_sata0 && !ftide->master_to_sata0) {
296                 dev_info(dev, "SATA0 (slave) start\n");
297                 ret = gemini_sata_start_bridge(sg, 0);
298                 if (!ret)
299                         bridges++;
300         }
301         /* Avoid double-starting */
302         if (ftide->slave_to_sata1 && !ftide->master_to_sata1) {
303                 dev_info(dev, "SATA1 (slave) start\n");
304                 ret = gemini_sata_start_bridge(sg, 1);
305                 if (!ret)
306                         bridges++;
307         }
308
309         dev_info(dev, "brought %d bridges online\n", bridges);
310         return (bridges > 0) ? 0 : -EINVAL; // -ENODEV;
311 }
312
313 static void pata_ftide010_gemini_port_stop(struct ata_port *ap)
314 {
315         struct ftide010 *ftide = ap->host->private_data;
316         struct device *dev = ftide->dev;
317         struct sata_gemini *sg = ftide->sg;
318
319         if (ftide->master_to_sata0) {
320                 dev_info(dev, "SATA0 (master) stop\n");
321                 gemini_sata_stop_bridge(sg, 0);
322         }
323         if (ftide->master_to_sata1) {
324                 dev_info(dev, "SATA1 (master) stop\n");
325                 gemini_sata_stop_bridge(sg, 1);
326         }
327         /* Avoid double-stopping */
328         if (ftide->slave_to_sata0 && !ftide->master_to_sata0) {
329                 dev_info(dev, "SATA0 (slave) stop\n");
330                 gemini_sata_stop_bridge(sg, 0);
331         }
332         /* Avoid double-stopping */
333         if (ftide->slave_to_sata1 && !ftide->master_to_sata1) {
334                 dev_info(dev, "SATA1 (slave) stop\n");
335                 gemini_sata_stop_bridge(sg, 1);
336         }
337 }
338
339 static int pata_ftide010_gemini_cable_detect(struct ata_port *ap)
340 {
341         struct ftide010 *ftide = ap->host->private_data;
342
343         /*
344          * Return the master cable, I have no clue how to return a different
345          * cable for the slave than for the master.
346          */
347         return ftide->master_cbl;
348 }
349
350 static int pata_ftide010_gemini_init(struct ftide010 *ftide,
351                                      struct ata_port_info *pi,
352                                      bool is_ata1)
353 {
354         struct device *dev = ftide->dev;
355         struct sata_gemini *sg;
356         enum gemini_muxmode muxmode;
357
358         /* Look up SATA bridge */
359         sg = gemini_sata_bridge_get();
360         if (IS_ERR(sg))
361                 return PTR_ERR(sg);
362         ftide->sg = sg;
363
364         muxmode = gemini_sata_get_muxmode(sg);
365
366         /* Special ops */
367         pata_ftide010_port_ops.port_start =
368                 pata_ftide010_gemini_port_start;
369         pata_ftide010_port_ops.port_stop =
370                 pata_ftide010_gemini_port_stop;
371         pata_ftide010_port_ops.cable_detect =
372                 pata_ftide010_gemini_cable_detect;
373
374         /* Flag port as SATA-capable */
375         if (gemini_sata_bridge_enabled(sg, is_ata1))
376                 pi->flags |= ATA_FLAG_SATA;
377
378         /* This device has broken DMA, only PIO works */
379         if (of_machine_is_compatible("itian,sq201")) {
380                 pi->mwdma_mask = 0;
381                 pi->udma_mask = 0;
382         }
383
384         /*
385          * We assume that a simple 40-wire cable is used in the PATA mode.
386          * if you're adding a system using the PATA interface, make sure
387          * the right cable is set up here, it might be necessary to use
388          * special hardware detection or encode the cable type in the device
389          * tree with special properties.
390          */
391         if (!is_ata1) {
392                 switch (muxmode) {
393                 case GEMINI_MUXMODE_0:
394                         ftide->master_cbl = ATA_CBL_SATA;
395                         ftide->slave_cbl = ATA_CBL_PATA40;
396                         ftide->master_to_sata0 = true;
397                         break;
398                 case GEMINI_MUXMODE_1:
399                         ftide->master_cbl = ATA_CBL_SATA;
400                         ftide->slave_cbl = ATA_CBL_NONE;
401                         ftide->master_to_sata0 = true;
402                         break;
403                 case GEMINI_MUXMODE_2:
404                         ftide->master_cbl = ATA_CBL_PATA40;
405                         ftide->slave_cbl = ATA_CBL_PATA40;
406                         break;
407                 case GEMINI_MUXMODE_3:
408                         ftide->master_cbl = ATA_CBL_SATA;
409                         ftide->slave_cbl = ATA_CBL_SATA;
410                         ftide->master_to_sata0 = true;
411                         ftide->slave_to_sata1 = true;
412                         break;
413                 }
414         } else {
415                 switch (muxmode) {
416                 case GEMINI_MUXMODE_0:
417                         ftide->master_cbl = ATA_CBL_SATA;
418                         ftide->slave_cbl = ATA_CBL_NONE;
419                         ftide->master_to_sata1 = true;
420                         break;
421                 case GEMINI_MUXMODE_1:
422                         ftide->master_cbl = ATA_CBL_SATA;
423                         ftide->slave_cbl = ATA_CBL_PATA40;
424                         ftide->master_to_sata1 = true;
425                         break;
426                 case GEMINI_MUXMODE_2:
427                         ftide->master_cbl = ATA_CBL_SATA;
428                         ftide->slave_cbl = ATA_CBL_SATA;
429                         ftide->slave_to_sata0 = true;
430                         ftide->master_to_sata1 = true;
431                         break;
432                 case GEMINI_MUXMODE_3:
433                         ftide->master_cbl = ATA_CBL_PATA40;
434                         ftide->slave_cbl = ATA_CBL_PATA40;
435                         break;
436                 }
437         }
438         dev_info(dev, "set up Gemini PATA%d\n", is_ata1);
439
440         return 0;
441 }
442 #else
443 static int pata_ftide010_gemini_init(struct ftide010 *ftide,
444                                      struct ata_port_info *pi,
445                                      bool is_ata1)
446 {
447         return -ENOTSUPP;
448 }
449 #endif
450
451
452 static int pata_ftide010_probe(struct platform_device *pdev)
453 {
454         struct device *dev = &pdev->dev;
455         struct device_node *np = dev->of_node;
456         struct ata_port_info pi = ftide010_port_info;
457         const struct ata_port_info *ppi[] = { &pi, NULL };
458         struct ftide010 *ftide;
459         struct resource *res;
460         int irq;
461         int ret;
462         int i;
463
464         ftide = devm_kzalloc(dev, sizeof(*ftide), GFP_KERNEL);
465         if (!ftide)
466                 return -ENOMEM;
467         ftide->dev = dev;
468
469         irq = platform_get_irq(pdev, 0);
470         if (irq < 0)
471                 return irq;
472
473         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
474         if (!res)
475                 return -ENODEV;
476
477         ftide->base = devm_ioremap_resource(dev, res);
478         if (IS_ERR(ftide->base))
479                 return PTR_ERR(ftide->base);
480
481         ftide->pclk = devm_clk_get(dev, "PCLK");
482         if (!IS_ERR(ftide->pclk)) {
483                 ret = clk_prepare_enable(ftide->pclk);
484                 if (ret) {
485                         dev_err(dev, "failed to enable PCLK\n");
486                         return ret;
487                 }
488         }
489
490         /* Some special Cortina Gemini init, if needed */
491         if (of_device_is_compatible(np, "cortina,gemini-pata")) {
492                 /*
493                  * We need to know which instance is probing (the
494                  * Gemini has two instances of FTIDE010) and we do
495                  * this simply by looking at the physical base
496                  * address, which is 0x63400000 for ATA1, else we
497                  * are ATA0. This will also set up the cable types.
498                  */
499                 ret = pata_ftide010_gemini_init(ftide,
500                                 &pi,
501                                 (res->start == 0x63400000));
502                 if (ret)
503                         goto err_dis_clk;
504         } else {
505                 /* Else assume we are connected using PATA40 */
506                 ftide->master_cbl = ATA_CBL_PATA40;
507                 ftide->slave_cbl = ATA_CBL_PATA40;
508         }
509
510         ftide->host = ata_host_alloc_pinfo(dev, ppi, 1);
511         if (!ftide->host) {
512                 ret = -ENOMEM;
513                 goto err_dis_clk;
514         }
515         ftide->host->private_data = ftide;
516
517         for (i = 0; i < ftide->host->n_ports; i++) {
518                 struct ata_port *ap = ftide->host->ports[i];
519                 struct ata_ioports *ioaddr = &ap->ioaddr;
520
521                 ioaddr->bmdma_addr = ftide->base + FTIDE010_DMA_REG;
522                 ioaddr->cmd_addr = ftide->base + FTIDE010_CMD_DATA;
523                 ioaddr->ctl_addr = ftide->base + FTIDE010_ALTSTAT_CTRL;
524                 ioaddr->altstatus_addr = ftide->base + FTIDE010_ALTSTAT_CTRL;
525                 ata_sff_std_ports(ioaddr);
526         }
527
528         dev_info(dev, "device ID %08x, irq %d, reg %pR\n",
529                  readl(ftide->base + FTIDE010_IDE_DEVICE_ID), irq, res);
530
531         ret = ata_host_activate(ftide->host, irq, ata_bmdma_interrupt,
532                                 0, &pata_ftide010_sht);
533         if (ret)
534                 goto err_dis_clk;
535
536         return 0;
537
538 err_dis_clk:
539         if (!IS_ERR(ftide->pclk))
540                 clk_disable_unprepare(ftide->pclk);
541         return ret;
542 }
543
544 static int pata_ftide010_remove(struct platform_device *pdev)
545 {
546         struct ata_host *host = platform_get_drvdata(pdev);
547         struct ftide010 *ftide = host->private_data;
548
549         ata_host_detach(ftide->host);
550         if (!IS_ERR(ftide->pclk))
551                 clk_disable_unprepare(ftide->pclk);
552
553         return 0;
554 }
555
556 static const struct of_device_id pata_ftide010_of_match[] = {
557         {
558                 .compatible = "faraday,ftide010",
559         },
560         {},
561 };
562
563 static struct platform_driver pata_ftide010_driver = {
564         .driver = {
565                 .name = DRV_NAME,
566                 .of_match_table = of_match_ptr(pata_ftide010_of_match),
567         },
568         .probe = pata_ftide010_probe,
569         .remove = pata_ftide010_remove,
570 };
571 module_platform_driver(pata_ftide010_driver);
572
573 MODULE_AUTHOR("Linus Walleij <linus.walleij@linaro.org>");
574 MODULE_LICENSE("GPL");
575 MODULE_ALIAS("platform:" DRV_NAME);