1
2
3
4
5
6
7#include "qla_def.h"
8
9#include <linux/blkdev.h>
10#include <linux/delay.h>
11
12#include <scsi/scsi_tcq.h>
13
14static request_t *qla2x00_req_pkt(scsi_qla_host_t *ha);
15static void qla2x00_isp_cmd(scsi_qla_host_t *ha);
16
17
18
19
20
21
22
23static inline uint16_t
24qla2x00_get_cmd_direction(srb_t *sp)
25{
26 uint16_t cflags;
27
28 cflags = 0;
29
30
31 if (sp->cmd->sc_data_direction == DMA_TO_DEVICE) {
32 cflags = CF_WRITE;
33 sp->fcport->ha->qla_stats.output_bytes +=
34 scsi_bufflen(sp->cmd);
35 } else if (sp->cmd->sc_data_direction == DMA_FROM_DEVICE) {
36 cflags = CF_READ;
37 sp->fcport->ha->qla_stats.input_bytes +=
38 scsi_bufflen(sp->cmd);
39 }
40 return (cflags);
41}
42
43
44
45
46
47
48
49
50
51uint16_t
52qla2x00_calc_iocbs_32(uint16_t dsds)
53{
54 uint16_t iocbs;
55
56 iocbs = 1;
57 if (dsds > 3) {
58 iocbs += (dsds - 3) / 7;
59 if ((dsds - 3) % 7)
60 iocbs++;
61 }
62 return (iocbs);
63}
64
65
66
67
68
69
70
71
72
73uint16_t
74qla2x00_calc_iocbs_64(uint16_t dsds)
75{
76 uint16_t iocbs;
77
78 iocbs = 1;
79 if (dsds > 2) {
80 iocbs += (dsds - 2) / 5;
81 if ((dsds - 2) % 5)
82 iocbs++;
83 }
84 return (iocbs);
85}
86
87
88
89
90
91
92
93static inline cont_entry_t *
94qla2x00_prep_cont_type0_iocb(scsi_qla_host_t *ha)
95{
96 cont_entry_t *cont_pkt;
97
98
99 ha->req_ring_index++;
100 if (ha->req_ring_index == ha->request_q_length) {
101 ha->req_ring_index = 0;
102 ha->request_ring_ptr = ha->request_ring;
103 } else {
104 ha->request_ring_ptr++;
105 }
106
107 cont_pkt = (cont_entry_t *)ha->request_ring_ptr;
108
109
110 *((uint32_t *)(&cont_pkt->entry_type)) =
111 __constant_cpu_to_le32(CONTINUE_TYPE);
112
113 return (cont_pkt);
114}
115
116
117
118
119
120
121
122static inline cont_a64_entry_t *
123qla2x00_prep_cont_type1_iocb(scsi_qla_host_t *ha)
124{
125 cont_a64_entry_t *cont_pkt;
126
127
128 ha->req_ring_index++;
129 if (ha->req_ring_index == ha->request_q_length) {
130 ha->req_ring_index = 0;
131 ha->request_ring_ptr = ha->request_ring;
132 } else {
133 ha->request_ring_ptr++;
134 }
135
136 cont_pkt = (cont_a64_entry_t *)ha->request_ring_ptr;
137
138
139 *((uint32_t *)(&cont_pkt->entry_type)) =
140 __constant_cpu_to_le32(CONTINUE_A64_TYPE);
141
142 return (cont_pkt);
143}
144
145
146
147
148
149
150
151
152
153void qla2x00_build_scsi_iocbs_32(srb_t *sp, cmd_entry_t *cmd_pkt,
154 uint16_t tot_dsds)
155{
156 uint16_t avail_dsds;
157 uint32_t *cur_dsd;
158 scsi_qla_host_t *ha;
159 struct scsi_cmnd *cmd;
160 struct scatterlist *sg;
161 int i;
162
163 cmd = sp->cmd;
164
165
166 *((uint32_t *)(&cmd_pkt->entry_type)) =
167 __constant_cpu_to_le32(COMMAND_TYPE);
168
169
170 if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) {
171 cmd_pkt->byte_count = __constant_cpu_to_le32(0);
172 return;
173 }
174
175 ha = sp->ha;
176
177 cmd_pkt->control_flags |= cpu_to_le16(qla2x00_get_cmd_direction(sp));
178
179
180 avail_dsds = 3;
181 cur_dsd = (uint32_t *)&cmd_pkt->dseg_0_address;
182
183
184 scsi_for_each_sg(cmd, sg, tot_dsds, i) {
185 cont_entry_t *cont_pkt;
186
187
188 if (avail_dsds == 0) {
189
190
191
192
193 cont_pkt = qla2x00_prep_cont_type0_iocb(ha);
194 cur_dsd = (uint32_t *)&cont_pkt->dseg_0_address;
195 avail_dsds = 7;
196 }
197
198 *cur_dsd++ = cpu_to_le32(sg_dma_address(sg));
199 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg));
200 avail_dsds--;
201 }
202}
203
204
205
206
207
208
209
210
211
212void qla2x00_build_scsi_iocbs_64(srb_t *sp, cmd_entry_t *cmd_pkt,
213 uint16_t tot_dsds)
214{
215 uint16_t avail_dsds;
216 uint32_t *cur_dsd;
217 scsi_qla_host_t *ha;
218 struct scsi_cmnd *cmd;
219 struct scatterlist *sg;
220 int i;
221
222 cmd = sp->cmd;
223
224
225 *((uint32_t *)(&cmd_pkt->entry_type)) =
226 __constant_cpu_to_le32(COMMAND_A64_TYPE);
227
228
229 if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) {
230 cmd_pkt->byte_count = __constant_cpu_to_le32(0);
231 return;
232 }
233
234 ha = sp->ha;
235
236 cmd_pkt->control_flags |= cpu_to_le16(qla2x00_get_cmd_direction(sp));
237
238
239 avail_dsds = 2;
240 cur_dsd = (uint32_t *)&cmd_pkt->dseg_0_address;
241
242
243 scsi_for_each_sg(cmd, sg, tot_dsds, i) {
244 dma_addr_t sle_dma;
245 cont_a64_entry_t *cont_pkt;
246
247
248 if (avail_dsds == 0) {
249
250
251
252
253 cont_pkt = qla2x00_prep_cont_type1_iocb(ha);
254 cur_dsd = (uint32_t *)cont_pkt->dseg_0_address;
255 avail_dsds = 5;
256 }
257
258 sle_dma = sg_dma_address(sg);
259 *cur_dsd++ = cpu_to_le32(LSD(sle_dma));
260 *cur_dsd++ = cpu_to_le32(MSD(sle_dma));
261 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg));
262 avail_dsds--;
263 }
264}
265
266
267
268
269
270
271
272int
273qla2x00_start_scsi(srb_t *sp)
274{
275 int ret, nseg;
276 unsigned long flags;
277 scsi_qla_host_t *ha;
278 struct scsi_cmnd *cmd;
279 uint32_t *clr_ptr;
280 uint32_t index;
281 uint32_t handle;
282 cmd_entry_t *cmd_pkt;
283 uint16_t cnt;
284 uint16_t req_cnt;
285 uint16_t tot_dsds;
286 struct device_reg_2xxx __iomem *reg;
287
288
289 ret = 0;
290 ha = sp->ha;
291 reg = &ha->iobase->isp;
292 cmd = sp->cmd;
293
294 tot_dsds = 0;
295
296
297 if (ha->marker_needed != 0) {
298 if (qla2x00_marker(ha, 0, 0, MK_SYNC_ALL) != QLA_SUCCESS) {
299 return (QLA_FUNCTION_FAILED);
300 }
301 ha->marker_needed = 0;
302 }
303
304
305 spin_lock_irqsave(&ha->hardware_lock, flags);
306
307
308 handle = ha->current_outstanding_cmd;
309 for (index = 1; index < MAX_OUTSTANDING_COMMANDS; index++) {
310 handle++;
311 if (handle == MAX_OUTSTANDING_COMMANDS)
312 handle = 1;
313 if (!ha->outstanding_cmds[handle])
314 break;
315 }
316 if (index == MAX_OUTSTANDING_COMMANDS)
317 goto queuing_error;
318
319
320 if (scsi_sg_count(cmd)) {
321 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd),
322 scsi_sg_count(cmd), cmd->sc_data_direction);
323 if (unlikely(!nseg))
324 goto queuing_error;
325 } else
326 nseg = 0;
327
328 tot_dsds = nseg;
329
330
331 req_cnt = ha->isp_ops->calc_req_entries(tot_dsds);
332 if (ha->req_q_cnt < (req_cnt + 2)) {
333 cnt = RD_REG_WORD_RELAXED(ISP_REQ_Q_OUT(ha, reg));
334 if (ha->req_ring_index < cnt)
335 ha->req_q_cnt = cnt - ha->req_ring_index;
336 else
337 ha->req_q_cnt = ha->request_q_length -
338 (ha->req_ring_index - cnt);
339 }
340 if (ha->req_q_cnt < (req_cnt + 2))
341 goto queuing_error;
342
343
344 ha->current_outstanding_cmd = handle;
345 ha->outstanding_cmds[handle] = sp;
346 sp->ha = ha;
347 sp->cmd->host_scribble = (unsigned char *)(unsigned long)handle;
348 ha->req_q_cnt -= req_cnt;
349
350 cmd_pkt = (cmd_entry_t *)ha->request_ring_ptr;
351 cmd_pkt->handle = handle;
352
353 clr_ptr = (uint32_t *)cmd_pkt + 2;
354 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8);
355 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds);
356
357
358 SET_TARGET_ID(ha, cmd_pkt->target, sp->fcport->loop_id);
359 cmd_pkt->lun = cpu_to_le16(sp->cmd->device->lun);
360
361
362 cmd_pkt->control_flags = __constant_cpu_to_le16(CF_SIMPLE_TAG);
363
364
365 memcpy(cmd_pkt->scsi_cdb, cmd->cmnd, cmd->cmd_len);
366 cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd));
367
368
369 ha->isp_ops->build_iocbs(sp, cmd_pkt, tot_dsds);
370
371
372 cmd_pkt->entry_count = (uint8_t)req_cnt;
373 wmb();
374
375
376 ha->req_ring_index++;
377 if (ha->req_ring_index == ha->request_q_length) {
378 ha->req_ring_index = 0;
379 ha->request_ring_ptr = ha->request_ring;
380 } else
381 ha->request_ring_ptr++;
382
383 sp->flags |= SRB_DMA_VALID;
384
385
386 WRT_REG_WORD(ISP_REQ_Q_IN(ha, reg), ha->req_ring_index);
387 RD_REG_WORD_RELAXED(ISP_REQ_Q_IN(ha, reg));
388
389
390 if (ha->flags.process_response_queue &&
391 ha->response_ring_ptr->signature != RESPONSE_PROCESSED)
392 qla2x00_process_response_queue(ha);
393
394 spin_unlock_irqrestore(&ha->hardware_lock, flags);
395 return (QLA_SUCCESS);
396
397queuing_error:
398 if (tot_dsds)
399 scsi_dma_unmap(cmd);
400
401 spin_unlock_irqrestore(&ha->hardware_lock, flags);
402
403 return (QLA_FUNCTION_FAILED);
404}
405
406
407
408
409
410
411
412
413
414
415
416
417int
418__qla2x00_marker(scsi_qla_host_t *ha, uint16_t loop_id, uint16_t lun,
419 uint8_t type)
420{
421 mrk_entry_t *mrk;
422 struct mrk_entry_24xx *mrk24;
423 scsi_qla_host_t *pha = to_qla_parent(ha);
424
425 mrk24 = NULL;
426 mrk = (mrk_entry_t *)qla2x00_req_pkt(pha);
427 if (mrk == NULL) {
428 DEBUG2_3(printk("%s(%ld): failed to allocate Marker IOCB.\n",
429 __func__, ha->host_no));
430
431 return (QLA_FUNCTION_FAILED);
432 }
433
434 mrk->entry_type = MARKER_TYPE;
435 mrk->modifier = type;
436 if (type != MK_SYNC_ALL) {
437 if (IS_FWI2_CAPABLE(ha)) {
438 mrk24 = (struct mrk_entry_24xx *) mrk;
439 mrk24->nport_handle = cpu_to_le16(loop_id);
440 mrk24->lun[1] = LSB(lun);
441 mrk24->lun[2] = MSB(lun);
442 host_to_fcp_swap(mrk24->lun, sizeof(mrk24->lun));
443 mrk24->vp_index = ha->vp_idx;
444 } else {
445 SET_TARGET_ID(ha, mrk->target, loop_id);
446 mrk->lun = cpu_to_le16(lun);
447 }
448 }
449 wmb();
450
451 qla2x00_isp_cmd(pha);
452
453 return (QLA_SUCCESS);
454}
455
456int
457qla2x00_marker(scsi_qla_host_t *ha, uint16_t loop_id, uint16_t lun,
458 uint8_t type)
459{
460 int ret;
461 unsigned long flags = 0;
462 scsi_qla_host_t *pha = to_qla_parent(ha);
463
464 spin_lock_irqsave(&pha->hardware_lock, flags);
465 ret = __qla2x00_marker(ha, loop_id, lun, type);
466 spin_unlock_irqrestore(&pha->hardware_lock, flags);
467
468 return (ret);
469}
470
471
472
473
474
475
476
477
478
479static request_t *
480qla2x00_req_pkt(scsi_qla_host_t *ha)
481{
482 device_reg_t __iomem *reg = ha->iobase;
483 request_t *pkt = NULL;
484 uint16_t cnt;
485 uint32_t *dword_ptr;
486 uint32_t timer;
487 uint16_t req_cnt = 1;
488
489
490 for (timer = HZ; timer; timer--) {
491 if ((req_cnt + 2) >= ha->req_q_cnt) {
492
493 if (IS_FWI2_CAPABLE(ha))
494 cnt = (uint16_t)RD_REG_DWORD(
495 ®->isp24.req_q_out);
496 else
497 cnt = qla2x00_debounce_register(
498 ISP_REQ_Q_OUT(ha, ®->isp));
499 if (ha->req_ring_index < cnt)
500 ha->req_q_cnt = cnt - ha->req_ring_index;
501 else
502 ha->req_q_cnt = ha->request_q_length -
503 (ha->req_ring_index - cnt);
504 }
505
506 if ((req_cnt + 2) < ha->req_q_cnt) {
507 ha->req_q_cnt--;
508 pkt = ha->request_ring_ptr;
509
510
511 dword_ptr = (uint32_t *)pkt;
512 for (cnt = 0; cnt < REQUEST_ENTRY_SIZE / 4; cnt++)
513 *dword_ptr++ = 0;
514
515
516 pkt->sys_define = (uint8_t)ha->req_ring_index;
517
518
519 pkt->entry_count = 1;
520
521 break;
522 }
523
524
525 spin_unlock(&ha->hardware_lock);
526
527 udelay(2);
528
529
530
531 if (!ha->marker_needed && !ha->flags.init_done)
532 qla2x00_poll(ha);
533
534 spin_lock_irq(&ha->hardware_lock);
535 }
536 if (!pkt) {
537 DEBUG2_3(printk("%s(): **** FAILED ****\n", __func__));
538 }
539
540 return (pkt);
541}
542
543
544
545
546
547
548
549static void
550qla2x00_isp_cmd(scsi_qla_host_t *ha)
551{
552 device_reg_t __iomem *reg = ha->iobase;
553
554 DEBUG5(printk("%s(): IOCB data:\n", __func__));
555 DEBUG5(qla2x00_dump_buffer(
556 (uint8_t *)ha->request_ring_ptr, REQUEST_ENTRY_SIZE));
557
558
559 ha->req_ring_index++;
560 if (ha->req_ring_index == ha->request_q_length) {
561 ha->req_ring_index = 0;
562 ha->request_ring_ptr = ha->request_ring;
563 } else
564 ha->request_ring_ptr++;
565
566
567 if (IS_FWI2_CAPABLE(ha)) {
568 WRT_REG_DWORD(®->isp24.req_q_in, ha->req_ring_index);
569 RD_REG_DWORD_RELAXED(®->isp24.req_q_in);
570 } else {
571 WRT_REG_WORD(ISP_REQ_Q_IN(ha, ®->isp), ha->req_ring_index);
572 RD_REG_WORD_RELAXED(ISP_REQ_Q_IN(ha, ®->isp));
573 }
574
575}
576
577
578
579
580
581
582
583
584
585static inline uint16_t
586qla24xx_calc_iocbs(uint16_t dsds)
587{
588 uint16_t iocbs;
589
590 iocbs = 1;
591 if (dsds > 1) {
592 iocbs += (dsds - 1) / 5;
593 if ((dsds - 1) % 5)
594 iocbs++;
595 }
596 return iocbs;
597}
598
599
600
601
602
603
604
605
606
607static inline void
608qla24xx_build_scsi_iocbs(srb_t *sp, struct cmd_type_7 *cmd_pkt,
609 uint16_t tot_dsds)
610{
611 uint16_t avail_dsds;
612 uint32_t *cur_dsd;
613 scsi_qla_host_t *ha;
614 struct scsi_cmnd *cmd;
615 struct scatterlist *sg;
616 int i;
617
618 cmd = sp->cmd;
619
620
621 *((uint32_t *)(&cmd_pkt->entry_type)) =
622 __constant_cpu_to_le32(COMMAND_TYPE_7);
623
624
625 if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) {
626 cmd_pkt->byte_count = __constant_cpu_to_le32(0);
627 return;
628 }
629
630 ha = sp->ha;
631
632
633 if (cmd->sc_data_direction == DMA_TO_DEVICE) {
634 cmd_pkt->task_mgmt_flags =
635 __constant_cpu_to_le16(TMF_WRITE_DATA);
636 sp->fcport->ha->qla_stats.output_bytes +=
637 scsi_bufflen(sp->cmd);
638 } else if (cmd->sc_data_direction == DMA_FROM_DEVICE) {
639 cmd_pkt->task_mgmt_flags =
640 __constant_cpu_to_le16(TMF_READ_DATA);
641 sp->fcport->ha->qla_stats.input_bytes +=
642 scsi_bufflen(sp->cmd);
643 }
644
645
646 avail_dsds = 1;
647 cur_dsd = (uint32_t *)&cmd_pkt->dseg_0_address;
648
649
650
651 scsi_for_each_sg(cmd, sg, tot_dsds, i) {
652 dma_addr_t sle_dma;
653 cont_a64_entry_t *cont_pkt;
654
655
656 if (avail_dsds == 0) {
657
658
659
660
661 cont_pkt = qla2x00_prep_cont_type1_iocb(ha);
662 cur_dsd = (uint32_t *)cont_pkt->dseg_0_address;
663 avail_dsds = 5;
664 }
665
666 sle_dma = sg_dma_address(sg);
667 *cur_dsd++ = cpu_to_le32(LSD(sle_dma));
668 *cur_dsd++ = cpu_to_le32(MSD(sle_dma));
669 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg));
670 avail_dsds--;
671 }
672}
673
674
675
676
677
678
679
680
681int
682qla24xx_start_scsi(srb_t *sp)
683{
684 int ret, nseg;
685 unsigned long flags;
686 scsi_qla_host_t *ha, *pha;
687 struct scsi_cmnd *cmd;
688 uint32_t *clr_ptr;
689 uint32_t index;
690 uint32_t handle;
691 struct cmd_type_7 *cmd_pkt;
692 uint16_t cnt;
693 uint16_t req_cnt;
694 uint16_t tot_dsds;
695 struct device_reg_24xx __iomem *reg;
696
697
698 ret = 0;
699 ha = sp->ha;
700 pha = to_qla_parent(ha);
701 reg = &ha->iobase->isp24;
702 cmd = sp->cmd;
703
704 tot_dsds = 0;
705
706
707 if (ha->marker_needed != 0) {
708 if (qla2x00_marker(ha, 0, 0, MK_SYNC_ALL) != QLA_SUCCESS) {
709 return QLA_FUNCTION_FAILED;
710 }
711 ha->marker_needed = 0;
712 }
713
714
715 spin_lock_irqsave(&pha->hardware_lock, flags);
716
717
718 handle = ha->current_outstanding_cmd;
719 for (index = 1; index < MAX_OUTSTANDING_COMMANDS; index++) {
720 handle++;
721 if (handle == MAX_OUTSTANDING_COMMANDS)
722 handle = 1;
723 if (!ha->outstanding_cmds[handle])
724 break;
725 }
726 if (index == MAX_OUTSTANDING_COMMANDS)
727 goto queuing_error;
728
729
730 if (scsi_sg_count(cmd)) {
731 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd),
732 scsi_sg_count(cmd), cmd->sc_data_direction);
733 if (unlikely(!nseg))
734 goto queuing_error;
735 } else
736 nseg = 0;
737
738 tot_dsds = nseg;
739
740 req_cnt = qla24xx_calc_iocbs(tot_dsds);
741 if (ha->req_q_cnt < (req_cnt + 2)) {
742 cnt = (uint16_t)RD_REG_DWORD_RELAXED(®->req_q_out);
743 if (ha->req_ring_index < cnt)
744 ha->req_q_cnt = cnt - ha->req_ring_index;
745 else
746 ha->req_q_cnt = ha->request_q_length -
747 (ha->req_ring_index - cnt);
748 }
749 if (ha->req_q_cnt < (req_cnt + 2))
750 goto queuing_error;
751
752
753 ha->current_outstanding_cmd = handle;
754 ha->outstanding_cmds[handle] = sp;
755 sp->ha = ha;
756 sp->cmd->host_scribble = (unsigned char *)(unsigned long)handle;
757 ha->req_q_cnt -= req_cnt;
758
759 cmd_pkt = (struct cmd_type_7 *)ha->request_ring_ptr;
760 cmd_pkt->handle = handle;
761
762
763
764 clr_ptr = (uint32_t *)cmd_pkt + 2;
765 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8);
766 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds);
767
768
769 cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id);
770 cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa;
771 cmd_pkt->port_id[1] = sp->fcport->d_id.b.area;
772 cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain;
773 cmd_pkt->vp_index = sp->fcport->vp_idx;
774
775 int_to_scsilun(sp->cmd->device->lun, &cmd_pkt->lun);
776 host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun));
777
778
779 memcpy(cmd_pkt->fcp_cdb, cmd->cmnd, cmd->cmd_len);
780 host_to_fcp_swap(cmd_pkt->fcp_cdb, sizeof(cmd_pkt->fcp_cdb));
781
782 cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd));
783
784
785 qla24xx_build_scsi_iocbs(sp, cmd_pkt, tot_dsds);
786
787
788 cmd_pkt->entry_count = (uint8_t)req_cnt;
789 wmb();
790
791
792 ha->req_ring_index++;
793 if (ha->req_ring_index == ha->request_q_length) {
794 ha->req_ring_index = 0;
795 ha->request_ring_ptr = ha->request_ring;
796 } else
797 ha->request_ring_ptr++;
798
799 sp->flags |= SRB_DMA_VALID;
800
801
802 WRT_REG_DWORD(®->req_q_in, ha->req_ring_index);
803 RD_REG_DWORD_RELAXED(®->req_q_in);
804
805
806 if (ha->flags.process_response_queue &&
807 ha->response_ring_ptr->signature != RESPONSE_PROCESSED)
808 qla24xx_process_response_queue(ha);
809
810 spin_unlock_irqrestore(&pha->hardware_lock, flags);
811 return QLA_SUCCESS;
812
813queuing_error:
814 if (tot_dsds)
815 scsi_dma_unmap(cmd);
816
817 spin_unlock_irqrestore(&pha->hardware_lock, flags);
818
819 return QLA_FUNCTION_FAILED;
820}