OpenWrt – Blame information for rev 4

Subversion Repositories:
Rev:
Rev Author Line No. Line
4 office 1 /*
2 * sata_oxnas
3 * A driver to interface the 934 based sata core present in the ox820
4 * with libata and scsi
5 * based on sata_oxnas driver by Ma Haijun <mahaijuns@gmail.com>
6 * based on ox820 sata code by:
7 * Copyright (c) 2007 Oxford Semiconductor Ltd.
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2, or (at your option)
12 * any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 */
19  
20 #include <linux/ata.h>
21 #include <linux/libata.h>
22 #include <linux/of_platform.h>
23 #include <linux/delay.h>
24 #include <linux/module.h>
25 #include <linux/slab.h>
26 #include <linux/spinlock.h>
27 #include <linux/of_address.h>
28 #include <linux/of_irq.h>
29 #include <linux/clk.h>
30 #include <linux/reset.h>
31  
32 #include <linux/io.h>
33 #include <linux/sizes.h>
34  
35 static inline void oxnas_register_clear_mask(void __iomem *p, unsigned mask)
36 {
37 u32 val = readl_relaxed(p);
38  
39 val &= ~mask;
40 writel_relaxed(val, p);
41 }
42  
43 static inline void oxnas_register_set_mask(void __iomem *p, unsigned mask)
44 {
45 u32 val = readl_relaxed(p);
46  
47 val |= mask;
48 writel_relaxed(val, p);
49 }
50  
51 static inline void oxnas_register_value_mask(void __iomem *p,
52 unsigned mask, unsigned new_value)
53 {
54 /* TODO sanity check mask & new_value = new_value */
55 u32 val = readl_relaxed(p);
56  
57 val &= ~mask;
58 val |= new_value;
59 writel_relaxed(val, p);
60 }
61  
62 /* sgdma request structure */
63 struct sgdma_request {
64 volatile u32 qualifier;
65 volatile u32 control;
66 dma_addr_t src_pa;
67 dma_addr_t dst_pa;
68 } __packed __aligned(4);
69  
70  
71 /* Controller information */
72 enum {
73 SATA_OXNAS_MAX_PRD = 254,
74 SATA_OXNAS_DMA_SIZE = SATA_OXNAS_MAX_PRD *
75 sizeof(struct ata_bmdma_prd) +
76 sizeof(struct sgdma_request),
77 SATA_OXNAS_MAX_PORTS = 2,
78 /** The different Oxsemi SATA core version numbers */
79 SATA_OXNAS_CORE_VERSION = 0x1f3,
80 SATA_OXNAS_IRQ_FLAG = IRQF_SHARED,
81 SATA_OXNAS_HOST_FLAGS = (ATA_FLAG_SATA | ATA_FLAG_PIO_DMA |
82 ATA_FLAG_NO_ATAPI /*| ATA_FLAG_NCQ*/),
83 SATA_OXNAS_QUEUE_DEPTH = 32,
84  
85 SATA_OXNAS_DMA_BOUNDARY = 0xFFFFFFFF,
86 };
87  
88  
89 /*
90 * SATA Port Registers
91 */
92 enum {
93 /** sata host port register offsets */
94 ORB1 = 0x00,
95 ORB2 = 0x04,
96 ORB3 = 0x08,
97 ORB4 = 0x0C,
98 ORB5 = 0x10,
99 MASTER_STATUS = 0x10,
100 FIS_CTRL = 0x18,
101 FIS_DATA = 0x1C,
102 INT_STATUS = 0x30,
103 INT_CLEAR = 0x30,
104 INT_ENABLE = 0x34,
105 INT_DISABLE = 0x38,
106 VERSION = 0x3C,
107 SATA_CONTROL = 0x5C,
108 SATA_COMMAND = 0x60,
109 HID_FEATURES = 0x64,
110 PORT_CONTROL = 0x68,
111 DRIVE_CONTROL = 0x6C,
112 /** These registers allow access to the link layer registers
113 that reside in a different clock domain to the processor bus */
114 LINK_DATA = 0x70,
115 LINK_RD_ADDR = 0x74,
116 LINK_WR_ADDR = 0x78,
117 LINK_CONTROL = 0x7C,
118 /* window control */
119 WIN1LO = 0x80,
120 WIN1HI = 0x84,
121 WIN2LO = 0x88,
122 WIN2HI = 0x8C,
123 WIN0_CONTROL = 0x90,
124 };
125  
126 /** sata port register bits */
127 enum{
128 /**
129 * commands to issue in the master status to tell it to move shadow ,
130 * registers to the actual device ,
131 */
132 SATA_OPCODE_MASK = 0x00000007,
133 CMD_WRITE_TO_ORB_REGS_NO_COMMAND = 0x4,
134 CMD_WRITE_TO_ORB_REGS = 0x2,
135 CMD_SYNC_ESCAPE = 0x7,
136 CMD_CORE_BUSY = (1 << 7),
137 CMD_DRIVE_SELECT_SHIFT = 12,
138 CMD_DRIVE_SELECT_MASK = (0xf << CMD_DRIVE_SELECT_SHIFT),
139  
140 /** interrupt bits */
141 INT_END_OF_CMD = 1 << 0,
142 INT_LINK_SERROR = 1 << 1,
143 INT_ERROR = 1 << 2,
144 INT_LINK_IRQ = 1 << 3,
145 INT_REG_ACCESS_ERR = 1 << 7,
146 INT_BIST_FIS = 1 << 11,
147 INT_MASKABLE = INT_END_OF_CMD |
148 INT_LINK_SERROR |
149 INT_ERROR |
150 INT_LINK_IRQ |
151 INT_REG_ACCESS_ERR |
152 INT_BIST_FIS,
153 INT_WANT = INT_END_OF_CMD |
154 INT_LINK_SERROR |
155 INT_REG_ACCESS_ERR |
156 INT_ERROR,
157 INT_ERRORS = INT_LINK_SERROR |
158 INT_REG_ACCESS_ERR |
159 INT_ERROR,
160  
161 /** raw interrupt bits, unmaskable, but do not generate interrupts */
162 RAW_END_OF_CMD = INT_END_OF_CMD << 16,
163 RAW_LINK_SERROR = INT_LINK_SERROR << 16,
164 RAW_ERROR = INT_ERROR << 16,
165 RAW_LINK_IRQ = INT_LINK_IRQ << 16,
166 RAW_REG_ACCESS_ERR = INT_REG_ACCESS_ERR << 16,
167 RAW_BIST_FIS = INT_BIST_FIS << 16,
168 RAW_WANT = INT_WANT << 16,
169 RAW_ERRORS = INT_ERRORS << 16,
170  
171 /**
172 * variables to write to the device control register to set the current
173 * device, ie. master or slave.
174 */
175 DR_CON_48 = 2,
176 DR_CON_28 = 0,
177  
178 SATA_CTL_ERR_MASK = 0x00000016,
179  
180 };
181  
182 /* ATA SGDMA register offsets */
183 enum {
184 SGDMA_CONTROL = 0x0,
185 SGDMA_STATUS = 0x4,
186 SGDMA_REQUESTPTR = 0x8,
187 SGDMA_RESETS = 0xC,
188 SGDMA_CORESIZE = 0x10,
189 };
190  
191 /* DMA controller register offsets */
192 enum {
193 DMA_CONTROL = 0x0,
194 DMA_CORESIZE = 0x20,
195  
196 DMA_CONTROL_RESET = (1 << 12),
197 };
198  
199 enum {
200 /* see DMA core docs for the values. Out means from memory (bus A) out
201 * to disk (bus B) */
202 SGDMA_REQCTL0OUT = 0x0497c03d,
203 /* burst mode disabled when no micro code used */
204 SGDMA_REQCTL0IN = 0x0493a3c1,
205 SGDMA_REQCTL1OUT = 0x0497c07d,
206 SGDMA_REQCTL1IN = 0x0497a3c5,
207 SGDMA_CONTROL_NOGO = 0x3e,
208 SGDMA_CONTROL_GO = SGDMA_CONTROL_NOGO | 1,
209 SGDMA_ERRORMASK = 0x3f,
210 SGDMA_BUSY = 0x80,
211  
212 SGDMA_RESETS_CTRL = 1 << 0,
213 SGDMA_RESETS_ARBT = 1 << 1,
214 SGDMA_RESETS_AHB = 1 << 2,
215 SGDMA_RESETS_ALL = SGDMA_RESETS_CTRL |
216 SGDMA_RESETS_ARBT |
217 SGDMA_RESETS_AHB,
218  
219 /* Final EOTs */
220 SGDMA_REQQUAL = 0x00220001,
221  
222 };
223  
224 /** SATA core register offsets */
225 enum {
226 DM_DBG1 = 0x000,
227 RAID_SET = 0x004,
228 DM_DBG2 = 0x008,
229 DATACOUNT_PORT0 = 0x010,
230 DATACOUNT_PORT1 = 0x014,
231 CORE_INT_STATUS = 0x030,
232 CORE_INT_CLEAR = 0x030,
233 CORE_INT_ENABLE = 0x034,
234 CORE_INT_DISABLE = 0x038,
235 CORE_REBUILD_ENABLE = 0x050,
236 CORE_FAILED_PORT_R = 0x054,
237 DEVICE_CONTROL = 0x068,
238 EXCESS = 0x06C,
239 RAID_SIZE_LOW = 0x070,
240 RAID_SIZE_HIGH = 0x074,
241 PORT_ERROR_MASK = 0x078,
242 IDLE_STATUS = 0x07C,
243 RAID_CONTROL = 0x090,
244 DATA_PLANE_CTRL = 0x0AC,
245 CORE_DATAPLANE_STAT = 0x0b8,
246 PROC_PC = 0x100,
247 CONFIG_IN = 0x3d8,
248 PROC_START = 0x3f0,
249 PROC_RESET = 0x3f4,
250 UCODE_STORE = 0x1000,
251 RAID_WP_BOT_LOW = 0x1FF0,
252 RAID_WP_BOT_HIGH = 0x1FF4,
253 RAID_WP_TOP_LOW = 0x1FF8,
254 RAID_WP_TOP_HIGH = 0x1FFC,
255 DATA_MUX_RAM0 = 0x8000,
256 DATA_MUX_RAM1 = 0xA000,
257 PORT_SIZE = 0x10000,
258 };
259  
260 enum {
261 /* Sata core debug1 register bits */
262 CORE_PORT0_DATA_DIR_BIT = 20,
263 CORE_PORT1_DATA_DIR_BIT = 21,
264 CORE_PORT0_DATA_DIR = 1 << CORE_PORT0_DATA_DIR_BIT,
265 CORE_PORT1_DATA_DIR = 1 << CORE_PORT1_DATA_DIR_BIT,
266  
267 /** sata core control register bits */
268 SCTL_CLR_ERR = 0x00003016,
269 RAID_CLR_ERR = 0x0000011e,
270  
271 /* Interrupts direct from the ports */
272 NORMAL_INTS_WANTED = 0x00000303,
273  
274 /* shift these left by port number */
275 COREINT_HOST = 0x00000001,
276 COREINT_END = 0x00000100,
277 CORERAW_HOST = COREINT_HOST << 16,
278 CORERAW_END = COREINT_END << 16,
279  
280 /* Interrupts from the RAID controller only */
281 RAID_INTS_WANTED = 0x00008300,
282  
283 /* The bits in the IDLE_STATUS that, when set indicate an idle core */
284 IDLE_CORES = (1 << 18) | (1 << 19),
285  
286 /* Data plane control error-mask mask and bit, these bit in the data
287 * plane control mask out errors from the ports that prevent the SGDMA
288 * care from sending an interrupt */
289 DPC_ERROR_MASK = 0x00000300,
290 DPC_ERROR_MASK_BIT = 0x00000100,
291 /* enable jbod micro-code */
292 DPC_JBOD_UCODE = 1 << 0,
293 DPC_FIS_SWCH = 1 << 1,
294  
295 /** Device Control register bits */
296 DEVICE_CONTROL_DMABT = 1 << 4,
297 DEVICE_CONTROL_ABORT = 1 << 2,
298 DEVICE_CONTROL_PAD = 1 << 3,
299 DEVICE_CONTROL_PADPAT = 1 << 16,
300 DEVICE_CONTROL_PRTRST = 1 << 8,
301 DEVICE_CONTROL_RAMRST = 1 << 12,
302 DEVICE_CONTROL_ATA_ERR_OVERRIDE = 1 << 28,
303  
304 /** oxsemi HW raid modes */
305 OXNASSATA_NOTRAID = 0,
306 OXNASSATA_RAID0 = 1,
307 OXNASSATA_RAID1 = 2,
308 /** OX820 specific HW-RAID register values */
309 RAID_TWODISKS = 3,
310 UNKNOWN_MODE = ~0,
311  
312 CONFIG_IN_RESUME = 2,
313 };
314  
315 /* SATA PHY Registers */
316 enum {
317 PHY_STAT = 0x00,
318 PHY_DATA = 0x04,
319 };
320  
321 enum {
322 STAT_READ_VALID = (1 << 21),
323 STAT_CR_ACK = (1 << 20),
324 STAT_CR_READ = (1 << 19),
325 STAT_CR_WRITE = (1 << 18),
326 STAT_CAP_DATA = (1 << 17),
327 STAT_CAP_ADDR = (1 << 16),
328  
329 STAT_ACK_ANY = STAT_CR_ACK |
330 STAT_CR_READ |
331 STAT_CR_WRITE |
332 STAT_CAP_DATA |
333 STAT_CAP_ADDR,
334  
335 CR_READ_ENABLE = (1 << 16),
336 CR_WRITE_ENABLE = (1 << 17),
337 CR_CAP_DATA = (1 << 18),
338 };
339  
340 enum {
341 /* Link layer registers */
342 SERROR_IRQ_MASK = 5,
343 };
344  
345 enum {
346 OXNAS_SATA_SOFTRESET = 1,
347 OXNAS_SATA_REINIT = 2,
348 };
349  
350 enum {
351 OXNAS_SATA_UCODE_RAID0,
352 OXNAS_SATA_UCODE_RAID1,
353 OXNAS_SATA_UCODE_JBOD,
354 OXNAS_SATA_UCODE_NONE,
355 };
356  
357 enum {
358 SATA_UNLOCKED,
359 SATA_WRITER,
360 SATA_READER,
361 SATA_REBUILD,
362 SATA_HWRAID,
363 SATA_SCSI_STACK
364 };
365  
366 typedef irqreturn_t (*oxnas_sata_isr_callback_t)(int, unsigned long, int);
367  
368 struct sata_oxnas_host_priv {
369 void __iomem *port_base;
370 void __iomem *dmactl_base;
371 void __iomem *sgdma_base;
372 void __iomem *core_base;
373 void __iomem *phy_base;
374 dma_addr_t dma_base;
375 void __iomem *dma_base_va;
376 size_t dma_size;
377 int irq;
378 int n_ports;
379 int current_ucode;
380 u32 port_frozen;
381 u32 port_in_eh;
382 struct clk *clk;
383 struct reset_control *rst_sata;
384 struct reset_control *rst_link;
385 struct reset_control *rst_phy;
386 spinlock_t phy_lock;
387 spinlock_t core_lock;
388 int core_locked;
389 int reentrant_port_no;
390 int hw_lock_count;
391 int direct_lock_count;
392 void *locker_uid;
393 int current_locker_type;
394 int scsi_nonblocking_attempts;
395 oxnas_sata_isr_callback_t isr_callback;
396 void *isr_arg;
397 wait_queue_head_t fast_wait_queue;
398 wait_queue_head_t scsi_wait_queue;
399 };
400  
401  
402 struct sata_oxnas_port_priv {
403 void __iomem *port_base;
404 void __iomem *dmactl_base;
405 void __iomem *sgdma_base;
406 void __iomem *core_base;
407 struct sgdma_request *sgdma_request;
408 dma_addr_t sgdma_request_pa;
409 };
410  
411 static u8 sata_oxnas_check_status(struct ata_port *ap);
412 static int sata_oxnas_cleanup(struct ata_host *ah);
413 static void sata_oxnas_tf_load(struct ata_port *ap,
414 const struct ata_taskfile *tf);
415 static void sata_oxnas_irq_on(struct ata_port *ap);
416 static void sata_oxnas_post_reset_init(struct ata_port *ap);
417  
418 static int sata_oxnas_acquire_hw(struct ata_port *ap, int may_sleep,
419 int timeout_jiffies);
420 static void sata_oxnas_release_hw(struct ata_port *ap);
421  
422 static const void *HW_LOCKER_UID = (void *)0xdeadbeef;
423  
424 /***************************************************************************
425 * ASIC access
426 ***************************************************************************/
427 static void wait_cr_ack(void __iomem *phy_base)
428 {
429 while ((ioread32(phy_base + PHY_STAT) >> 16) & 0x1f)
430 ; /* wait for an ack bit to be set */
431 }
432  
433 static u16 read_cr(void __iomem *phy_base, u16 address)
434 {
435 iowrite32((u32)address, phy_base + PHY_STAT);
436 wait_cr_ack(phy_base);
437 iowrite32(CR_READ_ENABLE, phy_base + PHY_DATA);
438 wait_cr_ack(phy_base);
439 return (u16)ioread32(phy_base + PHY_STAT);
440 }
441  
442 static void write_cr(void __iomem *phy_base, u16 data, u16 address)
443 {
444 iowrite32((u32)address, phy_base + PHY_STAT);
445 wait_cr_ack(phy_base);
446 iowrite32((data | CR_CAP_DATA), phy_base + PHY_DATA);
447 wait_cr_ack(phy_base);
448 iowrite32(CR_WRITE_ENABLE, phy_base + PHY_DATA);
449 wait_cr_ack(phy_base);
450 }
451  
452 #define PH_GAIN 2
453 #define FR_GAIN 3
454 #define PH_GAIN_OFFSET 6
455 #define FR_GAIN_OFFSET 8
456 #define PH_GAIN_MASK (0x3 << PH_GAIN_OFFSET)
457 #define FR_GAIN_MASK (0x3 << FR_GAIN_OFFSET)
458 #define USE_INT_SETTING (1<<5)
459  
460 void workaround5458(struct ata_host *ah)
461 {
462 struct sata_oxnas_host_priv *hd = ah->private_data;
463 void __iomem *phy_base = hd->phy_base;
464 u16 rx_control;
465 unsigned i;
466  
467 for (i = 0; i < 2; i++) {
468 rx_control = read_cr(phy_base, 0x201d + (i << 8));
469 rx_control &= ~(PH_GAIN_MASK | FR_GAIN_MASK);
470 rx_control |= PH_GAIN << PH_GAIN_OFFSET;
471 rx_control |= (FR_GAIN << FR_GAIN_OFFSET) | USE_INT_SETTING;
472 write_cr(phy_base, rx_control, 0x201d+(i<<8));
473 }
474 }
475  
476 /**
477 * allows access to the link layer registers
478 * @param link_reg the link layer register to access (oxsemi indexing ie
479 * 00 = static config, 04 = phy ctrl)
480 */
481 void sata_oxnas_link_write(struct ata_port *ap, unsigned int link_reg, u32 val)
482 {
483 struct sata_oxnas_port_priv *pd = ap->private_data;
484 struct sata_oxnas_host_priv *hd = ap->host->private_data;
485 void __iomem *port_base = pd->port_base;
486 u32 patience;
487 unsigned long flags;
488  
489 DPRINTK("P%d [0x%02x]->0x%08x\n", ap->port_no, link_reg, val);
490  
491 spin_lock_irqsave(&hd->phy_lock, flags);
492 iowrite32(val, port_base + LINK_DATA);
493  
494 /* accessed twice as a work around for a bug in the SATA abp bridge
495 * hardware (bug 6828) */
496 iowrite32(link_reg , port_base + LINK_WR_ADDR);
497 ioread32(port_base + LINK_WR_ADDR);
498  
499 for (patience = 0x100000; patience > 0; --patience) {
500 if (ioread32(port_base + LINK_CONTROL) & 0x00000001)
501 break;
502 }
503 spin_unlock_irqrestore(&hd->phy_lock, flags);
504 }
505  
506 static int sata_oxnas_scr_write_port(struct ata_port *ap, unsigned int sc_reg,
507 u32 val)
508 {
509 sata_oxnas_link_write(ap, 0x20 + (sc_reg * 4), val);
510 return 0;
511 }
512  
513 static int sata_oxnas_scr_write(struct ata_link *link, unsigned int sc_reg,
514 u32 val)
515 {
516 return sata_oxnas_scr_write_port(link->ap, sc_reg, val);
517 }
518  
519 u32 sata_oxnas_link_read(struct ata_port *ap, unsigned int link_reg)
520 {
521 struct sata_oxnas_port_priv *pd = ap->private_data;
522 struct sata_oxnas_host_priv *hd = ap->host->private_data;
523 void __iomem *port_base = pd->port_base;
524 u32 result;
525 u32 patience;
526 unsigned long flags;
527  
528 spin_lock_irqsave(&hd->phy_lock, flags);
529 /* accessed twice as a work around for a bug in the SATA abp bridge
530 * hardware (bug 6828) */
531 iowrite32(link_reg, port_base + LINK_RD_ADDR);
532 ioread32(port_base + LINK_RD_ADDR);
533  
534 for (patience = 0x100000; patience > 0; --patience) {
535 if (ioread32(port_base + LINK_CONTROL) & 0x00000001)
536 break;
537 }
538 if (patience == 0)
539 DPRINTK("link read timed out for port %d\n", ap->port_no);
540  
541 result = ioread32(port_base + LINK_DATA);
542 spin_unlock_irqrestore(&hd->phy_lock, flags);
543  
544 return result;
545 }
546  
547 static int sata_oxnas_scr_read_port(struct ata_port *ap, unsigned int sc_reg,
548 u32 *val)
549 {
550 *val = sata_oxnas_link_read(ap, 0x20 + (sc_reg*4));
551 return 0;
552 }
553  
554 static int sata_oxnas_scr_read(struct ata_link *link,
555 unsigned int sc_reg, u32 *val)
556 {
557 return sata_oxnas_scr_read_port(link->ap, sc_reg, val);
558 }
559  
560 /**
561 * sata_oxnas_irq_clear is called during probe just before the interrupt handler is
562 * registered, to be sure hardware is quiet. It clears and masks interrupt bits
563 * in the SATA core.
564 *
565 * @param ap hardware with the registers in
566 */
567 static void sata_oxnas_irq_clear(struct ata_port *ap)
568 {
569 struct sata_oxnas_port_priv *port_priv = ap->private_data;
570  
571 /* clear pending interrupts */
572 iowrite32(~0, port_priv->port_base + INT_CLEAR);
573 iowrite32(COREINT_END, port_priv->core_base + CORE_INT_CLEAR);
574 }
575  
576 /**
577 * qc_issue is used to make a command active, once the hardware and S/G tables
578 * have been prepared. IDE BMDMA drivers use the helper function
579 * ata_qc_issue_prot() for taskfile protocol-based dispatch. More advanced
580 * drivers roll their own ->qc_issue implementation, using this as the
581 * "issue new ATA command to hardware" hook.
582 * @param qc the queued command to issue
583 */
584 static unsigned int sata_oxnas_qc_issue(struct ata_queued_cmd *qc)
585 {
586 struct sata_oxnas_port_priv *pd = qc->ap->private_data;
587 struct sata_oxnas_host_priv *hd = qc->ap->host->private_data;
588  
589 void __iomem *port_base = pd->port_base;
590 void __iomem *core_base = pd->core_base;
591 int port_no = qc->ap->port_no;
592 int no_microcode = (hd->current_ucode == UNKNOWN_MODE);
593 u32 reg;
594  
595 /* check the core is idle */
596 if (ioread32(port_base + SATA_COMMAND) & CMD_CORE_BUSY) {
597 int count = 0;
598  
599 DPRINTK("core busy for a command on port %d\n",
600 qc->ap->port_no);
601 do {
602 mdelay(1);
603 if (++count > 100) {
604 DPRINTK("core busy for a command on port %d\n",
605 qc->ap->port_no);
606 /* CrazyDumpDebug(); */
607 sata_oxnas_cleanup(qc->ap->host);
608 }
609 } while (ioread32(port_base + SATA_COMMAND) & CMD_CORE_BUSY);
610 }
611  
612 /* enable passing of error signals to DMA sub-core by clearing the
613 * appropriate bit */
614 reg = ioread32(core_base + DATA_PLANE_CTRL);
615 if (no_microcode)
616 reg |= (DPC_ERROR_MASK_BIT | (DPC_ERROR_MASK_BIT << 1));
617 reg &= ~(DPC_ERROR_MASK_BIT << port_no);
618 iowrite32(reg, core_base + DATA_PLANE_CTRL);
619  
620 /* Disable all interrupts for ports and RAID controller */
621 iowrite32(~0, port_base + INT_DISABLE);
622  
623 /* Disable all interrupts for core */
624 iowrite32(~0, core_base + CORE_INT_DISABLE);
625 wmb();
626  
627 /* Load the command settings into the orb registers */
628 sata_oxnas_tf_load(qc->ap, &qc->tf);
629  
630 /* both pio and dma commands use dma */
631 if (ata_is_dma(qc->tf.protocol) || ata_is_pio(qc->tf.protocol)) {
632 /* Start the DMA */
633 iowrite32(SGDMA_CONTROL_GO, pd->sgdma_base + SGDMA_CONTROL);
634 wmb();
635 }
636  
637 /* enable End of command interrupt */
638 iowrite32(INT_WANT, port_base + INT_ENABLE);
639 iowrite32(COREINT_END, core_base + CORE_INT_ENABLE);
640 wmb();
641  
642 /* Start the command */
643 reg = ioread32(port_base + SATA_COMMAND);
644 reg &= ~SATA_OPCODE_MASK;
645 reg |= CMD_WRITE_TO_ORB_REGS;
646 iowrite32(reg , port_base + SATA_COMMAND);
647 wmb();
648  
649 return 0;
650 }
651  
652 /**
653 * Will schedule the libATA error handler on the premise that there has
654 * been a hotplug event on the port specified
655 */
656 void sata_oxnas_checkforhotplug(struct ata_port *ap)
657 {
658 DPRINTK("ENTER\n");
659  
660 ata_ehi_hotplugged(&ap->link.eh_info);
661 ata_port_freeze(ap);
662 }
663  
664  
665 /**************************************************************************/
666 /* Locking */
667 /**************************************************************************/
668 /**
669 * The underlying function that controls access to the sata core
670 *
671 * @return non-zero indicates that you have acquired exclusive access to the
672 * sata core.
673 */
674 static int __acquire_sata_core(
675 struct ata_host *ah,
676 int port_no,
677 oxnas_sata_isr_callback_t callback,
678 void *arg,
679 int may_sleep,
680 int timeout_jiffies,
681 int hw_access,
682 void *uid,
683 int locker_type)
684 {
685 unsigned long end = jiffies + timeout_jiffies;
686 int acquired = 0;
687 unsigned long flags;
688 int timed_out = 0;
689 struct sata_oxnas_host_priv *hd;
690  
691 DEFINE_WAIT(wait);
692  
693 if (!ah)
694 return acquired;
695  
696 hd = ah->private_data;
697  
698 spin_lock_irqsave(&hd->core_lock, flags);
699  
700 DPRINTK("Entered uid %p, port %d, h/w count %d, d count %d, "
701 "callback %p, hw_access %d, core_locked %d, "
702 "reentrant_port_no %d, isr_callback %p\n",
703 uid, port_no, hd->hw_lock_count, hd->direct_lock_count,
704 callback, hw_access, hd->core_locked, hd->reentrant_port_no,
705 hd->isr_callback);
706  
707 while (!timed_out) {
708 if (hd->core_locked ||
709 (!hw_access && hd->scsi_nonblocking_attempts)) {
710 /* Can only allow access if from SCSI/SATA stack and if
711 * reentrant access is allowed and this access is to the
712 * same port for which the lock is current held
713 */
714 if (hw_access && (port_no == hd->reentrant_port_no)) {
715 BUG_ON(!hd->hw_lock_count);
716 ++(hd->hw_lock_count);
717  
718 DPRINTK("Allow SCSI/SATA re-entrant access to "
719 "uid %p port %d\n", uid, port_no);
720 acquired = 1;
721 break;
722 } else if (!hw_access) {
723 if ((locker_type == SATA_READER) &&
724 (hd->current_locker_type == SATA_READER)) {
725 WARN(1,
726 "Already locked by reader, "
727 "uid %p, locker_uid %p, "
728 "port %d, h/w count %d, "
729 "d count %d, hw_access %d\n",
730 uid, hd->locker_uid, port_no,
731 hd->hw_lock_count,
732 hd->direct_lock_count,
733 hw_access);
734 goto check_uid;
735 }
736  
737 if ((locker_type != SATA_READER) &&
738 (locker_type != SATA_WRITER)) {
739 goto wait_for_lock;
740 }
741  
742 check_uid:
743 WARN(uid == hd->locker_uid, "Attempt to lock "
744 "by locker type %d uid %p, already "
745 "locked by locker type %d with "
746 "locker_uid %p, port %d, "
747 "h/w count %d, d count %d, "
748 "hw_access %d\n", locker_type, uid,
749 hd->current_locker_type,
750 hd->locker_uid, port_no,
751 hd->hw_lock_count,
752 hd->direct_lock_count, hw_access);
753 }
754 } else {
755 WARN(hd->hw_lock_count || hd->direct_lock_count,
756 "Core unlocked but counts non-zero: uid %p, "
757 "locker_uid %p, port %d, h/w count %d, "
758 "d count %d, hw_access %d\n", uid,
759 hd->locker_uid, port_no, hd->hw_lock_count,
760 hd->direct_lock_count, hw_access);
761  
762 BUG_ON(hd->current_locker_type != SATA_UNLOCKED);
763  
764 WARN(hd->locker_uid, "Attempt to lock uid %p when "
765 "locker_uid %p is non-zero, port %d, "
766 "h/w count %d, d count %d, hw_access %d\n",
767 uid, hd->locker_uid, port_no, hd->hw_lock_count,
768 hd->direct_lock_count, hw_access);
769  
770 if (!hw_access) {
771 /* Direct access attempting to acquire
772 * non-contented lock
773 */
774 /* Must have callback for direct access */
775 BUG_ON(!callback);
776 /* Sanity check lock state */
777 BUG_ON(hd->reentrant_port_no != -1);
778  
779 hd->isr_callback = callback;
780 hd->isr_arg = arg;
781 ++(hd->direct_lock_count);
782  
783 hd->current_locker_type = locker_type;
784 } else {
785 /* SCSI/SATA attempting to acquire
786 * non-contented lock
787 */
788 /* No callbacks for SCSI/SATA access */
789 BUG_ON(callback);
790 /* No callback args for SCSI/SATA access */
791 BUG_ON(arg);
792  
793 /* Sanity check lock state */
794 BUG_ON(hd->isr_callback);
795 BUG_ON(hd->isr_arg);
796  
797 ++(hd->hw_lock_count);
798 hd->reentrant_port_no = port_no;
799  
800 hd->current_locker_type = SATA_SCSI_STACK;
801 }
802  
803 hd->core_locked = 1;
804 hd->locker_uid = uid;
805 acquired = 1;
806 break;
807 }
808  
809 wait_for_lock:
810 if (!may_sleep) {
811 DPRINTK("Denying for uid %p locker_type %d, "
812 "hw_access %d, port %d, current_locker_type %d as "
813 "cannot sleep\n", uid, locker_type, hw_access, port_no,
814 hd->current_locker_type);
815  
816 if (hw_access)
817 ++(hd->scsi_nonblocking_attempts);
818  
819 break;
820 }
821  
822 /* Core is locked and we're allowed to sleep, so wait to be
823 * awoken when the core is unlocked
824 */
825 for (;;) {
826 prepare_to_wait(hw_access ? &hd->scsi_wait_queue :
827 &hd->fast_wait_queue,
828 &wait, TASK_UNINTERRUPTIBLE);
829 if (!hd->core_locked &&
830 !(!hw_access && hd->scsi_nonblocking_attempts)) {
831 /* We're going to use variables that will have
832 * been changed by the waker prior to clearing
833 * core_locked so we need to ensure we see
834 * changes to all those variables
835 */
836 smp_rmb();
837 break;
838 }
839 if (time_after(jiffies, end)) {
840 printk(KERN_WARNING "__acquire_sata_core() "
841 "uid %p failing for port %d timed out, "
842 "locker_uid %p, h/w count %d, "
843 "d count %d, callback %p, hw_access %d, "
844 "core_locked %d, reentrant_port_no %d, "
845 "isr_callback %p, isr_arg %p\n", uid,
846 port_no, hd->locker_uid,
847 hd->hw_lock_count,
848 hd->direct_lock_count, callback,
849 hw_access, hd->core_locked,
850 hd->reentrant_port_no, hd->isr_callback,
851 hd->isr_arg);
852 timed_out = 1;
853 break;
854 }
855 spin_unlock_irqrestore(&hd->core_lock, flags);
856 if (!schedule_timeout(4*HZ)) {
857 printk(KERN_INFO "__acquire_sata_core() uid %p, "
858 "locker_uid %p, timed-out of "
859 "schedule(), checking overall timeout\n",
860 uid, hd->locker_uid);
861 }
862 spin_lock_irqsave(&hd->core_lock, flags);
863 }
864 finish_wait(hw_access ? &hd->scsi_wait_queue :
865 &hd->fast_wait_queue, &wait);
866 }
867  
868 if (hw_access && acquired) {
869 if (hd->scsi_nonblocking_attempts)
870 hd->scsi_nonblocking_attempts = 0;
871  
872 /* Wake any other SCSI/SATA waiters so they can get reentrant
873 * access to the same port if appropriate. This is because if
874 * the SATA core is locked by fast access, or SCSI/SATA access
875 * to other port, then can have >1 SCSI/SATA waiters on the wait
876 * list so want to give reentrant accessors a chance to get
877 * access ASAP
878 */
879 if (!list_empty(&hd->scsi_wait_queue.head))
880 wake_up(&hd->scsi_wait_queue);
881 }
882  
883 DPRINTK("Leaving uid %p with acquired = %d, port %d, callback %p\n",
884 uid, acquired, port_no, callback);
885  
886 spin_unlock_irqrestore(&hd->core_lock, flags);
887  
888 return acquired;
889 }
890  
891 int sata_core_has_fast_waiters(struct ata_host *ah)
892 {
893 int has_waiters;
894 unsigned long flags;
895 struct sata_oxnas_host_priv *hd = ah->private_data;
896  
897 spin_lock_irqsave(&hd->core_lock, flags);
898 has_waiters = !list_empty(&hd->fast_wait_queue.head);
899 spin_unlock_irqrestore(&hd->core_lock, flags);
900  
901 return has_waiters;
902 }
903 EXPORT_SYMBOL(sata_core_has_fast_waiters);
904  
905 int sata_core_has_scsi_waiters(struct ata_host *ah)
906 {
907 int has_waiters;
908 unsigned long flags;
909 struct sata_oxnas_host_priv *hd = ah->private_data;
910  
911 spin_lock_irqsave(&hd->core_lock, flags);
912 has_waiters = hd->scsi_nonblocking_attempts ||
913 !list_empty(&hd->scsi_wait_queue.head);
914 spin_unlock_irqrestore(&hd->core_lock, flags);
915  
916 return has_waiters;
917 }
918 EXPORT_SYMBOL(sata_core_has_scsi_waiters);
919  
920 /*
921 * ata_port operation to gain ownership of the SATA hardware prior to issuing
922 * a command against a SATA host. Allows any number of users of the port against
923 * which the lock was first acquired, thus enforcing that only one SATA core
924 * port may be operated on at once.
925 */
926 static int sata_oxnas_acquire_hw(
927 struct ata_port *ap,
928 int may_sleep,
929 int timeout_jiffies)
930 {
931 return __acquire_sata_core(ap->host, ap->port_no, NULL, 0, may_sleep,
932 timeout_jiffies, 1, (void *)HW_LOCKER_UID,
933 SATA_SCSI_STACK);
934 }
935  
936 /*
937 * operation to release ownership of the SATA hardware
938 */
939 static void sata_oxnas_release_hw(struct ata_port *ap)
940 {
941 unsigned long flags;
942 int released = 0;
943 struct sata_oxnas_host_priv *hd = ap->host->private_data;
944  
945 spin_lock_irqsave(&hd->core_lock, flags);
946  
947 DPRINTK("Entered port_no = %d, h/w count %d, d count %d, "
948 "core locked = %d, reentrant_port_no = %d, isr_callback %p\n",
949 ap->port_no, hd->hw_lock_count, hd->direct_lock_count,
950 hd->core_locked, hd->reentrant_port_no, hd->isr_callback);
951  
952 if (!hd->core_locked) {
953 /* Nobody holds the SATA lock */
954 printk(KERN_WARNING "Nobody holds SATA lock, port_no %d\n",
955 ap->port_no);
956 released = 1;
957 } else if (!hd->hw_lock_count) {
958 /* SCSI/SATA has released without holding the lock */
959 printk(KERN_WARNING "SCSI/SATA does not hold SATA lock, "
960 "port_no %d\n", ap->port_no);
961 } else {
962 /* Trap incorrect usage */
963 BUG_ON(hd->reentrant_port_no == -1);
964 BUG_ON(ap->port_no != hd->reentrant_port_no);
965 BUG_ON(hd->direct_lock_count);
966 BUG_ON(hd->current_locker_type != SATA_SCSI_STACK);
967  
968 WARN(!hd->locker_uid || (hd->locker_uid != HW_LOCKER_UID),
969 "Invalid locker uid %p, h/w count %d, d count %d, "
970 "reentrant_port_no %d, core_locked %d, "
971 "isr_callback %p\n", hd->locker_uid, hd->hw_lock_count,
972 hd->direct_lock_count, hd->reentrant_port_no,
973 hd->core_locked, hd->isr_callback);
974  
975 if (--(hd->hw_lock_count)) {
976 DPRINTK("Still nested port_no %d\n", ap->port_no);
977 } else {
978 DPRINTK("Release port_no %d\n", ap->port_no);
979 hd->reentrant_port_no = -1;
980 hd->isr_callback = NULL;
981 hd->current_locker_type = SATA_UNLOCKED;
982 hd->locker_uid = 0;
983 hd->core_locked = 0;
984 released = 1;
985 wake_up(!list_empty(&hd->scsi_wait_queue.head) ?
986 &hd->scsi_wait_queue :
987 &hd->fast_wait_queue);
988 }
989 }
990  
991 DPRINTK("Leaving, port_no %d, count %d\n", ap->port_no,
992 hd->hw_lock_count);
993  
994 spin_unlock_irqrestore(&hd->core_lock, flags);
995  
996 /* CONFIG_SATA_OX820_DIRECT_HWRAID */
997 /* if (released)
998 ox820hwraid_restart_queue();
999 } */
1000 }
1001  
1002 static inline int sata_oxnas_is_host_frozen(struct ata_host *ah)
1003 {
1004 struct sata_oxnas_host_priv *hd = ah->private_data;
1005  
1006 smp_rmb();
1007 return hd->port_in_eh || hd->port_frozen;
1008 }
1009  
1010  
1011 static inline u32 sata_oxnas_hostportbusy(struct ata_port *ap)
1012 {
1013 struct sata_oxnas_host_priv *hd = ap->host->private_data;
1014  
1015 return (ioread32(hd->port_base + SATA_COMMAND) & CMD_CORE_BUSY) ||
1016 (hd->n_ports > 1 &&
1017 (ioread32(hd->port_base + PORT_SIZE + SATA_COMMAND) &
1018 CMD_CORE_BUSY));
1019 }
1020  
1021 static inline u32 sata_oxnas_hostdmabusy(struct ata_port *ap)
1022 {
1023 struct sata_oxnas_port_priv *pd = ap->private_data;
1024  
1025 return ioread32(pd->sgdma_base + SGDMA_STATUS) & SGDMA_BUSY;
1026 }
1027  
1028  
1029 /**
1030 * Turns on the cores clock and resets it
1031 */
1032 static void sata_oxnas_reset_core(struct ata_host *ah)
1033 {
1034 struct sata_oxnas_host_priv *host_priv = ah->private_data;
1035 int n;
1036  
1037 DPRINTK("ENTER\n");
1038 clk_prepare_enable(host_priv->clk);
1039  
1040 reset_control_assert(host_priv->rst_sata);
1041 reset_control_assert(host_priv->rst_link);
1042 reset_control_assert(host_priv->rst_phy);
1043  
1044 udelay(50);
1045  
1046 /* un-reset the PHY, then Link and Controller */
1047 reset_control_deassert(host_priv->rst_phy);
1048 udelay(50);
1049  
1050 reset_control_deassert(host_priv->rst_sata);
1051 reset_control_deassert(host_priv->rst_link);
1052 udelay(50);
1053  
1054 workaround5458(ah);
1055 /* tune for sata compatibility */
1056 sata_oxnas_link_write(ah->ports[0], 0x60, 0x2988);
1057  
1058 for (n = 0; n < host_priv->n_ports; n++) {
1059 /* each port in turn */
1060 sata_oxnas_link_write(ah->ports[n], 0x70, 0x55629);
1061 }
1062 udelay(50);
1063 }
1064  
1065  
1066 /**
1067 * Called after an identify device command has worked out what kind of device
1068 * is on the port
1069 *
1070 * @param port The port to configure
1071 * @param pdev The hardware associated with controlling the port
1072 */
1073 static void sata_oxnas_dev_config(struct ata_device *pdev)
1074 {
1075 struct sata_oxnas_port_priv *pd = pdev->link->ap->private_data;
1076 void __iomem *port_base = pd->port_base;
1077 u32 reg;
1078  
1079 DPRINTK("ENTER\n");
1080 /* Set the bits to put the port into 28 or 48-bit node */
1081 reg = ioread32(port_base + DRIVE_CONTROL);
1082 reg &= ~3;
1083 reg |= (pdev->flags & ATA_DFLAG_LBA48) ? DR_CON_48 : DR_CON_28;
1084 iowrite32(reg, port_base + DRIVE_CONTROL);
1085  
1086 /* if this is an ATA-6 disk, put port into ATA-5 auto translate mode */
1087 if (pdev->flags & ATA_DFLAG_LBA48) {
1088 reg = ioread32(port_base + PORT_CONTROL);
1089 reg |= 2;
1090 iowrite32(reg, port_base + PORT_CONTROL);
1091 }
1092 }
1093 /**
1094 * called to write a taskfile into the ORB registers
1095 * @param ap hardware with the registers in
1096 * @param tf taskfile to write to the registers
1097 */
1098 static void sata_oxnas_tf_load(struct ata_port *ap,
1099 const struct ata_taskfile *tf)
1100 {
1101 u32 count = 0;
1102 u32 Orb1 = 0;
1103 u32 Orb2 = 0;
1104 u32 Orb3 = 0;
1105 u32 Orb4 = 0;
1106 u32 Command_Reg;
1107  
1108 struct sata_oxnas_port_priv *port_priv = ap->private_data;
1109 void __iomem *port_base = port_priv->port_base;
1110 unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
1111  
1112 /* wait a maximum of 10ms for the core to be idle */
1113 do {
1114 Command_Reg = ioread32(port_base + SATA_COMMAND);
1115 if (!(Command_Reg & CMD_CORE_BUSY))
1116 break;
1117 count++;
1118 udelay(50);
1119 } while (count < 200);
1120  
1121 /* check if the ctl register has interrupts disabled or enabled and
1122 * modify the interrupt enable registers on the ata core as required */
1123 if (tf->ctl & ATA_NIEN) {
1124 /* interrupts disabled */
1125 u32 mask = (COREINT_END << ap->port_no);
1126  
1127 iowrite32(mask, port_priv->core_base + CORE_INT_DISABLE);
1128 sata_oxnas_irq_clear(ap);
1129 } else {
1130 sata_oxnas_irq_on(ap);
1131 }
1132  
1133 Orb2 |= (tf->command) << 24;
1134  
1135 /* write 48 or 28 bit tf parameters */
1136 if (is_addr) {
1137 /* set LBA bit as it's an address */
1138 Orb1 |= (tf->device & ATA_LBA) << 24;
1139  
1140 if (tf->flags & ATA_TFLAG_LBA48) {
1141 Orb1 |= ATA_LBA << 24;
1142 Orb2 |= (tf->hob_nsect) << 8;
1143 Orb3 |= (tf->hob_lbal) << 24;
1144 Orb4 |= (tf->hob_lbam) << 0;
1145 Orb4 |= (tf->hob_lbah) << 8;
1146 Orb4 |= (tf->hob_feature) << 16;
1147 } else {
1148 Orb3 |= (tf->device & 0xf) << 24;
1149 }
1150  
1151 /* write 28-bit lba */
1152 Orb2 |= (tf->nsect) << 0;
1153 Orb2 |= (tf->feature) << 16;
1154 Orb3 |= (tf->lbal) << 0;
1155 Orb3 |= (tf->lbam) << 8;
1156 Orb3 |= (tf->lbah) << 16;
1157 Orb4 |= (tf->ctl) << 24;
1158 }
1159  
1160 if (tf->flags & ATA_TFLAG_DEVICE)
1161 Orb1 |= (tf->device) << 24;
1162  
1163 ap->last_ctl = tf->ctl;
1164  
1165 /* write values to registers */
1166 iowrite32(Orb1, port_base + ORB1);
1167 iowrite32(Orb2, port_base + ORB2);
1168 iowrite32(Orb3, port_base + ORB3);
1169 iowrite32(Orb4, port_base + ORB4);
1170 }
1171  
1172  
1173 void sata_oxnas_set_mode(struct ata_host *ah, u32 mode, u32 force)
1174 {
1175 struct sata_oxnas_host_priv *host_priv = ah->private_data;
1176 void __iomem *core_base = host_priv->core_base;
1177  
1178 unsigned int *src;
1179 void __iomem *dst;
1180 unsigned int progmicrocode = 0;
1181 unsigned int changeparameters = 0;
1182  
1183 u32 previous_mode;
1184  
1185 /* these micro-code programs _should_ include the version word */
1186  
1187 /* JBOD */
1188 static const unsigned int jbod[] = {
1189 0x07B400AC, 0x0228A280, 0x00200001, 0x00204002, 0x00224001,
1190 0x00EE0009, 0x00724901, 0x01A24903, 0x00E40009, 0x00224001,
1191 0x00621120, 0x0183C908, 0x00E20005, 0x00718908, 0x0198A206,
1192 0x00621124, 0x0183C908, 0x00E20046, 0x00621104, 0x0183C908,
1193 0x00E20015, 0x00EE009D, 0x01A3E301, 0x00E2001B, 0x0183C900,
1194 0x00E2001B, 0x00210001, 0x00EE0020, 0x01A3E302, 0x00E2009D,
1195 0x0183C901, 0x00E2009D, 0x00210002, 0x0235D700, 0x0208A204,
1196 0x0071C908, 0x000F8207, 0x000FC207, 0x0071C920, 0x000F8507,
1197 0x000FC507, 0x0228A240, 0x02269A40, 0x00094004, 0x00621104,
1198 0x0180C908, 0x00E40031, 0x00621112, 0x01A3C801, 0x00E2002B,
1199 0x00294000, 0x0228A220, 0x01A69ABF, 0x002F8000, 0x002FC000,
1200 0x0198A204, 0x0001C022, 0x01B1A220, 0x0001C106, 0x00088007,
1201 0x0183C903, 0x00E2009D, 0x0228A220, 0x0071890C, 0x0208A206,
1202 0x0198A206, 0x0001C022, 0x01B1A220, 0x0001C106, 0x00088007,
1203 0x00EE009D, 0x00621104, 0x0183C908, 0x00E2004A, 0x00EE009D,
1204 0x01A3C901, 0x00E20050, 0x0021E7FF, 0x0183E007, 0x00E2009D,
1205 0x00EE0054, 0x0061600B, 0x0021E7FF, 0x0183C507, 0x00E2009D,
1206 0x01A3E301, 0x00E2005A, 0x0183C900, 0x00E2005A, 0x00210001,
1207 0x00EE005F, 0x01A3E302, 0x00E20005, 0x0183C901, 0x00E20005,
1208 0x00210002, 0x0235D700, 0x0208A204, 0x000F8109, 0x000FC109,
1209 0x0071C918, 0x000F8407, 0x000FC407, 0x0001C022, 0x01A1A2BF,
1210 0x0001C106, 0x00088007, 0x02269A40, 0x00094004, 0x00621112,
1211 0x01A3C801, 0x00E4007F, 0x00621104, 0x0180C908, 0x00E4008D,
1212 0x00621128, 0x0183C908, 0x00E2006C, 0x01A3C901, 0x00E2007B,
1213 0x0021E7FF, 0x0183E007, 0x00E2007F, 0x00EE006C, 0x0061600B,
1214 0x0021E7FF, 0x0183C507, 0x00E4006C, 0x00621111, 0x01A3C801,
1215 0x00E2007F, 0x00621110, 0x01A3C801, 0x00E20082, 0x0228A220,
1216 0x00621119, 0x01A3C801, 0x00E20086, 0x0001C022, 0x01B1A220,
1217 0x0001C106, 0x00088007, 0x0198A204, 0x00294000, 0x01A69ABF,
1218 0x002F8000, 0x002FC000, 0x0183C903, 0x00E20005, 0x0228A220,
1219 0x0071890C, 0x0208A206, 0x0198A206, 0x0001C022, 0x01B1A220,
1220 0x0001C106, 0x00088007, 0x00EE009D, 0x00621128, 0x0183C908,
1221 0x00E20005, 0x00621104, 0x0183C908, 0x00E200A6, 0x0062111C,
1222 0x0183C908, 0x00E20005, 0x0071890C, 0x0208A206, 0x0198A206,
1223 0x00718908, 0x0208A206, 0x00EE0005, ~0
1224 };
1225  
1226 /* Bi-Modal RAID-0/1 */
1227 static const unsigned int raid[] = {
1228 0x00F20145, 0x00EE20FA, 0x00EE20A7, 0x0001C009, 0x00EE0004,
1229 0x00220000, 0x0001000B, 0x037003FF, 0x00700018, 0x037003FE,
1230 0x037043FD, 0x00704118, 0x037043FC, 0x01A3D240, 0x00E20017,
1231 0x00B3C235, 0x00E40018, 0x0093C104, 0x00E80014, 0x0093C004,
1232 0x00E80017, 0x01020000, 0x00274020, 0x00EE0083, 0x0080C904,
1233 0x0093C104, 0x00EA0020, 0x0093C103, 0x00EC001F, 0x00220002,
1234 0x00924104, 0x0005C009, 0x00EE0058, 0x0093CF04, 0x00E80026,
1235 0x00900F01, 0x00600001, 0x00910400, 0x00EE0058, 0x00601604,
1236 0x01A00003, 0x00E2002C, 0x01018000, 0x00274040, 0x00EE0083,
1237 0x0093CF03, 0x00EC0031, 0x00220003, 0x00924F04, 0x0005C009,
1238 0x00810104, 0x00B3C235, 0x00E20037, 0x0022C000, 0x00218210,
1239 0x00EE0039, 0x0022C001, 0x00218200, 0x00600401, 0x00A04901,
1240 0x00604101, 0x01A0C401, 0x00E20040, 0x00216202, 0x00EE0041,
1241 0x00216101, 0x02018506, 0x00EE2141, 0x00904901, 0x00E20049,
1242 0x00A00401, 0x00600001, 0x02E0C301, 0x00EE2141, 0x00216303,
1243 0x037003EE, 0x01A3C001, 0x00E40105, 0x00250080, 0x00204000,
1244 0x002042F1, 0x0004C001, 0x00230001, 0x00100006, 0x02C18605,
1245 0x00100006, 0x01A3D502, 0x00E20055, 0x00EE0053, 0x00004009,
1246 0x00000004, 0x00B3C235, 0x00E40062, 0x0022C001, 0x0020C000,
1247 0x00EE2141, 0x0020C001, 0x00EE2141, 0x00EE006B, 0x0022C000,
1248 0x0060D207, 0x00EE2141, 0x00B3C242, 0x00E20069, 0x01A3D601,
1249 0x00E2006E, 0x02E0C301, 0x00EE2141, 0x00230001, 0x00301303,
1250 0x00EE007B, 0x00218210, 0x01A3C301, 0x00E20073, 0x00216202,
1251 0x00EE0074, 0x00216101, 0x02018506, 0x00214000, 0x037003EE,
1252 0x01A3C001, 0x00E40108, 0x00230001, 0x00100006, 0x00250080,
1253 0x00204000, 0x002042F1, 0x0004C001, 0x00EE007F, 0x0024C000,
1254 0x01A3D1F0, 0x00E20088, 0x00230001, 0x00300000, 0x01A3D202,
1255 0x00E20085, 0x00EE00A5, 0x00B3C800, 0x00E20096, 0x00218000,
1256 0x00924709, 0x0005C009, 0x00B20802, 0x00E40093, 0x037103FD,
1257 0x00710418, 0x037103FC, 0x00EE0006, 0x00220000, 0x0001000F,
1258 0x00EE0006, 0x00800B0C, 0x00B00001, 0x00204000, 0x00208550,
1259 0x00208440, 0x002083E0, 0x00208200, 0x00208100, 0x01008000,
1260 0x037083EE, 0x02008212, 0x02008216, 0x01A3C201, 0x00E400A5,
1261 0x0100C000, 0x00EE20FA, 0x02800000, 0x00208000, 0x00B24C00,
1262 0x00E400AD, 0x00224001, 0x00724910, 0x0005C009, 0x00B3CDC4,
1263 0x00E200D5, 0x00B3CD29, 0x00E200D5, 0x00B3CD20, 0x00E200D5,
1264 0x00B3CD24, 0x00E200D5, 0x00B3CDC5, 0x00E200D2, 0x00B3CD39,
1265 0x00E200D2, 0x00B3CD30, 0x00E200D2, 0x00B3CD34, 0x00E200D2,
1266 0x00B3CDCA, 0x00E200CF, 0x00B3CD35, 0x00E200CF, 0x00B3CDC8,
1267 0x00E200CC, 0x00B3CD25, 0x00E200CC, 0x00B3CD40, 0x00E200CB,
1268 0x00B3CD42, 0x00E200CB, 0x01018000, 0x00EE0083, 0x0025C000,
1269 0x036083EE, 0x0000800D, 0x00EE00D8, 0x036083EE, 0x00208035,
1270 0x00EE00DA, 0x036083EE, 0x00208035, 0x00EE00DA, 0x00208007,
1271 0x036083EE, 0x00208025, 0x036083EF, 0x02400000, 0x01A3D208,
1272 0x00E200D8, 0x0067120A, 0x0021C000, 0x0021C224, 0x00220000,
1273 0x00404B1C, 0x00600105, 0x00800007, 0x0020C00E, 0x00214000,
1274 0x01004000, 0x01A0411F, 0x00404E01, 0x01A3C101, 0x00E200F1,
1275 0x00B20800, 0x00E400D8, 0x00220001, 0x0080490B, 0x00B04101,
1276 0x0040411C, 0x00EE00E1, 0x02269A01, 0x01020000, 0x02275D80,
1277 0x01A3D202, 0x00E200F4, 0x01B75D80, 0x01030000, 0x01B69A01,
1278 0x00EE00D8, 0x01A3D204, 0x00E40104, 0x00224000, 0x0020C00E,
1279 0x0020001E, 0x00214000, 0x01004000, 0x0212490E, 0x00214001,
1280 0x01004000, 0x02400000, 0x00B3D702, 0x00E80112, 0x00EE010E,
1281 0x00B3D702, 0x00E80112, 0x00B3D702, 0x00E4010E, 0x00230001,
1282 0x00EE0140, 0x00200005, 0x036003EE, 0x00204001, 0x00EE0116,
1283 0x00230001, 0x00100006, 0x02C18605, 0x00100006, 0x01A3D1F0,
1284 0x00E40083, 0x037003EE, 0x01A3C002, 0x00E20121, 0x0020A300,
1285 0x0183D102, 0x00E20124, 0x037003EE, 0x01A00005, 0x036003EE,
1286 0x01A0910F, 0x00B3C20F, 0x00E2012F, 0x01A3D502, 0x00E20116,
1287 0x01A3C002, 0x00E20116, 0x00B3D702, 0x00E4012C, 0x00300000,
1288 0x00EE011F, 0x02C18605, 0x00100006, 0x00EE0116, 0x01A3D1F0,
1289 0x00E40083, 0x037003EE, 0x01A3C004, 0x00E20088, 0x00200003,
1290 0x036003EE, 0x01A3D502, 0x00E20136, 0x00230001, 0x00B3C101,
1291 0x00E4012C, 0x00100006, 0x02C18605, 0x00100006, 0x00204000,
1292 0x00EE0116, 0x00100006, 0x01A3D1F0, 0x00E40083, 0x01000000,
1293 0x02400000, ~0
1294 };
1295  
1296 DPRINTK("ENTER: mode:%d, force:%d\n", mode, force);
1297  
1298 if (force)
1299 previous_mode = UNKNOWN_MODE;
1300 else
1301 previous_mode = host_priv->current_ucode;
1302  
1303 if (mode == previous_mode)
1304 return;
1305  
1306 host_priv->current_ucode = mode;
1307  
1308 /* decide what needs to be done using the STD in my logbook */
1309 switch (previous_mode) {
1310 case OXNASSATA_RAID1:
1311 switch (mode) {
1312 case OXNASSATA_RAID0:
1313 changeparameters = 1;
1314 break;
1315 case OXNASSATA_NOTRAID:
1316 changeparameters = 1;
1317 progmicrocode = 1;
1318 break;
1319 }
1320 break;
1321 case OXNASSATA_RAID0:
1322 switch (mode) {
1323 case OXNASSATA_RAID1:
1324 changeparameters = 1;
1325 break;
1326 case OXNASSATA_NOTRAID:
1327 changeparameters = 1;
1328 progmicrocode = 1;
1329 break;
1330 }
1331 break;
1332 case OXNASSATA_NOTRAID:
1333 switch (mode) {
1334 case OXNASSATA_RAID0:
1335 case OXNASSATA_RAID1:
1336 changeparameters = 1;
1337 progmicrocode = 1;
1338 break;
1339 }
1340 break;
1341 case UNKNOWN_MODE:
1342 changeparameters = 1;
1343 progmicrocode = 1;
1344 break;
1345 }
1346  
1347 /* no need to reprogram everything if already in the right mode */
1348 if (progmicrocode) {
1349 /* reset micro-code processor */
1350 iowrite32(1, core_base + PROC_RESET);
1351 wmb();
1352  
1353 /* select micro-code */
1354 switch (mode) {
1355 case OXNASSATA_RAID1:
1356 case OXNASSATA_RAID0:
1357 VPRINTK("Loading RAID micro-code\n");
1358 src = (unsigned int *)&raid[1];
1359 break;
1360 case OXNASSATA_NOTRAID:
1361 VPRINTK("Loading JBOD micro-code\n");
1362 src = (unsigned int *)&jbod[1];
1363 break;
1364 default:
1365 BUG();
1366 break;
1367 }
1368  
1369 /* load micro code */
1370 dst = core_base + UCODE_STORE;
1371 while (*src != ~0) {
1372 iowrite32(*src, dst);
1373 src++;
1374 dst += sizeof(*src);
1375 }
1376 wmb();
1377 }
1378  
1379 if (changeparameters) {
1380 u32 reg;
1381 /* set other mode dependent flags */
1382 switch (mode) {
1383 case OXNASSATA_RAID1:
1384 /* clear JBOD mode */
1385 reg = ioread32(core_base + DATA_PLANE_CTRL);
1386 reg |= DPC_JBOD_UCODE;
1387 reg &= ~DPC_FIS_SWCH;
1388 iowrite32(reg, core_base + DATA_PLANE_CTRL);
1389 wmb();
1390  
1391 /* set the hardware up for RAID-1 */
1392 iowrite32(0, core_base + RAID_WP_BOT_LOW);
1393 iowrite32(0, core_base + RAID_WP_BOT_HIGH);
1394 iowrite32(0xffffffff, core_base + RAID_WP_TOP_LOW);
1395 iowrite32(0x7fffffff, core_base + RAID_WP_TOP_HIGH);
1396 iowrite32(0, core_base + RAID_SIZE_LOW);
1397 iowrite32(0, core_base + RAID_SIZE_HIGH);
1398 wmb();
1399 break;
1400 case OXNASSATA_RAID0:
1401 /* clear JBOD mode */
1402 reg = ioread32(core_base + DATA_PLANE_CTRL);
1403 reg |= DPC_JBOD_UCODE;
1404 reg &= ~DPC_FIS_SWCH;
1405 iowrite32(reg, core_base + DATA_PLANE_CTRL);
1406 wmb();
1407  
1408 /* set the hardware up for RAID-1 */
1409 iowrite32(0, core_base + RAID_WP_BOT_LOW);
1410 iowrite32(0, core_base + RAID_WP_BOT_HIGH);
1411 iowrite32(0xffffffff, core_base + RAID_WP_TOP_LOW);
1412 iowrite32(0x7fffffff, core_base + RAID_WP_TOP_HIGH);
1413 iowrite32(0xffffffff, core_base + RAID_SIZE_LOW);
1414 iowrite32(0x7fffffff, core_base + RAID_SIZE_HIGH);
1415 wmb();
1416 break;
1417 case OXNASSATA_NOTRAID:
1418 /* enable jbod mode */
1419 reg = ioread32(core_base + DATA_PLANE_CTRL);
1420 reg &= ~DPC_JBOD_UCODE;
1421 reg &= ~DPC_FIS_SWCH;
1422 iowrite32(reg, core_base + DATA_PLANE_CTRL);
1423 wmb();
1424  
1425 /* start micro-code processor*/
1426 iowrite32(1, core_base + PROC_START);
1427 break;
1428 default:
1429 reg = ioread32(core_base + DATA_PLANE_CTRL);
1430 reg |= DPC_JBOD_UCODE;
1431 reg &= ~DPC_FIS_SWCH;
1432 iowrite32(reg, core_base + DATA_PLANE_CTRL);
1433 wmb();
1434 break;
1435 }
1436 }
1437 }
1438  
1439 /**
1440 * sends a sync-escape if there is a link present
1441 */
1442 static inline void sata_oxnas_send_sync_escape(struct ata_port *ap)
1443 {
1444 struct sata_oxnas_port_priv *pd = ap->private_data;
1445 u32 reg;
1446  
1447 /* read the SSTATUS register and only send a sync escape if there is a
1448 * link active */
1449 if ((sata_oxnas_link_read(ap, 0x20) & 3) == 3) {
1450 reg = ioread32(pd->port_base + SATA_COMMAND);
1451 reg &= ~SATA_OPCODE_MASK;
1452 reg |= CMD_SYNC_ESCAPE;
1453 iowrite32(reg, pd->port_base + SATA_COMMAND);
1454 }
1455 }
1456  
1457 /* clears errors */
1458 static inline void sata_oxnas_clear_CS_error(struct ata_port *ap)
1459 {
1460 struct sata_oxnas_port_priv *pd = ap->private_data;
1461 u32 *base = pd->port_base;
1462 u32 reg;
1463  
1464 reg = ioread32(base + SATA_CONTROL);
1465 reg &= SATA_CTL_ERR_MASK;
1466 iowrite32(reg, base + SATA_CONTROL);
1467 }
1468  
1469 static inline void sata_oxnas_reset_sgdma(struct ata_port *ap)
1470 {
1471 struct sata_oxnas_port_priv *pd = ap->private_data;
1472  
1473 iowrite32(SGDMA_RESETS_CTRL, pd->sgdma_base + SGDMA_RESETS);
1474 }
1475  
1476 static inline void sata_oxnas_reset_dma(struct ata_port *ap, int assert)
1477 {
1478 struct sata_oxnas_port_priv *pd = ap->private_data;
1479 u32 reg;
1480  
1481 reg = ioread32(pd->dmactl_base + DMA_CONTROL);
1482 if (assert)
1483 reg |= DMA_CONTROL_RESET;
1484 else
1485 reg &= ~DMA_CONTROL_RESET;
1486  
1487 iowrite32(reg, pd->dmactl_base + DMA_CONTROL);
1488 };
1489  
1490 /**
1491 * Clears the error caused by the core's registers being accessed when the
1492 * core is busy.
1493 */
1494 static inline void sata_oxnas_clear_reg_access_error(struct ata_port *ap)
1495 {
1496 struct sata_oxnas_port_priv *pd = ap->private_data;
1497 u32 *base = pd->port_base;
1498 u32 reg;
1499  
1500 reg = ioread32(base + INT_STATUS);
1501  
1502 DPRINTK("ENTER\n");
1503 if (reg & INT_REG_ACCESS_ERR) {
1504 DPRINTK("clearing register access error on port %d\n",
1505 ap->port_no);
1506 iowrite32(INT_REG_ACCESS_ERR, base + INT_STATUS);
1507 }
1508 reg = ioread32(base + INT_STATUS);
1509 if (reg & INT_REG_ACCESS_ERR)
1510 DPRINTK("register access error didn't clear\n");
1511 }
1512  
1513 static inline void sata_oxnas_clear_sctl_error(struct ata_port *ap)
1514 {
1515 struct sata_oxnas_port_priv *pd = ap->private_data;
1516 u32 *base = pd->port_base;
1517 u32 reg;
1518  
1519 reg = ioread32(base + SATA_CONTROL);
1520 reg |= SCTL_CLR_ERR;
1521 iowrite32(reg, base + SATA_CONTROL);
1522 }
1523  
1524 static inline void sata_oxnas_clear_raid_error(struct ata_host *ah)
1525 {
1526 return;
1527 };
1528  
1529 /**
1530 * Clean up all the state machines in the sata core.
1531 * @return post cleanup action required
1532 */
1533 static int sata_oxnas_cleanup(struct ata_host *ah)
1534 {
1535 struct sata_oxnas_host_priv *hd = ah->private_data;
1536 int actions_required = 0;
1537 int n;
1538  
1539 printk(KERN_INFO "sata_oxnas: resetting SATA core\n");
1540 /* core not recovering, reset it */
1541 mdelay(5);
1542 sata_oxnas_reset_core(ah);
1543 mdelay(5);
1544 actions_required |= OXNAS_SATA_REINIT;
1545 /* Perform any SATA core re-initialisation after reset post reset init
1546 * needs to be called for both ports as there's one reset for both
1547 * ports */
1548 for (n = 0; n < hd->n_ports; n++)
1549 sata_oxnas_post_reset_init(ah->ports[n]);
1550  
1551  
1552 return actions_required;
1553 }
1554  
1555 /**
1556 * ata_qc_new - Request an available ATA command, for queueing
1557 * @ap: Port associated with device @dev
1558 * @return non zero will refuse a new command, zero will may grant on subject
1559 * to conditions elsewhere.
1560 *
1561 */
1562 static int sata_oxnas_qc_new(struct ata_port *ap)
1563 {
1564 struct sata_oxnas_host_priv *hd = ap->host->private_data;
1565  
1566 DPRINTK("port %d\n", ap->port_no);
1567 smp_rmb();
1568 if (hd->port_frozen || hd->port_in_eh)
1569 return 1;
1570 else
1571 return !sata_oxnas_acquire_hw(ap, 0, 0);
1572 }
1573  
1574 /**
1575 * releases the lock on the port the command used
1576 */
1577 static void sata_oxnas_qc_free(struct ata_queued_cmd *qc)
1578 {
1579 DPRINTK("\n");
1580 sata_oxnas_release_hw(qc->ap);
1581 }
1582  
1583 static void sata_oxnas_freeze(struct ata_port *ap)
1584 {
1585 struct sata_oxnas_host_priv *hd = ap->host->private_data;
1586  
1587 DPRINTK("\n");
1588 hd->port_frozen |= BIT(ap->port_no);
1589 smp_wmb();
1590 }
1591  
1592 static void sata_oxnas_thaw(struct ata_port *ap)
1593 {
1594 struct sata_oxnas_host_priv *hd = ap->host->private_data;
1595  
1596 DPRINTK("\n");
1597 hd->port_frozen &= ~BIT(ap->port_no);
1598 smp_wmb();
1599 }
1600  
1601 void sata_oxnas_freeze_host(struct ata_port *ap)
1602 {
1603 struct sata_oxnas_host_priv *hd = ap->host->private_data;
1604  
1605 DPRINTK("ENTER\n");
1606 hd->port_in_eh |= BIT(ap->port_no);
1607 smp_wmb();
1608 }
1609  
1610 void sata_oxnas_thaw_host(struct ata_port *ap)
1611 {
1612 struct sata_oxnas_host_priv *hd = ap->host->private_data;
1613  
1614 DPRINTK("ENTER\n");
1615 hd->port_in_eh &= ~BIT(ap->port_no);
1616 smp_wmb();
1617 }
1618  
1619 static void sata_oxnas_post_internal_cmd(struct ata_queued_cmd *qc)
1620 {
1621 DPRINTK("ENTER\n");
1622 /* If the core is busy here, make it idle */
1623 if (qc->flags & ATA_QCFLAG_FAILED)
1624 sata_oxnas_cleanup(qc->ap->host);
1625 }
1626  
1627  
1628 /**
1629 * turn on the interrupts
1630 *
1631 * @param ap Hardware with the registers in
1632 */
1633 static void sata_oxnas_irq_on(struct ata_port *ap)
1634 {
1635 struct sata_oxnas_port_priv *pd = ap->private_data;
1636 u32 mask = (COREINT_END << ap->port_no);
1637  
1638 /* Clear pending interrupts */
1639 iowrite32(~0, pd->port_base + INT_CLEAR);
1640 iowrite32(mask, pd->core_base + CORE_INT_STATUS);
1641 wmb();
1642  
1643 /* enable End of command interrupt */
1644 iowrite32(INT_WANT, pd->port_base + INT_ENABLE);
1645 iowrite32(mask, pd->core_base + CORE_INT_ENABLE);
1646 }
1647  
1648  
1649 /** @return true if the port has a cable connected */
1650 int sata_oxnas_check_link(struct ata_port *ap)
1651 {
1652 int reg;
1653  
1654 sata_oxnas_scr_read_port(ap, SCR_STATUS, &reg);
1655 /* Check for the cable present indicated by SCR status bit-0 set */
1656 return reg & 0x1;
1657 }
1658  
1659 /**
1660 * ata_std_postreset - standard postreset callback
1661 * @link: the target ata_link
1662 * @classes: classes of attached devices
1663 *
1664 * This function is invoked after a successful reset. Note that
1665 * the device might have been reset more than once using
1666 * different reset methods before postreset is invoked.
1667 *
1668 * LOCKING:
1669 * Kernel thread context (may sleep)
1670 */
1671 static void sata_oxnas_postreset(struct ata_link *link, unsigned int *classes)
1672 {
1673 struct ata_port *ap = link->ap;
1674 struct sata_oxnas_host_priv *hd = ap->host->private_data;
1675  
1676 unsigned int dev;
1677  
1678 DPRINTK("ENTER\n");
1679 ata_std_postreset(link, classes);
1680  
1681 /* turn on phy error detection by removing the masks */
1682 sata_oxnas_link_write(ap->host->ports[0], 0x0c, 0x30003);
1683 if (hd->n_ports > 1)
1684 sata_oxnas_link_write(ap->host->ports[1], 0x0c, 0x30003);
1685  
1686 /* bail out if no device is present */
1687 if (classes[0] == ATA_DEV_NONE && classes[1] == ATA_DEV_NONE) {
1688 DPRINTK("EXIT, no device\n");
1689 return;
1690 }
1691  
1692 /* go through all the devices and configure them */
1693 for (dev = 0; dev < ATA_MAX_DEVICES; ++dev) {
1694 if (ap->link.device[dev].class == ATA_DEV_ATA)
1695 sata_oxnas_dev_config(&(ap->link.device[dev]));
1696 }
1697  
1698 DPRINTK("EXIT\n");
1699 }
1700  
1701 /**
1702 * Called to read the hardware registers / DMA buffers, to
1703 * obtain the current set of taskfile register values.
1704 * @param ap hardware with the registers in
1705 * @param tf taskfile to read the registers into
1706 */
1707 static void sata_oxnas_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
1708 {
1709 struct sata_oxnas_port_priv *port_priv = ap->private_data;
1710 void __iomem *port_base = port_priv->port_base;
1711 /* read the orb registers */
1712 u32 Orb1 = ioread32(port_base + ORB1);
1713 u32 Orb2 = ioread32(port_base + ORB2);
1714 u32 Orb3 = ioread32(port_base + ORB3);
1715 u32 Orb4 = ioread32(port_base + ORB4);
1716  
1717 /* read common 28/48 bit tf parameters */
1718 tf->device = (Orb1 >> 24);
1719 tf->nsect = (Orb2 >> 0);
1720 tf->feature = (Orb2 >> 16);
1721 tf->command = sata_oxnas_check_status(ap);
1722  
1723 /* read 48 or 28 bit tf parameters */
1724 if (tf->flags & ATA_TFLAG_LBA48) {
1725 tf->hob_nsect = (Orb2 >> 8);
1726 tf->lbal = (Orb3 >> 0);
1727 tf->lbam = (Orb3 >> 8);
1728 tf->lbah = (Orb3 >> 16);
1729 tf->hob_lbal = (Orb3 >> 24);
1730 tf->hob_lbam = (Orb4 >> 0);
1731 tf->hob_lbah = (Orb4 >> 8);
1732 /* feature ext and control are write only */
1733 } else {
1734 /* read 28-bit lba */
1735 tf->lbal = (Orb3 >> 0);
1736 tf->lbam = (Orb3 >> 8);
1737 tf->lbah = (Orb3 >> 16);
1738 }
1739 }
1740  
1741 /**
1742 * Read a result task-file from the sata core registers.
1743 */
1744 static bool sata_oxnas_qc_fill_rtf(struct ata_queued_cmd *qc)
1745 {
1746 /* Read the most recently received FIS from the SATA core ORB registers
1747 and convert to an ATA taskfile */
1748 sata_oxnas_tf_read(qc->ap, &qc->result_tf);
1749 return true;
1750 }
1751  
1752 /**
1753 * Reads the Status ATA shadow register from hardware.
1754 *
1755 * @return The status register
1756 */
1757 static u8 sata_oxnas_check_status(struct ata_port *ap)
1758 {
1759 u32 Reg;
1760 u8 status;
1761 struct sata_oxnas_port_priv *port_priv = ap->private_data;
1762 void __iomem *port_base = port_priv->port_base;
1763  
1764 /* read byte 3 of Orb2 register */
1765 status = ioread32(port_base + ORB2) >> 24;
1766  
1767 /* check for the drive going missing indicated by SCR status bits
1768 * 0-3 = 0 */
1769 sata_oxnas_scr_read_port(ap, SCR_STATUS, &Reg);
1770  
1771 if (!(Reg & 0x1)) {
1772 status |= ATA_DF;
1773 status |= ATA_ERR;
1774 }
1775  
1776 return status;
1777 }
1778  
1779 static inline void sata_oxnas_reset_ucode(struct ata_host *ah, int force,
1780 int no_microcode)
1781 {
1782 struct sata_oxnas_host_priv *hd = ah->private_data;
1783  
1784 DPRINTK("ENTER\n");
1785 if (no_microcode) {
1786 u32 reg;
1787  
1788 sata_oxnas_set_mode(ah, UNKNOWN_MODE, force);
1789 reg = ioread32(hd->core_base + DEVICE_CONTROL);
1790 reg |= DEVICE_CONTROL_ATA_ERR_OVERRIDE;
1791 iowrite32(reg, hd->core_base + DEVICE_CONTROL);
1792 } else {
1793 /* JBOD uCode */
1794 sata_oxnas_set_mode(ah, OXNASSATA_NOTRAID, force);
1795 /* Turn the work around off as it may have been left on by any
1796 * HW-RAID code that we've been working with */
1797 iowrite32(0x0, hd->core_base + PORT_ERROR_MASK);
1798 }
1799 }
1800  
1801 /**
1802 * Prepare as much as possible for a command without involving anything that is
1803 * shared between ports.
1804 */
1805 static void sata_oxnas_qc_prep(struct ata_queued_cmd *qc)
1806 {
1807 struct sata_oxnas_port_priv *pd;
1808 int port_no = qc->ap->port_no;
1809  
1810 /* if the port's not connected, complete now with an error */
1811 if (!sata_oxnas_check_link(qc->ap)) {
1812 ata_port_err(qc->ap,
1813 "port %d not connected completing with error\n",
1814 port_no);
1815 qc->err_mask |= AC_ERR_ATA_BUS;
1816 ata_qc_complete(qc);
1817 }
1818  
1819 sata_oxnas_reset_ucode(qc->ap->host, 0, 0);
1820  
1821 /* both pio and dma commands use dma */
1822 if (ata_is_dma(qc->tf.protocol) || ata_is_pio(qc->tf.protocol)) {
1823  
1824 /* program the scatterlist into the prd table */
1825 ata_bmdma_qc_prep(qc);
1826  
1827 /* point the sgdma controller at the dma request structure */
1828 pd = qc->ap->private_data;
1829  
1830 iowrite32(pd->sgdma_request_pa,
1831 pd->sgdma_base + SGDMA_REQUESTPTR);
1832  
1833 /* setup the request table */
1834 if (port_no == 0) {
1835 pd->sgdma_request->control =
1836 (qc->dma_dir == DMA_FROM_DEVICE) ?
1837 SGDMA_REQCTL0IN : SGDMA_REQCTL0OUT;
1838 } else {
1839 pd->sgdma_request->control =
1840 (qc->dma_dir == DMA_FROM_DEVICE) ?
1841 SGDMA_REQCTL1IN : SGDMA_REQCTL1OUT;
1842 }
1843 pd->sgdma_request->qualifier = SGDMA_REQQUAL;
1844 pd->sgdma_request->src_pa = qc->ap->bmdma_prd_dma;
1845 pd->sgdma_request->dst_pa = qc->ap->bmdma_prd_dma;
1846 smp_wmb();
1847  
1848 /* tell it to wait */
1849 iowrite32(SGDMA_CONTROL_NOGO, pd->sgdma_base + SGDMA_CONTROL);
1850 }
1851 }
1852  
1853 static int sata_oxnas_port_start(struct ata_port *ap)
1854 {
1855 struct sata_oxnas_host_priv *host_priv = ap->host->private_data;
1856 struct device *dev = ap->host->dev;
1857 struct sata_oxnas_port_priv *pp;
1858 void *mem;
1859 dma_addr_t mem_dma;
1860  
1861 DPRINTK("ENTER\n");
1862  
1863 pp = kzalloc(sizeof(*pp), GFP_KERNEL);
1864 if (!pp)
1865 return -ENOMEM;
1866  
1867 pp->port_base = host_priv->port_base +
1868 (ap->port_no ? PORT_SIZE : 0);
1869 pp->dmactl_base = host_priv->dmactl_base +
1870 (ap->port_no ? DMA_CORESIZE : 0);
1871 pp->sgdma_base = host_priv->sgdma_base +
1872 (ap->port_no ? SGDMA_CORESIZE : 0);
1873 pp->core_base = host_priv->core_base;
1874  
1875 /* preallocated */
1876 if (host_priv->dma_size >= SATA_OXNAS_DMA_SIZE * host_priv->n_ports) {
1877 DPRINTK("using preallocated DMA\n");
1878 mem_dma = host_priv->dma_base +
1879 (ap->port_no ? SATA_OXNAS_DMA_SIZE : 0);
1880 mem = ioremap(mem_dma, SATA_OXNAS_DMA_SIZE);
1881 } else {
1882 mem = dma_alloc_coherent(dev, SATA_OXNAS_DMA_SIZE, &mem_dma,
1883 GFP_KERNEL);
1884 }
1885 if (!mem)
1886 goto err_ret;
1887  
1888 pp->sgdma_request_pa = mem_dma;
1889 pp->sgdma_request = mem;
1890  
1891 ap->bmdma_prd_dma = mem_dma + sizeof(struct sgdma_request);
1892 ap->bmdma_prd = mem + sizeof(struct sgdma_request);
1893  
1894 ap->private_data = pp;
1895  
1896 sata_oxnas_post_reset_init(ap);
1897  
1898 return 0;
1899  
1900 err_ret:
1901 kfree(pp);
1902 return -ENOMEM;
1903  
1904 }
1905  
1906 static void sata_oxnas_port_stop(struct ata_port *ap)
1907 {
1908 struct device *dev = ap->host->dev;
1909 struct sata_oxnas_port_priv *pp = ap->private_data;
1910 struct sata_oxnas_host_priv *host_priv = ap->host->private_data;
1911  
1912 DPRINTK("ENTER\n");
1913 ap->private_data = NULL;
1914 if (host_priv->dma_size) {
1915 iounmap(pp->sgdma_request);
1916 } else {
1917 dma_free_coherent(dev, SATA_OXNAS_DMA_SIZE,
1918 pp->sgdma_request, pp->sgdma_request_pa);
1919 }
1920  
1921 kfree(pp);
1922 }
1923  
1924  
1925 static void sata_oxnas_post_reset_init(struct ata_port *ap)
1926 {
1927 uint dev;
1928  
1929 /* force to load u-code only once after reset */
1930 sata_oxnas_reset_ucode(ap->host, !ap->port_no, 0);
1931  
1932 /* turn on phy error detection by removing the masks */
1933 sata_oxnas_link_write(ap, 0x0C, 0x30003);
1934  
1935 /* enable hotplug event detection */
1936 sata_oxnas_scr_write_port(ap, SCR_ERROR, ~0);
1937 sata_oxnas_scr_write_port(ap, SERROR_IRQ_MASK, 0x03feffff);
1938 sata_oxnas_scr_write_port(ap, SCR_ACTIVE, ~0 & ~(1 << 26) & ~(1 << 16));
1939  
1940 /* enable interrupts for ports */
1941 sata_oxnas_irq_on(ap);
1942  
1943 /* go through all the devices and configure them */
1944 for (dev = 0; dev < ATA_MAX_DEVICES; ++dev) {
1945 if (ap->link.device[dev].class == ATA_DEV_ATA) {
1946 sata_std_hardreset(&ap->link, NULL, jiffies + HZ);
1947 sata_oxnas_dev_config(&(ap->link.device[dev]));
1948 }
1949 }
1950  
1951 /* clean up any remaining errors */
1952 sata_oxnas_scr_write_port(ap, SCR_ERROR, ~0);
1953 VPRINTK("done\n");
1954 }
1955  
1956 /**
1957 * host_stop() is called when the rmmod or hot unplug process begins. The
1958 * hook must stop all hardware interrupts, DMA engines, etc.
1959 *
1960 * @param ap hardware with the registers in
1961 */
1962 static void sata_oxnas_host_stop(struct ata_host *host_set)
1963 {
1964 DPRINTK("\n");
1965 }
1966  
1967  
1968 #define ERROR_HW_ACQUIRE_TIMEOUT_JIFFIES (10 * HZ)
1969 static void sata_oxnas_error_handler(struct ata_port *ap)
1970 {
1971 DPRINTK("Enter port_no %d\n", ap->port_no);
1972 sata_oxnas_freeze_host(ap);
1973  
1974 /* If the core is busy here, make it idle */
1975 sata_oxnas_cleanup(ap->host);
1976  
1977 ata_std_error_handler(ap);
1978  
1979 sata_oxnas_thaw_host(ap);
1980 }
1981  
1982 static int sata_oxnas_softreset(struct ata_link *link, unsigned int *class,
1983 unsigned long deadline)
1984 {
1985 struct ata_port *ap = link->ap;
1986 struct sata_oxnas_port_priv *pd = ap->private_data;
1987 void __iomem *port_base = pd->port_base;
1988 int rc;
1989  
1990 struct ata_taskfile tf;
1991 u32 Command_Reg;
1992  
1993 DPRINTK("ENTER\n");
1994  
1995 port_base = pd->port_base;
1996  
1997 if (ata_link_offline(link)) {
1998 DPRINTK("PHY reports no device\n");
1999 *class = ATA_DEV_NONE;
2000 goto out;
2001 }
2002  
2003 /* write value to register */
2004 iowrite32(0, port_base + ORB1);
2005 iowrite32(0, port_base + ORB2);
2006 iowrite32(0, port_base + ORB3);
2007 iowrite32((ap->ctl) << 24, port_base + ORB4);
2008  
2009 /* command the core to send a control FIS */
2010 Command_Reg = ioread32(port_base + SATA_COMMAND);
2011 Command_Reg &= ~SATA_OPCODE_MASK;
2012 Command_Reg |= CMD_WRITE_TO_ORB_REGS_NO_COMMAND;
2013 iowrite32(Command_Reg, port_base + SATA_COMMAND);
2014 udelay(20); /* FIXME: flush */
2015  
2016 /* write value to register */
2017 iowrite32((ap->ctl | ATA_SRST) << 24, port_base + ORB4);
2018  
2019 /* command the core to send a control FIS */
2020 Command_Reg &= ~SATA_OPCODE_MASK;
2021 Command_Reg |= CMD_WRITE_TO_ORB_REGS_NO_COMMAND;
2022 iowrite32(Command_Reg, port_base + SATA_COMMAND);
2023 udelay(20); /* FIXME: flush */
2024  
2025 /* write value to register */
2026 iowrite32((ap->ctl) << 24, port_base + ORB4);
2027  
2028 /* command the core to send a control FIS */
2029 Command_Reg &= ~SATA_OPCODE_MASK;
2030 Command_Reg |= CMD_WRITE_TO_ORB_REGS_NO_COMMAND;
2031 iowrite32(Command_Reg, port_base + SATA_COMMAND);
2032  
2033 msleep(150);
2034  
2035 rc = ata_sff_wait_ready(link, deadline);
2036  
2037 /* if link is occupied, -ENODEV too is an error */
2038 if (rc && (rc != -ENODEV || sata_scr_valid(link))) {
2039 ata_link_printk(link, KERN_ERR, "SRST failed (errno=%d)\n", rc);
2040 return rc;
2041 }
2042  
2043 /* determine by signature whether we have ATA or ATAPI devices */
2044 sata_oxnas_tf_read(ap, &tf);
2045 *class = ata_dev_classify(&tf);
2046  
2047 if (*class == ATA_DEV_UNKNOWN)
2048 *class = ATA_DEV_NONE;
2049  
2050 out:
2051 DPRINTK("EXIT, class=%u\n", *class);
2052 return 0;
2053 }
2054  
2055  
2056 int sata_oxnas_init_controller(struct ata_host *host)
2057 {
2058 return 0;
2059 }
2060  
2061 /**
2062 * Ref bug-6320
2063 *
2064 * This code is a work around for a DMA hardware bug that will repeat the
2065 * penultimate 8-bytes on some reads. This code will check that the amount
2066 * of data transferred is a multiple of 512 bytes, if not the in it will
2067 * fetch the correct data from a buffer in the SATA core and copy it into
2068 * memory.
2069 *
2070 * @param port SATA port to check and if necessary, correct.
2071 */
2072 static int sata_oxnas_bug_6320_detect(struct ata_port *ap)
2073 {
2074 struct sata_oxnas_port_priv *pd = ap->private_data;
2075 void __iomem *core_base = pd->core_base;
2076 int is_read;
2077 int quads_transferred;
2078 int remainder;
2079 int sector_quads_remaining;
2080 int bug_present = 0;
2081  
2082 /* Only want to apply fix to reads */
2083 is_read = !(ioread32(core_base + DM_DBG1) & (ap->port_no ?
2084 BIT(CORE_PORT1_DATA_DIR_BIT) :
2085 BIT(CORE_PORT0_DATA_DIR_BIT)));
2086  
2087 /* Check for an incomplete transfer, i.e. not a multiple of 512 bytes
2088 transferred (datacount_port register counts quads transferred) */
2089 quads_transferred =
2090 ioread32(core_base + (ap->port_no ?
2091 DATACOUNT_PORT1 : DATACOUNT_PORT0));
2092  
2093 remainder = quads_transferred & 0x7f;
2094 sector_quads_remaining = remainder ? (0x80 - remainder) : 0;
2095  
2096 if (is_read && (sector_quads_remaining == 2)) {
2097 bug_present = 1;
2098 } else if (sector_quads_remaining) {
2099 if (is_read) {
2100 ata_port_warn(ap, "SATA read fixup cannot deal with "
2101 "%d quads remaining\n",
2102 sector_quads_remaining);
2103 } else {
2104 ata_port_warn(ap, "SATA write fixup of %d quads "
2105 "remaining not supported\n",
2106 sector_quads_remaining);
2107 }
2108 }
2109  
2110 return bug_present;
2111 }
2112  
2113 /* This port done an interrupt */
2114 static void sata_oxnas_port_irq(struct ata_port *ap, int force_error)
2115 {
2116 struct ata_queued_cmd *qc;
2117 struct sata_oxnas_port_priv *pd = ap->private_data;
2118 void __iomem *port_base = pd->port_base;
2119  
2120 u32 int_status;
2121 unsigned long flags = 0;
2122  
2123 DPRINTK("ENTER port %d irqstatus %x\n", ap->port_no,
2124 ioread32(port_base + INT_STATUS));
2125  
2126 if (ap->qc_active & (1 << ATA_TAG_INTERNAL)) {
2127 qc = ata_qc_from_tag(ap, ATA_TAG_INTERNAL);
2128 DPRINTK("completing non-ncq cmd\n");
2129  
2130 if (qc)
2131 ata_qc_complete(qc);
2132  
2133 return;
2134 }
2135  
2136 qc = ata_qc_from_tag(ap, ap->link.active_tag);
2137  
2138  
2139 /* record the port's interrupt */
2140 int_status = ioread32(port_base + INT_STATUS);
2141  
2142 /* If there's no command associated with this IRQ, ignore it. We may get
2143 * spurious interrupts when cleaning-up after a failed command, ignore
2144 * these too. */
2145 if (likely(qc)) {
2146 /* get the status before any error cleanup */
2147 qc->err_mask = ac_err_mask(sata_oxnas_check_status(ap));
2148 if (force_error) {
2149 /* Pretend there has been a link error */
2150 qc->err_mask |= AC_ERR_ATA_BUS;
2151 DPRINTK(" ####force error####\n");
2152 }
2153 /* tell libata we're done */
2154 local_irq_save(flags);
2155 sata_oxnas_irq_clear(ap);
2156 local_irq_restore(flags);
2157 ata_qc_complete(qc);
2158 } else {
2159 VPRINTK("Ignoring interrupt, can't find the command tag="
2160 "%d %08x\n", ap->link.active_tag, ap->qc_active);
2161 }
2162  
2163 /* maybe a hotplug event */
2164 if (unlikely(int_status & INT_LINK_SERROR)) {
2165 u32 serror;
2166  
2167 sata_oxnas_scr_read_port(ap, SCR_ERROR, &serror);
2168 if (serror & (SERR_DEV_XCHG | SERR_PHYRDY_CHG)) {
2169 ata_ehi_hotplugged(&ap->link.eh_info);
2170 ata_port_freeze(ap);
2171 }
2172 }
2173 }
2174  
2175 /**
2176 * irq_handler is the interrupt handling routine registered with the system,
2177 * by libata.
2178 */
2179 static irqreturn_t sata_oxnas_interrupt(int irq, void *dev_instance)
2180 {
2181 struct ata_host *ah = dev_instance;
2182 struct sata_oxnas_host_priv *hd = ah->private_data;
2183 void __iomem *core_base = hd->core_base;
2184  
2185 u32 int_status;
2186 irqreturn_t ret = IRQ_NONE;
2187 u32 port_no;
2188 u32 mask;
2189 int bug_present;
2190  
2191 /* loop until there are no more interrupts */
2192 while ((int_status = (ioread32(core_base + CORE_INT_STATUS)) &
2193 (COREINT_END | (COREINT_END << 1)))) {
2194  
2195 /* clear any interrupt */
2196 iowrite32(int_status, core_base + CORE_INT_CLEAR);
2197  
2198 /* Only need workaround_bug_6320 for single disk systems as dual
2199 * disk will use uCode which prevents this read underrun problem
2200 * from occurring.
2201 * All single disk systems will use port 0 */
2202 for (port_no = 0; port_no < hd->n_ports; ++port_no) {
2203 /* check the raw end of command interrupt to see if the
2204 * port is done */
2205 mask = (COREINT_END << port_no);
2206 if (!(int_status & mask))
2207 continue;
2208  
2209 /* this port had an interrupt, clear it */
2210 iowrite32(mask, core_base + CORE_INT_CLEAR);
2211 /* check for bug 6320 only if no microcode was loaded */
2212 bug_present = (hd->current_ucode == UNKNOWN_MODE) &&
2213 sata_oxnas_bug_6320_detect(ah->ports[port_no]);
2214  
2215 sata_oxnas_port_irq(ah->ports[port_no],
2216 bug_present);
2217 ret = IRQ_HANDLED;
2218 }
2219 }
2220  
2221 return ret;
2222 }
2223  
2224 /*
2225 * scsi mid-layer and libata interface structures
2226 */
2227 static struct scsi_host_template sata_oxnas_sht = {
2228 ATA_NCQ_SHT("sata_oxnas"),
2229 .can_queue = SATA_OXNAS_QUEUE_DEPTH,
2230 .sg_tablesize = SATA_OXNAS_MAX_PRD,
2231 .dma_boundary = ATA_DMA_BOUNDARY,
2232 .unchecked_isa_dma = 0,
2233 };
2234  
2235  
2236 static struct ata_port_operations sata_oxnas_ops = {
2237 .inherits = &sata_port_ops,
2238 .qc_prep = sata_oxnas_qc_prep,
2239 .qc_issue = sata_oxnas_qc_issue,
2240 .qc_fill_rtf = sata_oxnas_qc_fill_rtf,
2241 .qc_new = sata_oxnas_qc_new,
2242 .qc_free = sata_oxnas_qc_free,
2243  
2244 .scr_read = sata_oxnas_scr_read,
2245 .scr_write = sata_oxnas_scr_write,
2246  
2247 .freeze = sata_oxnas_freeze,
2248 .thaw = sata_oxnas_thaw,
2249 .softreset = sata_oxnas_softreset,
2250 /* .hardreset = sata_oxnas_hardreset, */
2251 .postreset = sata_oxnas_postreset,
2252 .error_handler = sata_oxnas_error_handler,
2253 .post_internal_cmd = sata_oxnas_post_internal_cmd,
2254  
2255 .port_start = sata_oxnas_port_start,
2256 .port_stop = sata_oxnas_port_stop,
2257  
2258 .host_stop = sata_oxnas_host_stop,
2259 /* .pmp_attach = sata_oxnas_pmp_attach, */
2260 /* .pmp_detach = sata_oxnas_pmp_detach, */
2261 .sff_check_status = sata_oxnas_check_status,
2262 .acquire_hw = sata_oxnas_acquire_hw,
2263 };
2264  
2265 static const struct ata_port_info sata_oxnas_port_info = {
2266 .flags = SATA_OXNAS_HOST_FLAGS,
2267 .pio_mask = ATA_PIO4,
2268 .udma_mask = ATA_UDMA6,
2269 .port_ops = &sata_oxnas_ops,
2270 };
2271  
2272 static int sata_oxnas_probe(struct platform_device *ofdev)
2273 {
2274 int retval = -ENXIO;
2275 int n_ports = 0;
2276 void __iomem *port_base = NULL;
2277 void __iomem *dmactl_base = NULL;
2278 void __iomem *sgdma_base = NULL;
2279 void __iomem *core_base = NULL;
2280 void __iomem *phy_base = NULL;
2281 struct reset_control *rstc;
2282  
2283 struct resource res = {};
2284 struct sata_oxnas_host_priv *host_priv = NULL;
2285 int irq = 0;
2286 struct ata_host *host = NULL;
2287 struct clk *clk = NULL;
2288  
2289 const struct ata_port_info *ppi[] = { &sata_oxnas_port_info, NULL };
2290  
2291 of_property_read_u32(ofdev->dev.of_node, "nr-ports", &n_ports);
2292 if (n_ports < 1 || n_ports > SATA_OXNAS_MAX_PORTS)
2293 goto error_exit_with_cleanup;
2294  
2295 port_base = of_iomap(ofdev->dev.of_node, 0);
2296 if (!port_base)
2297 goto error_exit_with_cleanup;
2298  
2299 dmactl_base = of_iomap(ofdev->dev.of_node, 1);
2300 if (!dmactl_base)
2301 goto error_exit_with_cleanup;
2302  
2303 sgdma_base = of_iomap(ofdev->dev.of_node, 2);
2304 if (!sgdma_base)
2305 goto error_exit_with_cleanup;
2306  
2307 core_base = of_iomap(ofdev->dev.of_node, 3);
2308 if (!core_base)
2309 goto error_exit_with_cleanup;
2310  
2311 phy_base = of_iomap(ofdev->dev.of_node, 4);
2312 if (!phy_base)
2313 goto error_exit_with_cleanup;
2314  
2315 host_priv = devm_kzalloc(&ofdev->dev,
2316 sizeof(struct sata_oxnas_host_priv),
2317 GFP_KERNEL);
2318 if (!host_priv)
2319 goto error_exit_with_cleanup;
2320  
2321 host_priv->port_base = port_base;
2322 host_priv->dmactl_base = dmactl_base;
2323 host_priv->sgdma_base = sgdma_base;
2324 host_priv->core_base = core_base;
2325 host_priv->phy_base = phy_base;
2326 host_priv->n_ports = n_ports;
2327 host_priv->current_ucode = UNKNOWN_MODE;
2328  
2329 if (!of_address_to_resource(ofdev->dev.of_node, 5, &res)) {
2330 host_priv->dma_base = res.start;
2331 host_priv->dma_size = resource_size(&res);
2332 }
2333  
2334 irq = irq_of_parse_and_map(ofdev->dev.of_node, 0);
2335 if (!irq) {
2336 dev_err(&ofdev->dev, "invalid irq from platform\n");
2337 goto error_exit_with_cleanup;
2338 }
2339 host_priv->irq = irq;
2340  
2341 clk = of_clk_get(ofdev->dev.of_node, 0);
2342 if (IS_ERR(clk)) {
2343 retval = PTR_ERR(clk);
2344 clk = NULL;
2345 goto error_exit_with_cleanup;
2346 }
2347 host_priv->clk = clk;
2348  
2349 rstc = devm_reset_control_get(&ofdev->dev, "sata");
2350 if (IS_ERR(rstc)) {
2351 retval = PTR_ERR(rstc);
2352 goto error_exit_with_cleanup;
2353 }
2354 host_priv->rst_sata = rstc;
2355  
2356 rstc = devm_reset_control_get(&ofdev->dev, "link");
2357 if (IS_ERR(rstc)) {
2358 retval = PTR_ERR(rstc);
2359 goto error_exit_with_cleanup;
2360 }
2361 host_priv->rst_link = rstc;
2362  
2363 rstc = devm_reset_control_get(&ofdev->dev, "phy");
2364 if (IS_ERR(rstc)) {
2365 retval = PTR_ERR(rstc);
2366 goto error_exit_with_cleanup;
2367 }
2368 host_priv->rst_phy = rstc;
2369  
2370 /* allocate host structure */
2371 host = ata_host_alloc_pinfo(&ofdev->dev, ppi, n_ports);
2372  
2373 if (!host) {
2374 retval = -ENOMEM;
2375 goto error_exit_with_cleanup;
2376 }
2377 host->private_data = host_priv;
2378 host->iomap = port_base;
2379  
2380 /* initialize core locking and queues */
2381 init_waitqueue_head(&host_priv->fast_wait_queue);
2382 init_waitqueue_head(&host_priv->scsi_wait_queue);
2383 spin_lock_init(&host_priv->phy_lock);
2384 spin_lock_init(&host_priv->core_lock);
2385 host_priv->core_locked = 0;
2386 host_priv->reentrant_port_no = -1;
2387 host_priv->hw_lock_count = 0;
2388 host_priv->direct_lock_count = 0;
2389 host_priv->locker_uid = 0;
2390 host_priv->current_locker_type = SATA_UNLOCKED;
2391 host_priv->isr_arg = NULL;
2392 host_priv->isr_callback = NULL;
2393  
2394 /* initialize host controller */
2395 retval = sata_oxnas_init_controller(host);
2396 if (retval)
2397 goto error_exit_with_cleanup;
2398  
2399 /*
2400 * Now, register with libATA core, this will also initiate the
2401 * device discovery process, invoking our port_start() handler &
2402 * error_handler() to execute a dummy softreset EH session
2403 */
2404 ata_host_activate(host, irq, sata_oxnas_interrupt, SATA_OXNAS_IRQ_FLAG,
2405 &sata_oxnas_sht);
2406  
2407 return 0;
2408  
2409 error_exit_with_cleanup:
2410 if (irq)
2411 irq_dispose_mapping(host_priv->irq);
2412 if (clk)
2413 clk_put(clk);
2414 if (host)
2415 ata_host_detach(host);
2416 if (port_base)
2417 iounmap(port_base);
2418 if (sgdma_base)
2419 iounmap(sgdma_base);
2420 if (core_base)
2421 iounmap(core_base);
2422 if (phy_base)
2423 iounmap(phy_base);
2424 return retval;
2425 }
2426  
2427  
2428 static int sata_oxnas_remove(struct platform_device *ofdev)
2429 {
2430 struct ata_host *host = dev_get_drvdata(&ofdev->dev);
2431 struct sata_oxnas_host_priv *host_priv = host->private_data;
2432  
2433 ata_host_detach(host);
2434  
2435 irq_dispose_mapping(host_priv->irq);
2436 iounmap(host_priv->port_base);
2437 iounmap(host_priv->sgdma_base);
2438 iounmap(host_priv->core_base);
2439  
2440 /* reset Controller, Link and PHY */
2441 reset_control_assert(host_priv->rst_sata);
2442 reset_control_assert(host_priv->rst_link);
2443 reset_control_assert(host_priv->rst_phy);
2444  
2445 /* Disable the clock to the SATA block */
2446 clk_disable_unprepare(host_priv->clk);
2447 clk_put(host_priv->clk);
2448  
2449 return 0;
2450 }
2451  
2452 #ifdef CONFIG_PM
2453 static int sata_oxnas_suspend(struct platform_device *op, pm_message_t state)
2454 {
2455 struct ata_host *host = dev_get_drvdata(&op->dev);
2456  
2457 return ata_host_suspend(host, state);
2458 }
2459  
2460 static int sata_oxnas_resume(struct platform_device *op)
2461 {
2462 struct ata_host *host = dev_get_drvdata(&op->dev);
2463 int ret;
2464  
2465 ret = sata_oxnas_init_controller(host);
2466 if (ret) {
2467 dev_err(&op->dev, "Error initializing hardware\n");
2468 return ret;
2469 }
2470 ata_host_resume(host);
2471 return 0;
2472 }
2473 #endif
2474  
2475  
2476  
2477 static struct of_device_id oxnas_sata_match[] = {
2478 {
2479 .compatible = "plxtech,nas782x-sata",
2480 },
2481 {},
2482 };
2483  
2484 MODULE_DEVICE_TABLE(of, oxnas_sata_match);
2485  
2486 static struct platform_driver oxnas_sata_driver = {
2487 .driver = {
2488 .name = "oxnas-sata",
2489 .owner = THIS_MODULE,
2490 .of_match_table = oxnas_sata_match,
2491 },
2492 .probe = sata_oxnas_probe,
2493 .remove = sata_oxnas_remove,
2494 #ifdef CONFIG_PM
2495 .suspend = sata_oxnas_suspend,
2496 .resume = sata_oxnas_resume,
2497 #endif
2498 };
2499  
2500 module_platform_driver(oxnas_sata_driver);
2501  
2502 MODULE_LICENSE("GPL");
2503 MODULE_VERSION("1.0");
2504 MODULE_AUTHOR("Oxford Semiconductor Ltd.");
2505 MODULE_DESCRIPTION("low-level driver for Oxford 934 SATA core");