ctatc.c (a8f4310be59a2e7fc80fba945bcb32b18f4ad54f) ctatc.c (29959a09cc1aabd2d5f4f03afc0305de6bd29248)
1/**
2 * Copyright (C) 2008, Creative Technology Ltd. All Rights Reserved.
3 *
4 * This source file is released under GPL v2 license (no other versions).
5 * See the COPYING file included in the main directory of this source
6 * distribution for the license terms and conditions.
7 *
8 * @File ctatc.c

--- 247 unchanged lines hidden (view full) ---

256 struct amixer_desc mix_dsc = {0};
257 struct src *src;
258 struct amixer *amixer;
259 int err;
260 int n_amixer = apcm->substream->runtime->channels, i = 0;
261 int device = apcm->substream->pcm->device;
262 unsigned int pitch;
263
1/**
2 * Copyright (C) 2008, Creative Technology Ltd. All Rights Reserved.
3 *
4 * This source file is released under GPL v2 license (no other versions).
5 * See the COPYING file included in the main directory of this source
6 * distribution for the license terms and conditions.
7 *
8 * @File ctatc.c

--- 247 unchanged lines hidden (view full) ---

256 struct amixer_desc mix_dsc = {0};
257 struct src *src;
258 struct amixer *amixer;
259 int err;
260 int n_amixer = apcm->substream->runtime->channels, i = 0;
261 int device = apcm->substream->pcm->device;
262 unsigned int pitch;
263
264 if (NULL != apcm->src) {
265 /* Prepared pcm playback */
266 return 0;
267 }
268
269 /* first release old resources */
264 /* first release old resources */
270 atc->pcm_release_resources(atc, apcm);
265 atc_pcm_release_resources(atc, apcm);
271
272 /* Get SRC resource */
273 desc.multi = apcm->substream->runtime->channels;
274 desc.msr = atc->msr;
275 desc.mode = MEMRD;
276 err = src_mgr->get_src(src_mgr, &desc, (struct src **)&apcm->src);
277 if (err)
278 goto error1;

--- 377 unchanged lines hidden (view full) ---

656 struct srcimp *srcimp;
657 struct ct_mixer *mixer = atc->mixer;
658 struct sum *mono;
659 struct rsc *out_ports[8] = {NULL};
660 int err, i, j, n_sum, multi;
661 unsigned int pitch;
662 int mix_base = 0, imp_base = 0;
663
266
267 /* Get SRC resource */
268 desc.multi = apcm->substream->runtime->channels;
269 desc.msr = atc->msr;
270 desc.mode = MEMRD;
271 err = src_mgr->get_src(src_mgr, &desc, (struct src **)&apcm->src);
272 if (err)
273 goto error1;

--- 377 unchanged lines hidden (view full) ---

