vesadrm.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2
  3#include <linux/aperture.h>
  4#include <linux/ioport.h>
  5#include <linux/limits.h>
  6#include <linux/platform_device.h>
  7#include <linux/screen_info.h>
  8
  9#include <drm/clients/drm_client_setup.h>
 10#include <drm/drm_atomic.h>
 11#include <drm/drm_atomic_state_helper.h>
 12#include <drm/drm_color_mgmt.h>
 13#include <drm/drm_connector.h>
 14#include <drm/drm_damage_helper.h>
 15#include <drm/drm_device.h>
 16#include <drm/drm_drv.h>
 17#include <drm/drm_edid.h>
 18#include <drm/drm_fbdev_shmem.h>
 19#include <drm/drm_framebuffer.h>
 20#include <drm/drm_gem_atomic_helper.h>
 21#include <drm/drm_gem_framebuffer_helper.h>
 22#include <drm/drm_gem_shmem_helper.h>
 23#include <drm/drm_managed.h>
 24#include <drm/drm_modeset_helper_vtables.h>
 25#include <drm/drm_print.h>
 26#include <drm/drm_probe_helper.h>
 27
 28#include <video/edid.h>
 29#include <video/pixel_format.h>
 30#include <video/vga.h>
 31
 32#include "drm_sysfb_helper.h"
 33
 34#define DRIVER_NAME	"vesadrm"
 35#define DRIVER_DESC	"DRM driver for VESA platform devices"
 36#define DRIVER_MAJOR	1
 37#define DRIVER_MINOR	0
 38
 39#define VESADRM_GAMMA_LUT_SIZE 256
 40
 41static const struct drm_format_info *vesadrm_get_format_si(struct drm_device *dev,
 42							   const struct screen_info *si)
 43{
 44	static const struct drm_sysfb_format formats[] = {
 45		{ PIXEL_FORMAT_XRGB1555, DRM_FORMAT_XRGB1555, },
 46		{ PIXEL_FORMAT_RGB565, DRM_FORMAT_RGB565, },
 47		{ PIXEL_FORMAT_RGB888, DRM_FORMAT_RGB888, },
 48		{ PIXEL_FORMAT_XRGB8888, DRM_FORMAT_XRGB8888, },
 49		{ PIXEL_FORMAT_XBGR8888, DRM_FORMAT_XBGR8888, },
 50		{ PIXEL_FORMAT_C8, DRM_FORMAT_C8, },
 51	};
 52
 53	return drm_sysfb_get_format_si(dev, formats, ARRAY_SIZE(formats), si);
 54}
 55
 56/*
 57 * VESA device
 58 */
 59
 60struct vesadrm_device {
 61	struct drm_sysfb_device sysfb;
 62
 63#if defined(CONFIG_X86_32)
 64	/* VESA Protected Mode interface */
 65	struct {
 66		const u8 *PrimaryPalette;
 67	} pmi;
 68#endif
 69
 70	void (*cmap_write)(struct vesadrm_device *vesa, unsigned int index,
 71			   u16 red, u16 green, u16 blue);
 72
 73	/* modesetting */
 74	u32 formats[DRM_SYSFB_PLANE_NFORMATS(1)];
 75	struct drm_plane primary_plane;
 76	struct drm_crtc crtc;
 77	struct drm_encoder encoder;
 78	struct drm_connector connector;
 79};
 80
 81static struct vesadrm_device *to_vesadrm_device(struct drm_device *dev)
 82{
 83	return container_of(to_drm_sysfb_device(dev), struct vesadrm_device, sysfb);
 84}
 85
 86/*
 87 * Color LUT
 88 */
 89
 90static void vesadrm_vga_cmap_write(struct vesadrm_device *vesa, unsigned int index,
 91				   u16 red, u16 green, u16 blue)
 92{
 93	u8 i8 = index;
 94	u8 r8 = red >> 8;
 95	u8 g8 = green >> 8;
 96	u8 b8 = blue >> 8;
 97
 98	outb_p(i8, VGA_PEL_IW);
 99	outb_p(r8, VGA_PEL_D);
100	outb_p(g8, VGA_PEL_D);
101	outb_p(b8, VGA_PEL_D);
102}
103
104#if defined(CONFIG_X86_32)
105static void vesadrm_pmi_cmap_write(struct vesadrm_device *vesa, unsigned int index,
106				   u16 red, u16 green, u16 blue)
107{
108	u32 i32 = index;
109	struct {
110		u8 b8;
111		u8 g8;
112		u8 r8;
113		u8 x8;
114	} PaletteEntry = {
115		blue >> 8,
116		green >> 8,
117		red >> 8,
118		0x00,
119	};
120
121	__asm__ __volatile__ (
122		"call *(%%esi)"
123		: /* no return value */
124		: "a" (0x4f09),
125		  "b" (0),
126		  "c" (1),
127		  "d" (i32),
128		  "D" (&PaletteEntry),
129		  "S" (&vesa->pmi.PrimaryPalette));
130}
131#endif
132
133static void vesadrm_set_color_lut(struct drm_crtc *crtc, unsigned int index,
134				  u16 red, u16 green, u16 blue)
135{
136	struct drm_device *dev = crtc->dev;
137	struct vesadrm_device *vesa = to_vesadrm_device(dev);
138	u8 i8 = index & 0xff;
139
140	if (drm_WARN_ON_ONCE(dev, index != i8))
141		return; /* driver bug */
142
143	vesa->cmap_write(vesa, i8, red, green, blue);
144}
145
146static void vesadrm_fill_gamma_lut(struct vesadrm_device *vesa,
147				   const struct drm_format_info *format)
148{
149	struct drm_device *dev = &vesa->sysfb.dev;
150	struct drm_crtc *crtc = &vesa->crtc;
151
152	switch (format->format) {
153	case DRM_FORMAT_XRGB1555:
154		drm_crtc_fill_gamma_555(crtc, vesadrm_set_color_lut);
155		break;
156	case DRM_FORMAT_RGB565:
157		drm_crtc_fill_gamma_565(crtc, vesadrm_set_color_lut);
158		break;
159	case DRM_FORMAT_RGB888:
160	case DRM_FORMAT_XRGB8888:
161	case DRM_FORMAT_BGRX8888:
162		drm_crtc_fill_gamma_888(crtc, vesadrm_set_color_lut);
163		break;
164	default:
165		drm_warn_once(dev, "Unsupported format %p4cc for gamma correction\n",
166			      &format->format);
167		break;
168	}
169}
170
171static void vesadrm_load_gamma_lut(struct vesadrm_device *vesa,
172				   const struct drm_format_info *format,
173				   struct drm_color_lut *lut)
174{
175	struct drm_device *dev = &vesa->sysfb.dev;
176	struct drm_crtc *crtc = &vesa->crtc;
177
178	switch (format->format) {
179	case DRM_FORMAT_XRGB1555:
180		drm_crtc_load_gamma_555_from_888(crtc, lut, vesadrm_set_color_lut);
181		break;
182	case DRM_FORMAT_RGB565:
183		drm_crtc_load_gamma_565_from_888(crtc, lut, vesadrm_set_color_lut);
184		break;
185	case DRM_FORMAT_RGB888:
186	case DRM_FORMAT_XRGB8888:
187	case DRM_FORMAT_BGRX8888:
188		drm_crtc_load_gamma_888(crtc, lut, vesadrm_set_color_lut);
189		break;
190	default:
191		drm_warn_once(dev, "Unsupported format %p4cc for gamma correction\n",
192			      &format->format);
193		break;
194	}
195}
196
197static void vesadrm_fill_palette_lut(struct vesadrm_device *vesa,
198				     const struct drm_format_info *format)
199{
200	struct drm_device *dev = &vesa->sysfb.dev;
201	struct drm_crtc *crtc = &vesa->crtc;
202
203	switch (format->format) {
204	case DRM_FORMAT_C8:
205		drm_crtc_fill_palette_8(crtc, vesadrm_set_color_lut);
206		break;
207	case DRM_FORMAT_RGB332:
208		drm_crtc_fill_palette_332(crtc, vesadrm_set_color_lut);
209		break;
210	default:
211		drm_warn_once(dev, "Unsupported format %p4cc for palette\n",
212			      &format->format);
213		break;
214	}
215}
216
217static void vesadrm_load_palette_lut(struct vesadrm_device *vesa,
218				     const struct drm_format_info *format,
219				     struct drm_color_lut *lut)
220{
221	struct drm_device *dev = &vesa->sysfb.dev;
222	struct drm_crtc *crtc = &vesa->crtc;
223
224	switch (format->format) {
225	case DRM_FORMAT_C8:
226		drm_crtc_load_palette_8(crtc, lut, vesadrm_set_color_lut);
227		break;
228	default:
229		drm_warn_once(dev, "Unsupported format %p4cc for gamma correction\n",
230			      &format->format);
231		break;
232	}
233}
234
235/*
236 * Modesetting
237 */
238
239static const u64 vesadrm_primary_plane_format_modifiers[] = {
240	DRM_SYSFB_PLANE_FORMAT_MODIFIERS,
241};
242
243static int vesadrm_primary_plane_helper_atomic_check(struct drm_plane *plane,
244						     struct drm_atomic_state *new_state)
245{
246	struct drm_sysfb_device *sysfb = to_drm_sysfb_device(plane->dev);
247	struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(new_state, plane);
248	struct drm_framebuffer *new_fb = new_plane_state->fb;
249	struct drm_crtc_state *new_crtc_state;
250	struct drm_sysfb_crtc_state *new_sysfb_crtc_state;
251	int ret;
252
253	ret = drm_sysfb_plane_helper_atomic_check(plane, new_state);
254	if (ret)
255		return ret;
256	else if (!new_plane_state->visible)
257		return 0;
258
259	/*
260	 * Fix up format conversion for specific cases
261	 */
262
263	switch (sysfb->fb_format->format) {
264	case DRM_FORMAT_C8:
265		new_crtc_state = drm_atomic_get_new_crtc_state(new_state, new_plane_state->crtc);
266		new_sysfb_crtc_state = to_drm_sysfb_crtc_state(new_crtc_state);
267
268		switch (new_fb->format->format) {
269		case DRM_FORMAT_XRGB8888:
270			/*
271			 * Reduce XRGB8888 to RGB332. Each resulting pixel is an index
272			 * into the C8 hardware palette, which stores RGB332 colors.
273			 */
274			if (new_sysfb_crtc_state->format->format != DRM_FORMAT_RGB332) {
275				new_sysfb_crtc_state->format =
276					drm_format_info(DRM_FORMAT_RGB332);
277				new_crtc_state->color_mgmt_changed = true;
278			}
279			break;
280		case DRM_FORMAT_C8:
281			/*
282			 * Restore original output. Emulation of XRGB8888 set RBG332
283			 * output format and hardware palette. This needs to be undone
284			 * when we switch back to DRM_FORMAT_C8.
285			 */
286			if (new_sysfb_crtc_state->format->format == DRM_FORMAT_RGB332) {
287				new_sysfb_crtc_state->format = sysfb->fb_format;
288				new_crtc_state->color_mgmt_changed = true;
289			}
290			break;
291		}
292		break;
293	}
294
295	return 0;
296}
297
298static const struct drm_plane_helper_funcs vesadrm_primary_plane_helper_funcs = {
299	.begin_fb_access = drm_sysfb_plane_helper_begin_fb_access,
300	.end_fb_access = drm_gem_end_shadow_fb_access,
301	.atomic_check = vesadrm_primary_plane_helper_atomic_check,
302	.atomic_update = drm_sysfb_plane_helper_atomic_update,
303	.atomic_disable = drm_sysfb_plane_helper_atomic_disable,
304	.get_scanout_buffer = drm_sysfb_plane_helper_get_scanout_buffer,
305};
306
307static const struct drm_plane_funcs vesadrm_primary_plane_funcs = {
308	DRM_SYSFB_PLANE_FUNCS,
309	.destroy = drm_plane_cleanup,
310};
311
312static void vesadrm_crtc_helper_atomic_flush(struct drm_crtc *crtc,
313					     struct drm_atomic_state *state)
314{
315	struct drm_device *dev = crtc->dev;
316	struct drm_sysfb_device *sysfb = to_drm_sysfb_device(dev);
317	struct vesadrm_device *vesa = to_vesadrm_device(dev);
318	struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
319	struct drm_sysfb_crtc_state *sysfb_crtc_state = to_drm_sysfb_crtc_state(crtc_state);
320
321	/*
322	 * The gamma LUT has to be reloaded after changing the primary
323	 * plane's color format.
324	 */
325	if (crtc_state->enable && crtc_state->color_mgmt_changed) {
326		switch (sysfb->fb_format->format) {
327		/*
328		 * Index formats
329		 */
330		case DRM_FORMAT_C8:
331			if (sysfb_crtc_state->format->format == DRM_FORMAT_RGB332) {
332				vesadrm_fill_palette_lut(vesa, sysfb_crtc_state->format);
333			} else if (crtc->state->gamma_lut) {
334				vesadrm_load_palette_lut(vesa,
335							 sysfb_crtc_state->format,
336							 crtc_state->gamma_lut->data);
337			} else {
338				vesadrm_fill_palette_lut(vesa, sysfb_crtc_state->format);
339			}
340			break;
341		/*
342		 * Component formats
343		 */
344		default:
345			if (sysfb_crtc_state->format == sysfb->fb_format) {
346				if (crtc_state->gamma_lut)
347					vesadrm_load_gamma_lut(vesa,
348							       sysfb_crtc_state->format,
349							       crtc_state->gamma_lut->data);
350				else
351					vesadrm_fill_gamma_lut(vesa, sysfb_crtc_state->format);
352			} else {
353				vesadrm_fill_gamma_lut(vesa, sysfb_crtc_state->format);
354			}
355			break;
356		}
357	}
358}
359
360static const struct drm_crtc_helper_funcs vesadrm_crtc_helper_funcs = {
361	DRM_SYSFB_CRTC_HELPER_FUNCS,
362	.atomic_flush = vesadrm_crtc_helper_atomic_flush,
363};
364
365static const struct drm_crtc_funcs vesadrm_crtc_funcs = {
366	DRM_SYSFB_CRTC_FUNCS,
367	.destroy = drm_crtc_cleanup,
368};
369
370static const struct drm_encoder_funcs vesadrm_encoder_funcs = {
371	.destroy = drm_encoder_cleanup,
372};
373
374static const struct drm_connector_helper_funcs vesadrm_connector_helper_funcs = {
375	DRM_SYSFB_CONNECTOR_HELPER_FUNCS,
376};
377
378static const struct drm_connector_funcs vesadrm_connector_funcs = {
379	DRM_SYSFB_CONNECTOR_FUNCS,
380	.destroy = drm_connector_cleanup,
381};
382
383static const struct drm_mode_config_funcs vesadrm_mode_config_funcs = {
384	DRM_SYSFB_MODE_CONFIG_FUNCS,
385};
386
387/*
388 * Init / Cleanup
389 */
390
391static struct vesadrm_device *vesadrm_device_create(struct drm_driver *drv,
392						    struct platform_device *pdev)
393{
394	const struct screen_info *si;
395	const struct drm_format_info *format;
396	int width, height, stride;
397	u64 vsize;
398	struct resource resbuf;
399	struct resource *res;
400	struct vesadrm_device *vesa;
401	struct drm_sysfb_device *sysfb;
402	struct drm_device *dev;
403	struct resource *mem = NULL;
404	void __iomem *screen_base;
405	struct drm_plane *primary_plane;
406	struct drm_crtc *crtc;
407	struct drm_encoder *encoder;
408	struct drm_connector *connector;
409	unsigned long max_width, max_height;
410	size_t nformats;
411	int ret;
412
413	si = dev_get_platdata(&pdev->dev);
414	if (!si)
415		return ERR_PTR(-ENODEV);
416	if (screen_info_video_type(si) != VIDEO_TYPE_VLFB)
417		return ERR_PTR(-ENODEV);
418
419	/*
420	 * VESA DRM driver
421	 */
422
423	vesa = devm_drm_dev_alloc(&pdev->dev, drv, struct vesadrm_device, sysfb.dev);
424	if (IS_ERR(vesa))
425		return ERR_CAST(vesa);
426	sysfb = &vesa->sysfb;
427	dev = &sysfb->dev;
428	platform_set_drvdata(pdev, dev);
429
430	/*
431	 * Hardware settings
432	 */
433
434	format = vesadrm_get_format_si(dev, si);
435	if (!format)
436		return ERR_PTR(-EINVAL);
437	width = drm_sysfb_get_width_si(dev, si);
438	if (width < 0)
439		return ERR_PTR(width);
440	height = drm_sysfb_get_height_si(dev, si);
441	if (height < 0)
442		return ERR_PTR(height);
443	res = drm_sysfb_get_memory_si(dev, si, &resbuf);
444	if (!res)
445		return ERR_PTR(-EINVAL);
446	stride = drm_sysfb_get_stride_si(dev, si, format, width, height, resource_size(res));
447	if (stride < 0)
448		return ERR_PTR(stride);
449	vsize = drm_sysfb_get_visible_size_si(dev, si, height, stride, resource_size(res));
450	if (!vsize)
451		return ERR_PTR(-EINVAL);
452
453	drm_dbg(dev, "framebuffer format=%p4cc, size=%dx%d, stride=%d bytes\n",
454		&format->format, width, height, stride);
455
456	if (!__screen_info_vbe_mode_nonvga(si)) {
457		vesa->cmap_write = vesadrm_vga_cmap_write;
458	} else {
459#if defined(CONFIG_X86_32)
460		phys_addr_t pmi_base = __screen_info_vesapm_info_base(si);
461
462		if (pmi_base) {
463			const u16 *pmi_addr = phys_to_virt(pmi_base);
464
465			vesa->pmi.PrimaryPalette = (u8 *)pmi_addr + pmi_addr[2];
466			vesa->cmap_write = vesadrm_pmi_cmap_write;
467		} else
468#endif
469		if (format->is_color_indexed)
470			drm_warn(dev, "hardware palette is unchangeable, colors may be incorrect\n");
471	}
472
473#if defined(CONFIG_FIRMWARE_EDID)
474	if (drm_edid_header_is_valid(edid_info.dummy) == 8)
475		sysfb->edid = edid_info.dummy;
476#endif
477	sysfb->fb_mode = drm_sysfb_mode(width, height, 0, 0);
478	sysfb->fb_format = format;
479	sysfb->fb_pitch = stride;
480	if (vesa->cmap_write)
481		sysfb->fb_gamma_lut_size = VESADRM_GAMMA_LUT_SIZE;
482
483	/*
484	 * Memory management
485	 */
486
487	ret = devm_aperture_acquire_for_platform_device(pdev, res->start, vsize);
488	if (ret) {
489		drm_err(dev, "could not acquire memory range %pr: %d\n", res, ret);
490		return ERR_PTR(ret);
491	}
492
493	drm_dbg(dev, "using I/O memory framebuffer at %pr\n", res);
494
495	mem = devm_request_mem_region(&pdev->dev, res->start, vsize, drv->name);
496	if (!mem) {
497		/*
498		 * We cannot make this fatal. Sometimes this comes from magic
499		 * spaces our resource handlers simply don't know about. Use
500		 * the I/O-memory resource as-is and try to map that instead.
501		 */
502		drm_warn(dev, "could not acquire memory region %pr\n", res);
503		mem = res;
504	}
505
506	screen_base = devm_ioremap_wc(&pdev->dev, mem->start, resource_size(mem));
507	if (!screen_base)
508		return ERR_PTR(-ENOMEM);
509	iosys_map_set_vaddr_iomem(&sysfb->fb_addr, screen_base);
510
511	/*
512	 * Modesetting
513	 */
514
515	ret = drmm_mode_config_init(dev);
516	if (ret)
517		return ERR_PTR(ret);
518
519	max_width = max_t(unsigned long, width, DRM_SHADOW_PLANE_MAX_WIDTH);
520	max_height = max_t(unsigned long, height, DRM_SHADOW_PLANE_MAX_HEIGHT);
521
522	dev->mode_config.min_width = width;
523	dev->mode_config.max_width = max_width;
524	dev->mode_config.min_height = height;
525	dev->mode_config.max_height = max_height;
526	dev->mode_config.preferred_depth = format->depth;
527	dev->mode_config.funcs = &vesadrm_mode_config_funcs;
528
529	/* Primary plane */
530
531	nformats = drm_sysfb_build_fourcc_list(dev, &format->format, 1,
532					       vesa->formats, ARRAY_SIZE(vesa->formats));
533
534	primary_plane = &vesa->primary_plane;
535	ret = drm_universal_plane_init(dev, primary_plane, 0, &vesadrm_primary_plane_funcs,
536				       vesa->formats, nformats,
537				       vesadrm_primary_plane_format_modifiers,
538				       DRM_PLANE_TYPE_PRIMARY, NULL);
539	if (ret)
540		return ERR_PTR(ret);
541	drm_plane_helper_add(primary_plane, &vesadrm_primary_plane_helper_funcs);
542	drm_plane_enable_fb_damage_clips(primary_plane);
543
544	/* CRTC */
545
546	crtc = &vesa->crtc;
547	ret = drm_crtc_init_with_planes(dev, crtc, primary_plane, NULL,
548					&vesadrm_crtc_funcs, NULL);
549	if (ret)
550		return ERR_PTR(ret);
551	drm_crtc_helper_add(crtc, &vesadrm_crtc_helper_funcs);
552
553	if (sysfb->fb_gamma_lut_size) {
554		ret = drm_mode_crtc_set_gamma_size(crtc, sysfb->fb_gamma_lut_size);
555		if (!ret)
556			drm_crtc_enable_color_mgmt(crtc, 0, false, sysfb->fb_gamma_lut_size);
557	}
558
559	/* Encoder */
560
561	encoder = &vesa->encoder;
562	ret = drm_encoder_init(dev, encoder, &vesadrm_encoder_funcs,
563			       DRM_MODE_ENCODER_NONE, NULL);
564	if (ret)
565		return ERR_PTR(ret);
566	encoder->possible_crtcs = drm_crtc_mask(crtc);
567
568	/* Connector */
569
570	connector = &vesa->connector;
571	ret = drm_connector_init(dev, connector, &vesadrm_connector_funcs,
572				 DRM_MODE_CONNECTOR_Unknown);
573	if (ret)
574		return ERR_PTR(ret);
575	drm_connector_helper_add(connector, &vesadrm_connector_helper_funcs);
576	drm_connector_set_panel_orientation_with_quirk(connector,
577						       DRM_MODE_PANEL_ORIENTATION_UNKNOWN,
578						       width, height);
579	if (sysfb->edid)
580		drm_connector_attach_edid_property(connector);
581
582	ret = drm_connector_attach_encoder(connector, encoder);
583	if (ret)
584		return ERR_PTR(ret);
585
586	drm_mode_config_reset(dev);
587
588	return vesa;
589}
590
591/*
592 * DRM driver
593 */
594
595DEFINE_DRM_GEM_FOPS(vesadrm_fops);
596
597static struct drm_driver vesadrm_driver = {
598	DRM_GEM_SHMEM_DRIVER_OPS,
599	DRM_FBDEV_SHMEM_DRIVER_OPS,
600	.name			= DRIVER_NAME,
601	.desc			= DRIVER_DESC,
602	.major			= DRIVER_MAJOR,
603	.minor			= DRIVER_MINOR,
604	.driver_features	= DRIVER_ATOMIC | DRIVER_GEM | DRIVER_MODESET,
605	.fops			= &vesadrm_fops,
606};
607
608/*
609 * Platform driver
610 */
611
612static int vesadrm_probe(struct platform_device *pdev)
613{
614	struct vesadrm_device *vesa;
615	struct drm_sysfb_device *sysfb;
616	struct drm_device *dev;
617	int ret;
618
619	vesa = vesadrm_device_create(&vesadrm_driver, pdev);
620	if (IS_ERR(vesa))
621		return PTR_ERR(vesa);
622	sysfb = &vesa->sysfb;
623	dev = &sysfb->dev;
624
625	ret = drm_dev_register(dev, 0);
626	if (ret)
627		return ret;
628
629	drm_client_setup(dev, sysfb->fb_format);
630
631	return 0;
632}
633
634static void vesadrm_remove(struct platform_device *pdev)
635{
636	struct drm_device *dev = platform_get_drvdata(pdev);
637
638	drm_dev_unplug(dev);
639}
640
641static struct platform_driver vesadrm_platform_driver = {
642	.driver = {
643		.name = "vesa-framebuffer",
644	},
645	.probe = vesadrm_probe,
646	.remove = vesadrm_remove,
647};
648
649module_platform_driver(vesadrm_platform_driver);
650
651MODULE_DESCRIPTION(DRIVER_DESC);
652MODULE_LICENSE("GPL");