2 * Copyright © 2006-2011 Intel Corporation
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms and conditions of the GNU General Public License,
6 * version 2, as published by the Free Software Foundation.
8 * This program is distributed in the hope it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc.,
15 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
18 * Eric Anholt <eric@anholt.net>
19 * Dave Airlie <airlied@linux.ie>
20 * Jesse Barnes <jesse.barnes@intel.com>
23 #include <linux/i2c.h>
24 #include <linux/dmi.h>
27 #include "intel_bios.h"
29 #include "psb_intel_drv.h"
30 #include "psb_intel_reg.h"
32 #include <linux/pm_runtime.h>
33 #include "cdv_device.h"
36 * LVDS I2C backlight control macros
38 #define BRIGHTNESS_MAX_LEVEL 100
39 #define BRIGHTNESS_MASK 0xFF
40 #define BLC_I2C_TYPE 0x01
41 #define BLC_PWM_TYPT 0x02
43 #define BLC_POLARITY_NORMAL 0
44 #define BLC_POLARITY_INVERSE 1
46 #define PSB_BLC_MAX_PWM_REG_FREQ (0xFFFE)
47 #define PSB_BLC_MIN_PWM_REG_FREQ (0x2)
48 #define PSB_BLC_PWM_PRECISION_FACTOR (10)
49 #define PSB_BACKLIGHT_PWM_CTL_SHIFT (16)
50 #define PSB_BACKLIGHT_PWM_POLARITY_BIT_CLEAR (0xFFFE)
52 struct cdv_intel_lvds_priv
{
54 * Saved LVDO output states
59 uint32_t savePP_CONTROL
;
60 uint32_t savePP_CYCLE
;
61 uint32_t savePFIT_CONTROL
;
62 uint32_t savePFIT_PGM_RATIOS
;
63 uint32_t saveBLC_PWM_CTL
;
67 * Returns the maximum level of the backlight duty cycle field.
69 static u32
cdv_intel_lvds_get_max_backlight(struct drm_device
*dev
)
71 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
74 if (gma_power_begin(dev
, false)) {
75 retval
= ((REG_READ(BLC_PWM_CTL
) &
76 BACKLIGHT_MODULATION_FREQ_MASK
) >>
77 BACKLIGHT_MODULATION_FREQ_SHIFT
) * 2;
81 retval
= ((dev_priv
->saveBLC_PWM_CTL
&
82 BACKLIGHT_MODULATION_FREQ_MASK
) >>
83 BACKLIGHT_MODULATION_FREQ_SHIFT
) * 2;
89 * Set LVDS backlight level by I2C command
91 static int cdv_lvds_i2c_set_brightness(struct drm_device
*dev
,
94 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
95 struct psb_intel_i2c_chan
*lvds_i2c_bus
= dev_priv
->lvds_i2c_bus
;
97 unsigned int blc_i2c_brightness
;
99 struct i2c_msg msgs
[] = {
101 .addr
= lvds_i2c_bus
->slave_addr
,
108 blc_i2c_brightness
= BRIGHTNESS_MASK
& ((unsigned int)level
*
110 BRIGHTNESS_MAX_LEVEL
);
112 if (dev_priv
->lvds_bl
->pol
== BLC_POLARITY_INVERSE
)
113 blc_i2c_brightness
= BRIGHTNESS_MASK
- blc_i2c_brightness
;
115 out_buf
[0] = dev_priv
->lvds_bl
->brightnesscmd
;
116 out_buf
[1] = (u8
)blc_i2c_brightness
;
118 if (i2c_transfer(&lvds_i2c_bus
->adapter
, msgs
, 1) == 1)
121 DRM_ERROR("I2C transfer error\n");
126 static int cdv_lvds_pwm_set_brightness(struct drm_device
*dev
, int level
)
128 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
131 u32 blc_pwm_duty_cycle
;
133 max_pwm_blc
= cdv_intel_lvds_get_max_backlight(dev
);
135 /*BLC_PWM_CTL Should be initiated while backlight device init*/
136 BUG_ON((max_pwm_blc
& PSB_BLC_MAX_PWM_REG_FREQ
) == 0);
138 blc_pwm_duty_cycle
= level
* max_pwm_blc
/ BRIGHTNESS_MAX_LEVEL
;
140 if (dev_priv
->lvds_bl
->pol
== BLC_POLARITY_INVERSE
)
141 blc_pwm_duty_cycle
= max_pwm_blc
- blc_pwm_duty_cycle
;
143 blc_pwm_duty_cycle
&= PSB_BACKLIGHT_PWM_POLARITY_BIT_CLEAR
;
144 REG_WRITE(BLC_PWM_CTL
,
145 (max_pwm_blc
<< PSB_BACKLIGHT_PWM_CTL_SHIFT
) |
146 (blc_pwm_duty_cycle
));
152 * Set LVDS backlight level either by I2C or PWM
154 void cdv_intel_lvds_set_brightness(struct drm_device
*dev
, int level
)
156 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
158 if (!dev_priv
->lvds_bl
) {
159 DRM_ERROR("NO LVDS Backlight Info\n");
163 if (dev_priv
->lvds_bl
->type
== BLC_I2C_TYPE
)
164 cdv_lvds_i2c_set_brightness(dev
, level
);
166 cdv_lvds_pwm_set_brightness(dev
, level
);
170 * Sets the backlight level.
172 * level backlight level, from 0 to cdv_intel_lvds_get_max_backlight().
174 static void cdv_intel_lvds_set_backlight(struct drm_device
*dev
, int level
)
176 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
179 if (gma_power_begin(dev
, false)) {
181 REG_READ(BLC_PWM_CTL
) & ~BACKLIGHT_DUTY_CYCLE_MASK
;
182 REG_WRITE(BLC_PWM_CTL
,
184 (level
<< BACKLIGHT_DUTY_CYCLE_SHIFT
)));
187 blc_pwm_ctl
= dev_priv
->saveBLC_PWM_CTL
&
188 ~BACKLIGHT_DUTY_CYCLE_MASK
;
189 dev_priv
->saveBLC_PWM_CTL
= (blc_pwm_ctl
|
190 (level
<< BACKLIGHT_DUTY_CYCLE_SHIFT
));
195 * Sets the power state for the panel.
197 static void cdv_intel_lvds_set_power(struct drm_device
*dev
,
198 struct psb_intel_output
*output
, bool on
)
202 if (!gma_power_begin(dev
, true))
206 REG_WRITE(PP_CONTROL
, REG_READ(PP_CONTROL
) |
209 pp_status
= REG_READ(PP_STATUS
);
210 } while ((pp_status
& PP_ON
) == 0);
212 cdv_intel_lvds_set_backlight(dev
,
214 mode_dev
->backlight_duty_cycle
);
216 cdv_intel_lvds_set_backlight(dev
, 0);
218 REG_WRITE(PP_CONTROL
, REG_READ(PP_CONTROL
) &
221 pp_status
= REG_READ(PP_STATUS
);
222 } while (pp_status
& PP_ON
);
227 static void cdv_intel_lvds_encoder_dpms(struct drm_encoder
*encoder
, int mode
)
229 struct drm_device
*dev
= encoder
->dev
;
230 struct psb_intel_output
*output
= enc_to_psb_intel_output(encoder
);
231 if (mode
== DRM_MODE_DPMS_ON
)
232 cdv_intel_lvds_set_power(dev
, output
, true);
234 cdv_intel_lvds_set_power(dev
, output
, false);
235 /* XXX: We never power down the LVDS pairs. */
238 static void cdv_intel_lvds_save(struct drm_connector
*connector
)
242 static void cdv_intel_lvds_restore(struct drm_connector
*connector
)
246 int cdv_intel_lvds_mode_valid(struct drm_connector
*connector
,
247 struct drm_display_mode
*mode
)
249 struct psb_intel_output
*psb_intel_output
=
250 to_psb_intel_output(connector
);
251 struct drm_display_mode
*fixed_mode
=
252 psb_intel_output
->mode_dev
->panel_fixed_mode
;
255 if (mode
->flags
& DRM_MODE_FLAG_DBLSCAN
)
256 return MODE_NO_DBLESCAN
;
259 if (mode
->flags
& DRM_MODE_FLAG_INTERLACE
)
260 return MODE_NO_INTERLACE
;
263 if (mode
->hdisplay
> fixed_mode
->hdisplay
)
265 if (mode
->vdisplay
> fixed_mode
->vdisplay
)
271 bool cdv_intel_lvds_mode_fixup(struct drm_encoder
*encoder
,
272 struct drm_display_mode
*mode
,
273 struct drm_display_mode
*adjusted_mode
)
275 struct psb_intel_mode_device
*mode_dev
=
276 enc_to_psb_intel_output(encoder
)->mode_dev
;
277 struct drm_device
*dev
= encoder
->dev
;
278 struct drm_encoder
*tmp_encoder
;
279 struct drm_display_mode
*panel_fixed_mode
= mode_dev
->panel_fixed_mode
;
281 /* Should never happen!! */
282 list_for_each_entry(tmp_encoder
, &dev
->mode_config
.encoder_list
,
284 if (tmp_encoder
!= encoder
285 && tmp_encoder
->crtc
== encoder
->crtc
) {
286 printk(KERN_ERR
"Can't enable LVDS and another "
287 "encoder on the same pipe\n");
293 * If we have timings from the BIOS for the panel, put them in
294 * to the adjusted mode. The CRTC will be set up for this mode,
295 * with the panel scaling set up to source from the H/VDisplay
296 * of the original mode.
298 if (panel_fixed_mode
!= NULL
) {
299 adjusted_mode
->hdisplay
= panel_fixed_mode
->hdisplay
;
300 adjusted_mode
->hsync_start
= panel_fixed_mode
->hsync_start
;
301 adjusted_mode
->hsync_end
= panel_fixed_mode
->hsync_end
;
302 adjusted_mode
->htotal
= panel_fixed_mode
->htotal
;
303 adjusted_mode
->vdisplay
= panel_fixed_mode
->vdisplay
;
304 adjusted_mode
->vsync_start
= panel_fixed_mode
->vsync_start
;
305 adjusted_mode
->vsync_end
= panel_fixed_mode
->vsync_end
;
306 adjusted_mode
->vtotal
= panel_fixed_mode
->vtotal
;
307 adjusted_mode
->clock
= panel_fixed_mode
->clock
;
308 drm_mode_set_crtcinfo(adjusted_mode
,
309 CRTC_INTERLACE_HALVE_V
);
313 * XXX: It would be nice to support lower refresh rates on the
314 * panels to reduce power consumption, and perhaps match the
315 * user's requested refresh rate.
321 static void cdv_intel_lvds_prepare(struct drm_encoder
*encoder
)
323 struct drm_device
*dev
= encoder
->dev
;
324 struct psb_intel_output
*output
= enc_to_psb_intel_output(encoder
);
325 struct psb_intel_mode_device
*mode_dev
= output
->mode_dev
;
327 if (!gma_power_begin(dev
, true))
330 mode_dev
->saveBLC_PWM_CTL
= REG_READ(BLC_PWM_CTL
);
331 mode_dev
->backlight_duty_cycle
= (mode_dev
->saveBLC_PWM_CTL
&
332 BACKLIGHT_DUTY_CYCLE_MASK
);
334 cdv_intel_lvds_set_power(dev
, output
, false);
339 static void cdv_intel_lvds_commit(struct drm_encoder
*encoder
)
341 struct drm_device
*dev
= encoder
->dev
;
342 struct psb_intel_output
*output
= enc_to_psb_intel_output(encoder
);
343 struct psb_intel_mode_device
*mode_dev
= output
->mode_dev
;
345 if (mode_dev
->backlight_duty_cycle
== 0)
346 mode_dev
->backlight_duty_cycle
=
347 cdv_intel_lvds_get_max_backlight(dev
);
349 cdv_intel_lvds_set_power(dev
, output
, true);
352 static void cdv_intel_lvds_mode_set(struct drm_encoder
*encoder
,
353 struct drm_display_mode
*mode
,
354 struct drm_display_mode
*adjusted_mode
)
356 struct psb_intel_mode_device
*mode_dev
=
357 enc_to_psb_intel_output(encoder
)->mode_dev
;
358 struct drm_device
*dev
= encoder
->dev
;
362 * The LVDS pin pair will already have been turned on in the
363 * cdv_intel_crtc_mode_set since it has a large impact on the DPLL
368 * Enable automatic panel scaling so that non-native modes fill the
369 * screen. Should be enabled before the pipe is enabled, according to
370 * register description and PRM.
372 if (mode
->hdisplay
!= adjusted_mode
->hdisplay
||
373 mode
->vdisplay
!= adjusted_mode
->vdisplay
)
374 pfit_control
= (PFIT_ENABLE
| VERT_AUTO_SCALE
|
375 HORIZ_AUTO_SCALE
| VERT_INTERP_BILINEAR
|
376 HORIZ_INTERP_BILINEAR
);
380 if (mode_dev
->panel_wants_dither
)
381 pfit_control
|= PANEL_8TO6_DITHER_ENABLE
;
383 REG_WRITE(PFIT_CONTROL
, pfit_control
);
387 * Detect the LVDS connection.
389 * This always returns CONNECTOR_STATUS_CONNECTED.
390 * This connector should only have
391 * been set up if the LVDS was actually connected anyway.
393 static enum drm_connector_status
cdv_intel_lvds_detect(
394 struct drm_connector
*connector
, bool force
)
396 return connector_status_connected
;
400 * Return the list of DDC modes if available, or the BIOS fixed mode otherwise.
402 static int cdv_intel_lvds_get_modes(struct drm_connector
*connector
)
404 struct drm_device
*dev
= connector
->dev
;
405 struct psb_intel_output
*psb_intel_output
=
406 to_psb_intel_output(connector
);
407 struct psb_intel_mode_device
*mode_dev
=
408 psb_intel_output
->mode_dev
;
411 ret
= psb_intel_ddc_get_modes(psb_intel_output
);
416 /* Didn't get an EDID, so
417 * Set wide sync ranges so we get all modes
418 * handed to valid_mode for checking
420 connector
->display_info
.min_vfreq
= 0;
421 connector
->display_info
.max_vfreq
= 200;
422 connector
->display_info
.min_hfreq
= 0;
423 connector
->display_info
.max_hfreq
= 200;
424 if (mode_dev
->panel_fixed_mode
!= NULL
) {
425 struct drm_display_mode
*mode
=
426 drm_mode_duplicate(dev
, mode_dev
->panel_fixed_mode
);
427 drm_mode_probed_add(connector
, mode
);
435 * cdv_intel_lvds_destroy - unregister and free LVDS structures
436 * @connector: connector to free
438 * Unregister the DDC bus for this connector then free the driver private
441 void cdv_intel_lvds_destroy(struct drm_connector
*connector
)
443 struct psb_intel_output
*psb_intel_output
=
444 to_psb_intel_output(connector
);
446 if (psb_intel_output
->ddc_bus
)
447 psb_intel_i2c_destroy(psb_intel_output
->ddc_bus
);
448 drm_sysfs_connector_remove(connector
);
449 drm_connector_cleanup(connector
);
453 int cdv_intel_lvds_set_property(struct drm_connector
*connector
,
454 struct drm_property
*property
,
457 struct drm_encoder
*encoder
= connector
->encoder
;
459 if (!strcmp(property
->name
, "scaling mode") && encoder
) {
460 struct psb_intel_crtc
*crtc
=
461 to_psb_intel_crtc(encoder
->crtc
);
468 case DRM_MODE_SCALE_FULLSCREEN
:
470 case DRM_MODE_SCALE_NO_SCALE
:
472 case DRM_MODE_SCALE_ASPECT
:
478 if (drm_connector_property_get_value(connector
,
483 if (curValue
== value
)
486 if (drm_connector_property_set_value(connector
,
491 if (crtc
->saved_mode
.hdisplay
!= 0 &&
492 crtc
->saved_mode
.vdisplay
!= 0) {
493 if (!drm_crtc_helper_set_mode(encoder
->crtc
,
500 } else if (!strcmp(property
->name
, "backlight") && encoder
) {
501 if (drm_connector_property_set_value(connector
,
506 #ifdef CONFIG_BACKLIGHT_CLASS_DEVICE
507 struct drm_psb_private
*dev_priv
=
508 encoder
->dev
->dev_private
;
509 struct backlight_device
*bd
=
510 dev_priv
->backlight_device
;
511 bd
->props
.brightness
= value
;
512 backlight_update_status(bd
);
515 } else if (!strcmp(property
->name
, "DPMS") && encoder
) {
516 struct drm_encoder_helper_funcs
*helpers
=
517 encoder
->helper_private
;
518 helpers
->dpms(encoder
, value
);
523 static const struct drm_encoder_helper_funcs
524 cdv_intel_lvds_helper_funcs
= {
525 .dpms
= cdv_intel_lvds_encoder_dpms
,
526 .mode_fixup
= cdv_intel_lvds_mode_fixup
,
527 .prepare
= cdv_intel_lvds_prepare
,
528 .mode_set
= cdv_intel_lvds_mode_set
,
529 .commit
= cdv_intel_lvds_commit
,
532 static const struct drm_connector_helper_funcs
533 cdv_intel_lvds_connector_helper_funcs
= {
534 .get_modes
= cdv_intel_lvds_get_modes
,
535 .mode_valid
= cdv_intel_lvds_mode_valid
,
536 .best_encoder
= psb_intel_best_encoder
,
539 static const struct drm_connector_funcs cdv_intel_lvds_connector_funcs
= {
540 .dpms
= drm_helper_connector_dpms
,
541 .save
= cdv_intel_lvds_save
,
542 .restore
= cdv_intel_lvds_restore
,
543 .detect
= cdv_intel_lvds_detect
,
544 .fill_modes
= drm_helper_probe_single_connector_modes
,
545 .set_property
= cdv_intel_lvds_set_property
,
546 .destroy
= cdv_intel_lvds_destroy
,
550 static void cdv_intel_lvds_enc_destroy(struct drm_encoder
*encoder
)
552 drm_encoder_cleanup(encoder
);
555 const struct drm_encoder_funcs cdv_intel_lvds_enc_funcs
= {
556 .destroy
= cdv_intel_lvds_enc_destroy
,
560 * cdv_intel_lvds_init - setup LVDS connectors on this device
563 * Create the connector, register the LVDS DDC bus, and try to figure out what
564 * modes we can display on the LVDS panel (if present).
566 void cdv_intel_lvds_init(struct drm_device
*dev
,
567 struct psb_intel_mode_device
*mode_dev
)
569 struct psb_intel_output
*psb_intel_output
;
570 struct cdv_intel_lvds_priv
*lvds_priv
;
571 struct drm_connector
*connector
;
572 struct drm_encoder
*encoder
;
573 struct drm_display_mode
*scan
;
574 struct drm_crtc
*crtc
;
575 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
579 psb_intel_output
= kzalloc(sizeof(struct psb_intel_output
) +
580 sizeof(struct cdv_intel_lvds_priv
), GFP_KERNEL
);
581 if (!psb_intel_output
)
584 lvds_priv
= (struct cdv_intel_lvds_priv
*)(psb_intel_output
+ 1);
586 psb_intel_output
->dev_priv
= lvds_priv
;
588 psb_intel_output
->mode_dev
= mode_dev
;
589 connector
= &psb_intel_output
->base
;
590 encoder
= &psb_intel_output
->enc
;
593 drm_connector_init(dev
, &psb_intel_output
->base
,
594 &cdv_intel_lvds_connector_funcs
,
595 DRM_MODE_CONNECTOR_LVDS
);
597 drm_encoder_init(dev
, &psb_intel_output
->enc
,
598 &cdv_intel_lvds_enc_funcs
,
599 DRM_MODE_ENCODER_LVDS
);
602 drm_mode_connector_attach_encoder(&psb_intel_output
->base
,
603 &psb_intel_output
->enc
);
604 psb_intel_output
->type
= INTEL_OUTPUT_LVDS
;
606 drm_encoder_helper_add(encoder
, &cdv_intel_lvds_helper_funcs
);
607 drm_connector_helper_add(connector
,
608 &cdv_intel_lvds_connector_helper_funcs
);
609 connector
->display_info
.subpixel_order
= SubPixelHorizontalRGB
;
610 connector
->interlace_allowed
= false;
611 connector
->doublescan_allowed
= false;
613 /*Attach connector properties*/
614 drm_connector_attach_property(connector
,
615 dev
->mode_config
.scaling_mode_property
,
616 DRM_MODE_SCALE_FULLSCREEN
);
617 drm_connector_attach_property(connector
,
618 dev_priv
->backlight_property
,
619 BRIGHTNESS_MAX_LEVEL
);
623 * FIXME: distroy i2c_bus when exit
625 psb_intel_output
->i2c_bus
= psb_intel_i2c_create(dev
,
628 if (!psb_intel_output
->i2c_bus
) {
630 &dev
->pdev
->dev
, "I2C bus registration failed.\n");
633 psb_intel_output
->i2c_bus
->slave_addr
= 0x2C;
634 dev_priv
->lvds_i2c_bus
= psb_intel_output
->i2c_bus
;
638 * 1) check for EDID on DDC
639 * 2) check for VBT data
640 * 3) check to see if LVDS is already on
641 * if none of the above, no panel
642 * 4) make sure lid is open
643 * if closed, act like it's not there for now
646 /* Set up the DDC bus. */
647 psb_intel_output
->ddc_bus
= psb_intel_i2c_create(dev
,
650 if (!psb_intel_output
->ddc_bus
) {
651 dev_printk(KERN_ERR
, &dev
->pdev
->dev
,
652 "DDC bus registration " "failed.\n");
657 * Attempt to get the fixed panel mode from DDC. Assume that the
658 * preferred mode is the right one.
660 psb_intel_ddc_get_modes(psb_intel_output
);
661 list_for_each_entry(scan
, &connector
->probed_modes
, head
) {
662 if (scan
->type
& DRM_MODE_TYPE_PREFERRED
) {
663 mode_dev
->panel_fixed_mode
=
664 drm_mode_duplicate(dev
, scan
);
665 goto out
; /* FIXME: check for quirks */
669 /* Failed to get EDID, what about VBT? do we need this?*/
670 if (dev_priv
->lfp_lvds_vbt_mode
) {
671 mode_dev
->panel_fixed_mode
=
672 drm_mode_duplicate(dev
, dev_priv
->lfp_lvds_vbt_mode
);
673 if (mode_dev
->panel_fixed_mode
) {
674 mode_dev
->panel_fixed_mode
->type
|=
675 DRM_MODE_TYPE_PREFERRED
;
676 goto out
; /* FIXME: check for quirks */
680 * If we didn't get EDID, try checking if the panel is already turned
681 * on. If so, assume that whatever is currently programmed is the
684 lvds
= REG_READ(LVDS
);
685 pipe
= (lvds
& LVDS_PIPEB_SELECT
) ? 1 : 0;
686 crtc
= psb_intel_get_crtc_from_pipe(dev
, pipe
);
688 if (crtc
&& (lvds
& LVDS_PORT_EN
)) {
689 mode_dev
->panel_fixed_mode
=
690 cdv_intel_crtc_mode_get(dev
, crtc
);
691 if (mode_dev
->panel_fixed_mode
) {
692 mode_dev
->panel_fixed_mode
->type
|=
693 DRM_MODE_TYPE_PREFERRED
;
694 goto out
; /* FIXME: check for quirks */
698 /* If we still don't have a mode after all that, give up. */
699 if (!mode_dev
->panel_fixed_mode
) {
701 ("Found no modes on the lvds, ignoring the LVDS\n");
706 drm_sysfs_connector_add(connector
);
710 printk(KERN_ERR
"Failed find\n");
711 if (psb_intel_output
->ddc_bus
)
712 psb_intel_i2c_destroy(psb_intel_output
->ddc_bus
);
714 printk(KERN_ERR
"Failed DDC\n");
715 if (psb_intel_output
->i2c_bus
)
716 psb_intel_i2c_destroy(psb_intel_output
->i2c_bus
);
718 printk(KERN_ERR
"Failed BLC\n");
719 drm_encoder_cleanup(encoder
);
720 drm_connector_cleanup(connector
);