651 struct srcimp *srcimp;
652 struct ct_mixer *mixer = atc->mixer;
653 struct sum *mono;
654 struct rsc *out_ports[8] = {NULL};
655 int err, i, j, n_sum, multi;
656 unsigned int pitch;
657 int mix_base = 0, imp_base = 0;
658
664 if (NULL != apcm->src) {
665 /* Prepared pcm capture */
666 return 0;
667 }
659 atc_pcm_release_resources(atc, apcm);
668
669 /* Get needed resources. */
670 err = atc_pcm_capture_get_resources(atc, apcm);
671 if (err)
672 return err;
673
674 /* Connect resources */
675 mixer->get_output_ports(mixer, MIX_PCMO_FRONT,

--- 186 unchanged lines hidden (view full) ---

862}
863
864static int
865spdif_passthru_playback_setup(struct ct_atc *atc, struct ct_atc_pcm *apcm)
866{
867 struct dao *dao = container_of(atc->daios[SPDIFOO], struct dao, daio);
868 unsigned int rate = apcm->substream->runtime->rate;
869 unsigned int status;
660
661 /* Get needed resources. */
662 err = atc_pcm_capture_get_resources(atc, apcm);
663 if (err)
664 return err;
665
666 /* Connect resources */
667 mixer->get_output_ports(mixer, MIX_PCMO_FRONT,

--- 186 unchanged lines hidden (view full) ---

854}
855
856static int
857spdif_passthru_playback_setup(struct ct_atc *atc, struct ct_atc_pcm *apcm)
858{
859 struct dao *dao = container_of(atc->daios[SPDIFOO], struct dao, daio);
860 unsigned int rate = apcm->substream->runtime->rate;
861 unsigned int status;
870 int err;
862 int err = 0;
871 unsigned char iec958_con_fs;
872
873 switch (rate) {
874 case 48000:
875 iec958_con_fs = IEC958_AES3_CON_FS_48000;
876 break;
877 case 44100:
878 iec958_con_fs = IEC958_AES3_CON_FS_44100;

--- 24 unchanged lines hidden (view full) ---

903spdif_passthru_playback_prepare(struct ct_atc *atc, struct ct_atc_pcm *apcm)
904{
905 struct src *src;
906 struct amixer *amixer;
907 struct dao *dao;
908 int err;
909 int i;
910
863 unsigned char iec958_con_fs;
864
865 switch (rate) {
866 case 48000:
867 iec958_con_fs = IEC958_AES3_CON_FS_48000;
868 break;
869 case 44100:
870 iec958_con_fs = IEC958_AES3_CON_FS_44100;

--- 24 unchanged lines hidden (view full) ---

895spdif_passthru_playback_prepare(struct ct_atc *atc, struct ct_atc_pcm *apcm)
896{
897 struct src *src;
898 struct amixer *amixer;
899 struct dao *dao;
900 int err;
901 int i;
902
911 if (NULL != apcm->src)
912 return 0;
903 atc_pcm_release_resources(atc, apcm);
913
914 /* Configure SPDIFOO and PLL to passthrough mode;
915 * determine pll_rate. */
916 err = spdif_passthru_playback_setup(atc, apcm);
917 if (err)
918 return err;
919
920 /* Get needed resources. */

--- 190 unchanged lines hidden (view full) ---

1111 }
1112 dao->ops->set_spos(dao, spos);
1113 dao->ops->commit_write(dao);
1114 mutex_unlock(&atc->atc_mutex);
1115
1116 return err;
1117}
1118
904
905 /* Configure SPDIFOO and PLL to passthrough mode;
906 * determine pll_rate. */
907 err = spdif_passthru_playback_setup(atc, apcm);
908 if (err)
909 return err;
910
911 /* Get needed resources. */

--- 190 unchanged lines hidden (view full) ---

1102 }
1103 dao->ops->set_spos(dao, spos);
1104 dao->ops->commit_write(dao);
1105 mutex_unlock(&atc->atc_mutex);
1106
1107 return err;
1108}
1109
1119static int ct_atc_destroy(struct ct_atc *atc)
1110static int atc_release_resources(struct ct_atc *atc)
1120{
1111{
1121 struct daio_mgr *daio_mgr;
1122 struct dao *dao;
1123 struct dai *dai;
1124 struct daio *daio;
1125 struct sum_mgr *sum_mgr;
1126 struct src_mgr *src_mgr;
1127 struct srcimp_mgr *srcimp_mgr;
1128 struct srcimp *srcimp;
1129 struct ct_mixer *mixer;
1130 int i = 0;
1112 int i;
1113 struct daio_mgr *daio_mgr = NULL;
1114 struct dao *dao = NULL;
1115 struct dai *dai = NULL;
1116 struct daio *daio = NULL;
1117 struct sum_mgr *sum_mgr = NULL;
1118 struct src_mgr *src_mgr = NULL;
1119 struct srcimp_mgr *srcimp_mgr = NULL;
1120 struct srcimp *srcimp = NULL;
1121 struct ct_mixer *mixer = NULL;
1131
1122
1132 if (NULL == atc)
1133 return 0;
1134
1135 if (atc->timer) {
1136 ct_timer_free(atc->timer);
1137 atc->timer = NULL;
1138 }
1139
1140 /* Stop hardware and disable all interrupts */
1141 if (NULL != atc->hw)
1142 ((struct hw *)atc->hw)->card_stop(atc->hw);
1143
1144 /* Destroy internal mixer objects */
1123 /* disconnect internal mixer objects */
1145 if (NULL != atc->mixer) {
1146 mixer = atc->mixer;
1147 mixer->set_input_left(mixer, MIX_LINE_IN, NULL);
1148 mixer->set_input_right(mixer, MIX_LINE_IN, NULL);
1149 mixer->set_input_left(mixer, MIX_MIC_IN, NULL);
1150 mixer->set_input_right(mixer, MIX_MIC_IN, NULL);
1151 mixer->set_input_left(mixer, MIX_SPDIF_IN, NULL);
1152 mixer->set_input_right(mixer, MIX_SPDIF_IN, NULL);
1124 if (NULL != atc->mixer) {
1125 mixer = atc->mixer;
1126 mixer->set_input_left(mixer, MIX_LINE_IN, NULL);
1127 mixer->set_input_right(mixer, MIX_LINE_IN, NULL);
1128 mixer->set_input_left(mixer, MIX_MIC_IN, NULL);
1129 mixer->set_input_right(mixer, MIX_MIC_IN, NULL);
1130 mixer->set_input_left(mixer, MIX_SPDIF_IN, NULL);
1131 mixer->set_input_right(mixer, MIX_SPDIF_IN, NULL);
1153 ct_mixer_destroy(atc->mixer);
1154 }
1155
1156 if (NULL != atc->daios) {
1157 daio_mgr = (struct daio_mgr *)atc->rsc_mgrs[DAIO];
1158 for (i = 0; i < atc->n_daio; i++) {
1159 daio = atc->daios[i];
1160 if (daio->type < LINEIM) {
1161 dao = container_of(daio, struct dao, daio);
1162 dao->ops->clear_left_input(dao);
1163 dao->ops->clear_right_input(dao);
1164 } else {
1165 dai = container_of(daio, struct dai, daio);
1166 /* some thing to do for dai ... */
1167 }
1168 daio_mgr->put_daio(daio_mgr, daio);
1169 }
1170 kfree(atc->daios);
1132 }
1133
1134 if (NULL != atc->daios) {
1135 daio_mgr = (struct daio_mgr *)atc->rsc_mgrs[DAIO];
1136 for (i = 0; i < atc->n_daio; i++) {
1137 daio = atc->daios[i];
1138 if (daio->type < LINEIM) {
1139 dao = container_of(daio, struct dao, daio);
1140 dao->ops->clear_left_input(dao);
1141 dao->ops->clear_right_input(dao);
1142 } else {
1143 dai = container_of(daio, struct dai, daio);
1144 /* some thing to do for dai ... */
1145 }
1146 daio_mgr->put_daio(daio_mgr, daio);
1147 }
1148 kfree(atc->daios);
1149 atc->daios = NULL;
1171 }
1172
1173 if (NULL != atc->pcm) {
1174 sum_mgr = atc->rsc_mgrs[SUM];
1175 for (i = 0; i < atc->n_pcm; i++)
1176 sum_mgr->put_sum(sum_mgr, atc->pcm[i]);
1177
1178 kfree(atc->pcm);
1150 }
1151
1152 if (NULL != atc->pcm) {
1153 sum_mgr = atc->rsc_mgrs[SUM];
1154 for (i = 0; i < atc->n_pcm; i++)
1155 sum_mgr->put_sum(sum_mgr, atc->pcm[i]);
1156
1157 kfree(atc->pcm);
1158 atc->pcm = NULL;
1179 }
1180
1181 if (NULL != atc->srcs) {
1182 src_mgr = atc->rsc_mgrs[SRC];
1183 for (i = 0; i < atc->n_src; i++)
1184 src_mgr->put_src(src_mgr, atc->srcs[i]);
1185
1186 kfree(atc->srcs);
1159 }
1160
1161 if (NULL != atc->srcs) {
1162 src_mgr = atc->rsc_mgrs[SRC];
1163 for (i = 0; i < atc->n_src; i++)
1164 src_mgr->put_src(src_mgr, atc->srcs[i]);
1165
1166 kfree(atc->srcs);
1167 atc->srcs = NULL;
1187 }
1188
1189 if (NULL != atc->srcimps) {
1190 srcimp_mgr = atc->rsc_mgrs[SRCIMP];
1191 for (i = 0; i < atc->n_srcimp; i++) {
1192 srcimp = atc->srcimps[i];
1193 srcimp->ops->unmap(srcimp);
1194 srcimp_mgr->put_srcimp(srcimp_mgr, atc->srcimps[i]);
1195 }
1196 kfree(atc->srcimps);
1168 }
1169
1170 if (NULL != atc->srcimps) {
1171 srcimp_mgr = atc->rsc_mgrs[SRCIMP];
1172 for (i = 0; i < atc->n_srcimp; i++) {
1173 srcimp = atc->srcimps[i];
1174 srcimp->ops->unmap(srcimp);
1175 srcimp_mgr->put_srcimp(srcimp_mgr, atc->srcimps[i]);
1176 }
1177 kfree(atc->srcimps);
1178 atc->srcimps = NULL;
1197 }
1198
1179 }
1180
1181 return 0;
1182}
1183
1184static int ct_atc_destroy(struct ct_atc *atc)
1185{
1186 int i = 0;
1187
1188 if (NULL == atc)
1189 return 0;
1190
1191 if (atc->timer) {
1192 ct_timer_free(atc->timer);
1193 atc->timer = NULL;
1194 }
1195
1196 atc_release_resources(atc);
1197
1198 /* Destroy internal mixer objects */
1199 if (NULL != atc->mixer)
1200 ct_mixer_destroy(atc->mixer);
1201
1199 for (i = 0; i < NUM_RSCTYP; i++) {
1200 if ((NULL != rsc_mgr_funcs[i].destroy) &&
1201 (NULL != atc->rsc_mgrs[i]))
1202 rsc_mgr_funcs[i].destroy(atc->rsc_mgrs[i]);
1203
1204 }
1205
1206 if (NULL != atc->hw)

--- 111 unchanged lines hidden (view full) ---

1318 "Failed to create rsc_mgr %d!!!\n", i);
1319 return err;
1320 }
1321 }
1322
1323 return 0;
1324}
1325
1202 for (i = 0; i < NUM_RSCTYP; i++) {
1203 if ((NULL != rsc_mgr_funcs[i].destroy) &&
1204 (NULL != atc->rsc_mgrs[i]))
1205 rsc_mgr_funcs[i].destroy(atc->rsc_mgrs[i]);
1206
1207 }
1208
1209 if (NULL != atc->hw)

