projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
V4L/DVB (12931): SAA7164: Fix the 88021 definition to work with production boards.
[linux-block.git] / drivers / media / video / saa7164 / saa7164-dvb.c
CommitLineData
443c1228
ST		 1/*
2 * Driver for the NXP SAA7164 PCIe bridge
3 *
4 * Copyright (c) 2009 Steven Toth <stoth@kernellabs.com>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 *
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22#include "saa7164.h"
23
24#include "tda10048.h"
25#include "tda18271.h"
26#include "s5h1411.h"
27
28#define DRIVER_NAME "saa7164"
29
30DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
31
32/* addr is in the card struct, get it from there */
33static struct tda10048_config hauppauge_hvr2200_1_config = {
34 .demod_address = 0x10 >> 1,
35 .output_mode = TDA10048_SERIAL_OUTPUT,
36 .fwbulkwritelen = TDA10048_BULKWRITE_200,
7aa2e795
ST		 37 .inversion = TDA10048_INVERSION_ON,
38 .if_freq_khz = TDA10048_IF_4000,
39 .clk_freq_khz = TDA10048_CLK_16000,
443c1228
ST		 40};
41static struct tda10048_config hauppauge_hvr2200_2_config = {
42 .demod_address = 0x12 >> 1,
43 .output_mode = TDA10048_SERIAL_OUTPUT,
44 .fwbulkwritelen = TDA10048_BULKWRITE_200,
7aa2e795
ST		 45 .inversion = TDA10048_INVERSION_ON,
46 .if_freq_khz = TDA10048_IF_4000,
47 .clk_freq_khz = TDA10048_CLK_16000,
443c1228
ST		 48};
49
50static struct tda18271_std_map hauppauge_tda18271_std_map = {
51 .atsc_6 = { .if_freq = 3250, .agc_mode = 3, .std = 3,
52 .if_lvl = 6, .rfagc_top = 0x37 },
53 .qam_6 = { .if_freq = 4000, .agc_mode = 3, .std = 0,
54 .if_lvl = 6, .rfagc_top = 0x37 },
55};
56
57static struct tda18271_config hauppauge_hvr22x0_tuner_config = {
58 .std_map = &hauppauge_tda18271_std_map,
59 .gate = TDA18271_GATE_ANALOG,
60};
61
62static struct s5h1411_config hauppauge_s5h1411_config = {
63 .output_mode = S5H1411_SERIAL_OUTPUT,
64 .gpio = S5H1411_GPIO_ON,
65 .qam_if = S5H1411_IF_4000,
66 .vsb_if = S5H1411_IF_3250,
67 .inversion = S5H1411_INVERSION_ON,
68 .status_mode = S5H1411_DEMODLOCKING,
69 .mpeg_timing = S5H1411_MPEGTIMING_CONTINOUS_NONINVERTING_CLOCK,
70};
71
72static int saa7164_dvb_stop_tsport(struct saa7164_tsport *port)
73{
74 struct saa7164_dev *dev = port->dev;
75 int ret;
76
77 ret = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
78 if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
79 printk(KERN_ERR "%s() stop transition failed, ret = 0x%x\n",
80 __func__, ret);
81 ret = -EIO;
82 } else {
83 dprintk(DBGLVL_DVB, "%s() Stopped\n", __func__);
84 ret = 0;
85 }
86
87 return ret;
88}
89
90static int saa7164_dvb_acquire_tsport(struct saa7164_tsport *port)
91{
92 struct saa7164_dev *dev = port->dev;
93 int ret;
94
95 ret = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
96 if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
97 printk(KERN_ERR "%s() acquire transition failed, ret = 0x%x\n",
98 __func__, ret);
99 ret = -EIO;
100 } else {
101 dprintk(DBGLVL_DVB, "%s() Acquired\n", __func__);
102 ret = 0;
103 }
104
105 return ret;
106}
107
108static int saa7164_dvb_pause_tsport(struct saa7164_tsport *port)
109{
110 struct saa7164_dev *dev = port->dev;
111 int ret;
112
113 ret = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
114 if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
115 printk(KERN_ERR "%s() pause transition failed, ret = 0x%x\n",
116 __func__, ret);
117 ret = -EIO;
118 } else {
119 dprintk(DBGLVL_DVB, "%s() Paused\n", __func__);
120 ret = 0;
121 }
122
123 return ret;
124}
125
126/* Firmware is very windows centric, meaning you have to transition
127 * the part through AVStream / KS Windows stages, forwards or backwards.
128 * States are: stopped, acquired (h/w), paused, started.
129 */
130static int saa7164_dvb_stop_streaming(struct saa7164_tsport *port)
131{
132 struct saa7164_dev *dev = port->dev;
133 int ret;
134
135 dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
136
137 ret = saa7164_dvb_pause_tsport(port);
138 ret = saa7164_dvb_acquire_tsport(port);
139 ret = saa7164_dvb_stop_tsport(port);
140
141 return ret;
142}
143
144static int saa7164_dvb_cfg_tsport(struct saa7164_tsport *port)
145{
146 tmHWStreamParameters_t *params = &port->hw_streamingparams;
147 struct saa7164_dev *dev = port->dev;
148 struct saa7164_buffer *buf;
149 struct list_head *c, *n;
150 int i = 0;
151
152 dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
153
154 saa7164_writel(port->pitch, params->pitch);
155 saa7164_writel(port->bufsize, params->pitch * params->numberoflines);
156
157 dprintk(DBGLVL_DVB, " configured:\n");
207b42c4 158 dprintk(DBGLVL_DVB, " lmmio 0x%p\n", dev->lmmio);
443c1228
ST		 159 dprintk(DBGLVL_DVB, " bufcounter 0x%x = 0x%x\n", port->bufcounter,
160 saa7164_readl(port->bufcounter));
161
162 dprintk(DBGLVL_DVB, " pitch 0x%x = %d\n", port->pitch,
163 saa7164_readl(port->pitch));
164
165 dprintk(DBGLVL_DVB, " bufsize 0x%x = %d\n", port->bufsize,
166 saa7164_readl(port->bufsize));
167
168 dprintk(DBGLVL_DVB, " buffercount = %d\n", port->hwcfg.buffercount);
169 dprintk(DBGLVL_DVB, " bufoffset = 0x%x\n", port->bufoffset);
170 dprintk(DBGLVL_DVB, " bufptr32h = 0x%x\n", port->bufptr32h);
171 dprintk(DBGLVL_DVB, " bufptr32l = 0x%x\n", port->bufptr32l);
172
173 /* Poke the buffers and offsets into PCI space */
174 mutex_lock(&port->dmaqueue_lock);
175 list_for_each_safe(c, n, &port->dmaqueue.list) {
176 buf = list_entry(c, struct saa7164_buffer, list);
177
178 /* TODO: Review this in light of 32v64 assignments */
179 saa7164_writel(port->bufoffset + (sizeof(u32) * i), 0);
180 saa7164_writel(port->bufptr32h + ((sizeof(u32) * 2) * i),
181 buf->pt_dma);
182 saa7164_writel(port->bufptr32l + ((sizeof(u32) * 2) * i), 0);
183
184 dprintk(DBGLVL_DVB,
207b42c4
ST		 185 " buf[%d] offset 0x%llx (0x%x) "
186 "buf 0x%llx/%llx (0x%x/%x)\n",
443c1228 187 i,
207b42c4 188 (u64)port->bufoffset + (i * sizeof(u32)),
443c1228 189 saa7164_readl(port->bufoffset + (sizeof(u32) * i)),
207b42c4
ST		 190 (u64)port->bufptr32h + ((sizeof(u32) * 2) * i),
191 (u64)port->bufptr32l + ((sizeof(u32) * 2) * i),
443c1228
ST		 192 saa7164_readl(port->bufptr32h + ((sizeof(u32) * i)
193 * 2)),
194 saa7164_readl(port->bufptr32l + ((sizeof(u32) * i)
195 * 2)));
196
197 if (i++ > port->hwcfg.buffercount)
198 BUG();
199
200 }
201 mutex_unlock(&port->dmaqueue_lock);
202
203 return 0;
204}
205
206static int saa7164_dvb_start_tsport(struct saa7164_tsport *port)
207{
208 struct saa7164_dev *dev = port->dev;
209 int ret = 0, result;
210
211 dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
212
213 saa7164_dvb_cfg_tsport(port);
214
215 /* Acquire the hardware */
216 result = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
217 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
218 printk(KERN_ERR "%s() acquire transition failed, res = 0x%x\n",
219 __func__, result);
220
221 /* Stop the hardware, regardless */
222 result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
223 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
224 printk(KERN_ERR "%s() acquire/forced stop transition "
225 "failed, res = 0x%x\n", __func__, result);
226 }
227 ret = -EIO;
228 goto out;
229 } else
230 dprintk(DBGLVL_DVB, "%s() Acquired\n", __func__);
231
232 /* Pause the hardware */
233 result = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
234 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
235 printk(KERN_ERR "%s() pause transition failed, res = 0x%x\n",
236 __func__, result);
237
238 /* Stop the hardware, regardless */
239 result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
240 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
241 printk(KERN_ERR "%s() pause/forced stop transition "
242 "failed, res = 0x%x\n", __func__, result);
243 }
244
245 ret = -EIO;
246 goto out;
247 } else
248 dprintk(DBGLVL_DVB, "%s() Paused\n", __func__);
249
250 /* Start the hardware */
251 result = saa7164_api_transition_port(port, SAA_DMASTATE_RUN);
252 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
253 printk(KERN_ERR "%s() run transition failed, result = 0x%x\n",
254 __func__, result);
255
256 /* Stop the hardware, regardless */
257 result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
258 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
259 printk(KERN_ERR "%s() run/forced stop transition "
260 "failed, res = 0x%x\n", __func__, result);
261 }
262
263 ret = -EIO;
264 } else
265 dprintk(DBGLVL_DVB, "%s() Running\n", __func__);
266
267out:
268 return ret;
269}
270
271static int saa7164_dvb_start_feed(struct dvb_demux_feed *feed)
272{
273 struct dvb_demux *demux = feed->demux;
274 struct saa7164_tsport *port = (struct saa7164_tsport *) demux->priv;
275 struct saa7164_dvb *dvb = &port->dvb;
276 struct saa7164_dev *dev = port->dev;
277 int ret = 0;
278
279 dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
280
281 if (!demux->dmx.frontend)
282 return -EINVAL;
283
284 if (dvb) {
285 mutex_lock(&dvb->lock);
286 if (dvb->feeding++ == 0) {
287 /* Start transport */
288 ret = saa7164_dvb_start_tsport(port);
289 }
290 mutex_unlock(&dvb->lock);
291 dprintk(DBGLVL_DVB, "%s(port=%d) now feeding = %d\n",
292 __func__, port->nr, dvb->feeding);
293 }
294
295 return ret;
296}
297
298static int saa7164_dvb_stop_feed(struct dvb_demux_feed *feed)
299{
300 struct dvb_demux *demux = feed->demux;
301 struct saa7164_tsport *port = (struct saa7164_tsport *) demux->priv;
302 struct saa7164_dvb *dvb = &port->dvb;
303 struct saa7164_dev *dev = port->dev;
304 int ret = 0;
305
306 dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
307
308 if (dvb) {
309 mutex_lock(&dvb->lock);
310 if (--dvb->feeding == 0) {
311 /* Stop transport */
312 ret = saa7164_dvb_stop_streaming(port);
313 }
314 mutex_unlock(&dvb->lock);
315 dprintk(DBGLVL_DVB, "%s(port=%d) now feeding = %d\n",
316 __func__, port->nr, dvb->feeding);
317 }
318
319 return ret;
320}
321
322static int dvb_register(struct saa7164_tsport *port)
323{
324 struct saa7164_dvb *dvb = &port->dvb;
325 struct saa7164_dev *dev = port->dev;
326 struct saa7164_buffer *buf;
327 int result, i;
328
329 dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
330
331 /* Sanity check that the PCI configuration space is active */
332 if (port->hwcfg.BARLocation == 0) {
333 result = -ENOMEM;
334 printk(KERN_ERR "%s: dvb_register_adapter failed "
335 "(errno = %d), NO PCI configuration\n",
336 DRIVER_NAME, result);
337 goto fail_adapter;
338 }
339
340 /* Init and establish defaults */
341 port->hw_streamingparams.bitspersample = 8;
342 port->hw_streamingparams.samplesperline = 188;
343 port->hw_streamingparams.numberoflines =
344 (SAA7164_TS_NUMBER_OF_LINES * 188) / 188;
345
346 port->hw_streamingparams.pitch = 188;
347 port->hw_streamingparams.linethreshold = 0;
348 port->hw_streamingparams.pagetablelistvirt = 0;
349 port->hw_streamingparams.pagetablelistphys = 0;
350 port->hw_streamingparams.numpagetables = 2 +
351 ((SAA7164_TS_NUMBER_OF_LINES * 188) / PAGE_SIZE);
352
353 port->hw_streamingparams.numpagetableentries = port->hwcfg.buffercount;
354
355 /* Allocate the PCI resources */
356 for (i = 0; i < port->hwcfg.buffercount; i++) {
357 buf = saa7164_buffer_alloc(port,
358 port->hw_streamingparams.numberoflines *
359 port->hw_streamingparams.pitch);
360
361 if (!buf) {
362 result = -ENOMEM;
363 printk(KERN_ERR "%s: dvb_register_adapter failed "
364 "(errno = %d), unable to allocate buffers\n",
365 DRIVER_NAME, result);
366 goto fail_adapter;
367 }
368 buf->nr = i;
369
370 mutex_lock(&port->dmaqueue_lock);
371 list_add_tail(&buf->list, &port->dmaqueue.list);
372 mutex_unlock(&port->dmaqueue_lock);
373 }
374
375 /* register adapter */
376 result = dvb_register_adapter(&dvb->adapter, DRIVER_NAME, THIS_MODULE,
377 &dev->pci->dev, adapter_nr);
378 if (result < 0) {
379 printk(KERN_ERR "%s: dvb_register_adapter failed "
380 "(errno = %d)\n", DRIVER_NAME, result);
381 goto fail_adapter;
382 }
383 dvb->adapter.priv = port;
384
385 /* register frontend */
386 result = dvb_register_frontend(&dvb->adapter, dvb->frontend);
387 if (result < 0) {
388 printk(KERN_ERR "%s: dvb_register_frontend failed "
389 "(errno = %d)\n", DRIVER_NAME, result);
390 goto fail_frontend;
391 }
392
393 /* register demux stuff */
394 dvb->demux.dmx.capabilities =
395 DMX_TS_FILTERING | DMX_SECTION_FILTERING |
396 DMX_MEMORY_BASED_FILTERING;
397 dvb->demux.priv = port;
398 dvb->demux.filternum = 256;
399 dvb->demux.feednum = 256;
400 dvb->demux.start_feed = saa7164_dvb_start_feed;
401 dvb->demux.stop_feed = saa7164_dvb_stop_feed;
402 result = dvb_dmx_init(&dvb->demux);
403 if (result < 0) {
404 printk(KERN_ERR "%s: dvb_dmx_init failed (errno = %d)\n",
405 DRIVER_NAME, result);
406 goto fail_dmx;
407 }
408
409 dvb->dmxdev.filternum = 256;
410 dvb->dmxdev.demux = &dvb->demux.dmx;
411 dvb->dmxdev.capabilities = 0;
412 result = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter);
413 if (result < 0) {
414 printk(KERN_ERR "%s: dvb_dmxdev_init failed (errno = %d)\n",
415 DRIVER_NAME, result);
416 goto fail_dmxdev;
417 }
418
419 dvb->fe_hw.source = DMX_FRONTEND_0;
420 result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_hw);
421 if (result < 0) {
422 printk(KERN_ERR "%s: add_frontend failed "
423 "(DMX_FRONTEND_0, errno = %d)\n", DRIVER_NAME, result);
424 goto fail_fe_hw;
425 }
426
427 dvb->fe_mem.source = DMX_MEMORY_FE;
428 result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_mem);
429 if (result < 0) {
430 printk(KERN_ERR "%s: add_frontend failed "
431 "(DMX_MEMORY_FE, errno = %d)\n", DRIVER_NAME, result);
432 goto fail_fe_mem;
433 }
434
435 result = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx, &dvb->fe_hw);
436 if (result < 0) {
437 printk(KERN_ERR "%s: connect_frontend failed (errno = %d)\n",
438 DRIVER_NAME, result);
439 goto fail_fe_conn;
440 }
441
442 /* register network adapter */
443 dvb_net_init(&dvb->adapter, &dvb->net, &dvb->demux.dmx);
444 return 0;
445
446fail_fe_conn:
447 dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
448fail_fe_mem:
449 dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
450fail_fe_hw:
451 dvb_dmxdev_release(&dvb->dmxdev);
452fail_dmxdev:
453 dvb_dmx_release(&dvb->demux);
454fail_dmx:
455 dvb_unregister_frontend(dvb->frontend);
456fail_frontend:
457 dvb_frontend_detach(dvb->frontend);
458 dvb_unregister_adapter(&dvb->adapter);
459fail_adapter:
460 return result;
461}
462
463int saa7164_dvb_unregister(struct saa7164_tsport *port)
464{
465 struct saa7164_dvb *dvb = &port->dvb;
466 struct saa7164_dev *dev = port->dev;
467 struct saa7164_buffer *b;
468 struct list_head *c, *n;
469
470 dprintk(DBGLVL_DVB, "%s()\n", __func__);
471
472 /* Remove any allocated buffers */
473 mutex_lock(&port->dmaqueue_lock);
474 list_for_each_safe(c, n, &port->dmaqueue.list) {
475 b = list_entry(c, struct saa7164_buffer, list);
476 list_del(c);
477 saa7164_buffer_dealloc(port, b);
478 }
479 mutex_unlock(&port->dmaqueue_lock);
480
481 if (dvb->frontend == NULL)
482 return 0;
483
484 dvb_net_release(&dvb->net);
485 dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
486 dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
487 dvb_dmxdev_release(&dvb->dmxdev);
488 dvb_dmx_release(&dvb->demux);
489 dvb_unregister_frontend(dvb->frontend);
490 dvb_frontend_detach(dvb->frontend);
491 dvb_unregister_adapter(&dvb->adapter);
492 return 0;
493}
494
495/* All the DVB attach calls go here, this function get's modified
496 * for each new card.
497 */
498int saa7164_dvb_register(struct saa7164_tsport *port)
499{
500 struct saa7164_dev *dev = port->dev;
501 struct saa7164_dvb *dvb = &port->dvb;
502 struct saa7164_i2c *i2c_bus = NULL;
503 int ret;
504
505 dprintk(DBGLVL_DVB, "%s()\n", __func__);
506
507 /* init frontend */
508 switch (dev->board) {
509 case SAA7164_BOARD_HAUPPAUGE_HVR2200:
510 case SAA7164_BOARD_HAUPPAUGE_HVR2200_2:
511 case SAA7164_BOARD_HAUPPAUGE_HVR2200_3:
512 switch (port->nr) {
513 case 0:
514 i2c_bus = &dev->i2c_bus[1];
515
516 port->dvb.frontend = dvb_attach(tda10048_attach,
517 &hauppauge_hvr2200_1_config,
518 &i2c_bus->i2c_adap);
519
520 if (port->dvb.frontend != NULL) {
521 dvb_attach(tda18271_attach, port->dvb.frontend,
522 0xc0 >> 1, &i2c_bus->i2c_adap,
523 &hauppauge_hvr22x0_tuner_config);
524 }
525
526 break;
527 case 1:
528 i2c_bus = &dev->i2c_bus[2];
529
530 port->dvb.frontend = dvb_attach(tda10048_attach,
531 &hauppauge_hvr2200_2_config,
532 &i2c_bus->i2c_adap);
533
534 if (port->dvb.frontend != NULL) {
535 dvb_attach(tda18271_attach, port->dvb.frontend,
536 0xc0 >> 1, &i2c_bus->i2c_adap,
537 &hauppauge_hvr22x0_tuner_config);
538 }
539
540 break;
541 }
542 break;
543 case SAA7164_BOARD_HAUPPAUGE_HVR2250:
544 case SAA7164_BOARD_HAUPPAUGE_HVR2250_2:
e3335222 545 case SAA7164_BOARD_HAUPPAUGE_HVR2250_3:
443c1228
ST		 546 i2c_bus = &dev->i2c_bus[port->nr + 1];
547
548 port->dvb.frontend = dvb_attach(s5h1411_attach,
549 &hauppauge_s5h1411_config,
550 &i2c_bus->i2c_adap);
551
552 if (port->dvb.frontend != NULL) {
553 /* TODO: addr is in the card struct */
554 dvb_attach(tda18271_attach, port->dvb.frontend,
555 0xc0 >> 1, &i2c_bus->i2c_adap,
556 &hauppauge_hvr22x0_tuner_config);
557 }
558
559 break;
560 default:
561 printk(KERN_ERR "%s: The frontend isn't supported\n",
562 dev->name);
563 break;
564 }
565 if (NULL == dvb->frontend) {
566 printk(KERN_ERR "%s() Frontend initialization failed\n",
567 __func__);
568 return -1;
569 }
570
571 /* Put the analog decoder in standby to keep it quiet */
572
573 /* register everything */
574 ret = dvb_register(port);
575 if (ret < 0) {
576 if (dvb->frontend->ops.release)
577 dvb->frontend->ops.release(dvb->frontend);
578 return ret;
579 }
580
581 return 0;
582}
583
Linux 6.x block layer and io_uring tree(s)