--- 111 unchanged lines hidden (view full) ---

1321 "Failed to create rsc_mgr %d!!!\n", i);
1322 return err;
1323 }
1324 }
1325
1326 return 0;
1327}
1328
1326static int __devinit atc_get_resources(struct ct_atc *atc)
1329static int atc_get_resources(struct ct_atc *atc)
1327{
1328 struct daio_desc da_desc = {0};
1329 struct daio_mgr *daio_mgr;
1330 struct src_desc src_dsc = {0};
1331 struct src_mgr *src_mgr;
1332 struct srcimp_desc srcimp_dsc = {0};
1333 struct srcimp_mgr *srcimp_mgr;
1334 struct sum_desc sum_dsc = {0};

--- 80 unchanged lines hidden (view full) ---

1415 err = sum_mgr->get_sum(sum_mgr, &sum_dsc,
1416 (struct sum **)&atc->pcm[i]);
1417 if (err)
1418 return err;
1419
1420 atc->n_pcm++;
1421 }
1422
1330{
1331 struct daio_desc da_desc = {0};
1332 struct daio_mgr *daio_mgr;
1333 struct src_desc src_dsc = {0};
1334 struct src_mgr *src_mgr;
1335 struct srcimp_desc srcimp_dsc = {0};
1336 struct srcimp_mgr *srcimp_mgr;
1337 struct sum_desc sum_dsc = {0};

--- 80 unchanged lines hidden (view full) ---

1418 err = sum_mgr->get_sum(sum_mgr, &sum_dsc,
1419 (struct sum **)&atc->pcm[i]);
1420 if (err)
1421 return err;
1422
1423 atc->n_pcm++;
1424 }
1425
1423 err = ct_mixer_create(atc, (struct ct_mixer **)&atc->mixer);
1424 if (err) {
1425 printk(KERN_ERR "ctxfi: Failed to create mixer obj!!!\n");
1426 return err;
1427 }
1428
1429 return 0;
1430}
1431
1426 return 0;
1427}
1428
1432static void __devinit
1429static void
1433atc_connect_dai(struct src_mgr *src_mgr, struct dai *dai,
1434 struct src **srcs, struct srcimp **srcimps)
1435{
1436 struct rsc *rscs[2] = {NULL};
1437 struct src *src;
1438 struct srcimp *srcimp;
1439 int i = 0;
1440

--- 22 unchanged lines hidden (view full) ---

1463
1464 dai->ops->set_enb_src(dai, 1);
1465 dai->ops->set_enb_srt(dai, 1);
1466 dai->ops->commit_write(dai);
1467
1468 src_mgr->commit_write(src_mgr); /* Synchronously enable SRCs */
1469}
1470
1430atc_connect_dai(struct src_mgr *src_mgr, struct dai *dai,
1431 struct src **srcs, struct srcimp **srcimps)
1432{
1433 struct rsc *rscs[2] = {NULL};
1434 struct src *src;
1435 struct srcimp *srcimp;
1436 int i = 0;
1437

--- 22 unchanged lines hidden (view full) ---

1460
1461 dai->ops->set_enb_src(dai, 1);
1462 dai->ops->set_enb_srt(dai, 1);
1463 dai->ops->commit_write(dai);
1464
1465 src_mgr->commit_write(src_mgr); /* Synchronously enable SRCs */
1466}
1467
1471static void __devinit atc_connect_resources(struct ct_atc *atc)
1468static void atc_connect_resources(struct ct_atc *atc)
1472{
1473 struct dai *dai;
1474 struct dao *dao;
1475 struct src *src;
1476 struct sum *sum;
1477 struct ct_mixer *mixer;
1478 struct rsc *rscs[2] = {NULL};
1479 int i, j;

--- 29 unchanged lines hidden (view full) ---

1509 for (i = MIX_PCMI_FRONT, j = 0; i <= MIX_PCMI_SURROUND; i++, j += 2) {
1510 sum = atc->pcm[j];
1511 mixer->set_input_left(mixer, i, &sum->rsc);
1512 sum = atc->pcm[j+1];
1513 mixer->set_input_right(mixer, i, &sum->rsc);
1514 }
1515}
1516
1469{
1470 struct dai *dai;
1471 struct dao *dao;
1472 struct src *src;
1473 struct sum *sum;
1474 struct ct_mixer *mixer;
1475 struct rsc *rscs[2] = {NULL};
1476 int i, j;

--- 29 unchanged lines hidden (view full) ---

1506 for (i = MIX_PCMI_FRONT, j = 0; i <= MIX_PCMI_SURROUND; i++, j += 2) {
1507 sum = atc->pcm[j];
1508 mixer->set_input_left(mixer, i, &sum->rsc);
1509 sum = atc->pcm[j+1];
1510 mixer->set_input_right(mixer, i, &sum->rsc);
1511 }
1512}
1513
1514#ifdef CONFIG_PM
1515static int atc_suspend(struct ct_atc *atc, pm_message_t state)
1516{
1517 int i;
1518 struct hw *hw = atc->hw;
1519
1520 snd_power_change_state(atc->card, SNDRV_CTL_POWER_D3hot);
1521
1522 for (i = FRONT; i < NUM_PCMS; i++) {
1523 if (!atc->pcms[i])
1524 continue;
1525
1526 snd_pcm_suspend_all(atc->pcms[i]);
1527 }
1528
1529 atc_release_resources(atc);
1530
1531 hw->suspend(hw, state);
1532
1533 return 0;
1534}
1535
1536static int atc_hw_resume(struct ct_atc *atc)
1537{
1538 struct hw *hw = atc->hw;
1539 struct card_conf info = {0};
1540
1541 /* Re-initialize card hardware. */
1542 info.rsr = atc->rsr;
1543 info.msr = atc->msr;
1544 info.vm_pgt_phys = atc_get_ptp_phys(atc, 0);
1545 return hw->resume(hw, &info);
1546}
1547
1548static int atc_resources_resume(struct ct_atc *atc)
1549{
1550 struct ct_mixer *mixer;
1551 int err = 0;
1552
1553 /* Get resources */
1554 err = atc_get_resources(atc);
1555 if (err < 0) {
1556 atc_release_resources(atc);
1557 return err;
1558 }
1559
1560 /* Build topology */
1561 atc_connect_resources(atc);
1562
1563 mixer = atc->mixer;
1564 mixer->resume(mixer);
1565
1566 return 0;
1567}
1568
1569static int atc_resume(struct ct_atc *atc)
1570{
1571 int err = 0;
1572
1573 /* Do hardware resume. */
1574 err = atc_hw_resume(atc);
1575 if (err < 0) {
1576 printk(KERN_ERR "ctxfi: pci_enable_device failed, "
1577 "disabling device\n");
1578 snd_card_disconnect(atc->card);
1579 return err;
1580 }
1581
1582 err = atc_resources_resume(atc);
1583 if (err < 0)
1584 return err;
1585
1586 snd_power_change_state(atc->card, SNDRV_CTL_POWER_D0);
1587
1588 return 0;
1589}
1590#endif
1591
1517static struct ct_atc atc_preset __devinitdata = {
1518 .map_audio_buffer = ct_map_audio_buffer,
1519 .unmap_audio_buffer = ct_unmap_audio_buffer,
1520 .pcm_playback_prepare = atc_pcm_playback_prepare,
1521 .pcm_release_resources = atc_pcm_release_resources,
1522 .pcm_playback_start = atc_pcm_playback_start,
1523 .pcm_playback_stop = atc_pcm_stop,
1524 .pcm_playback_position = atc_pcm_playback_position,

--- 12 unchanged lines hidden (view full) ---

1537 .line_rear_unmute = atc_line_rear_unmute,
1538 .line_in_unmute = atc_line_in_unmute,
1539 .spdif_out_unmute = atc_spdif_out_unmute,
1540 .spdif_in_unmute = atc_spdif_in_unmute,
1541 .spdif_out_get_status = atc_spdif_out_get_status,
1542 .spdif_out_set_status = atc_spdif_out_set_status,
1543 .spdif_out_passthru = atc_spdif_out_passthru,
1544 .have_digit_io_switch = atc_have_digit_io_switch,
1592static struct ct_atc atc_preset __devinitdata = {
1593 .map_audio_buffer = ct_map_audio_buffer,
1594 .unmap_audio_buffer = ct_unmap_audio_buffer,
1595 .pcm_playback_prepare = atc_pcm_playback_prepare,
1596 .pcm_release_resources = atc_pcm_release_resources,
1597 .pcm_playback_start = atc_pcm_playback_start,
1598 .pcm_playback_stop = atc_pcm_stop,
1599 .pcm_playback_position = atc_pcm_playback_position,

--- 12 unchanged lines hidden (view full) ---

1612 .line_rear_unmute = atc_line_rear_unmute,
1613 .line_in_unmute = atc_line_in_unmute,
1614 .spdif_out_unmute = atc_spdif_out_unmute,
1615 .spdif_in_unmute = atc_spdif_in_unmute,
1616 .spdif_out_get_status = atc_spdif_out_get_status,
1617 .spdif_out_set_status = atc_spdif_out_set_status,
1618 .spdif_out_passthru = atc_spdif_out_passthru,
1619 .have_digit_io_switch = atc_have_digit_io_switch,
1620#ifdef CONFIG_PM
1621 .suspend = atc_suspend,
1622 .resume = atc_resume,
1623#endif
1545};
1546
1547/**
1548 * ct_atc_create - create and initialize a hardware manager
1549 * @card: corresponding alsa card object
1550 * @pci: corresponding kernel pci device object
1551 * @ratc: return created object address in it
1552 *

--- 42 unchanged lines hidden (view full) ---

1595 if (err < 0)
1596 goto error1;
1597
1598 /* Create all atc hw devices */
1599 err = atc_create_hw_devs(atc);
1600 if (err < 0)
1601 goto error1;
1602
1624};
1625
1626/**
1627 * ct_atc_create - create and initialize a hardware manager
1628 * @card: corresponding alsa card object
1629 * @pci: corresponding kernel pci device object
1630 * @ratc: return created object address in it
1631 *

--- 42 unchanged lines hidden (view full) ---

1674 if (err < 0)
1675 goto error1;
1676
1677 /* Create all atc hw devices */
1678 err = atc_create_hw_devs(atc);
1679 if (err < 0)
1680 goto error1;
1681
1682 err = ct_mixer_create(atc, (struct ct_mixer **)&atc->mixer);
1683 if (err) {
1684 printk(KERN_ERR "ctxfi: Failed to create mixer obj!!!\n");
1685 goto error1;
1686 }
1687
1603 /* Get resources */
1604 err = atc_get_resources(atc);
1605 if (err < 0)
1606 goto error1;
1607
1608 /* Build topology */
1609 atc_connect_resources(atc);
1610

--- 18 unchanged lines hidden --- 		1688 /* Get resources */
1689 err = atc_get_resources(atc);
1690 if (err < 0)
1691 goto error1;
1692
1693 /* Build topology */
1694 atc_connect_resources(atc);
1695

--- 18 unchanged lines hidden ---