drivers/gpu/drm/i915/intel_opregion.c

   1 /*
   2  * Copyright 2008 Intel Corporation <hong.liu@intel.com>
   3  * Copyright 2008 Red Hat <mjg@redhat.com>
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining
   6  * a copy of this software and associated documentation files (the
   7  * "Software"), to deal in the Software without restriction, including
   8  * without limitation the rights to use, copy, modify, merge, publish,
   9  * distribute, sub license, and/or sell copies of the Software, and to
  10  * permit persons to whom the Software is furnished to do so, subject to
  11  * the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the
  14  * next paragraph) shall be included in all copies or substantial
  15  * portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  18  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  20  * NON-INFRINGEMENT.  IN NO EVENT SHALL INTEL AND/OR ITS SUPPLIERS BE
  21  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  22  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  23  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  24  * SOFTWARE.
  25  *
  26  */
  27
  28 #include <linux/acpi.h>
  29 #include <acpi/video.h>
  30
  31 #include "drmP.h"
  32 #include "i915_drm.h"
  33 #include "i915_drv.h"
  34
  35 #define PCI_ASLE 0xe4
  36 #define PCI_LBPC 0xf4
  37 #define PCI_ASLS 0xfc
  38
  39 #define OPREGION_HEADER_OFFSET 0
  40 #define OPREGION_ACPI_OFFSET   0x100
  41 #define OPREGION_SWSCI_OFFSET  0x200
  42 #define OPREGION_ASLE_OFFSET   0x300
  43 #define OPREGION_VBT_OFFSET    0x400
  44
  45 #define OPREGION_SIGNATURE "IntelGraphicsMem"
  46 #define MBOX_ACPI      (1<<0)
  47 #define MBOX_SWSCI     (1<<1)
  48 #define MBOX_ASLE      (1<<2)
  49
  50 struct opregion_header {
  51        u8 signature[16];
  52        u32 size;
  53        u32 opregion_ver;
  54        u8 bios_ver[32];
  55        u8 vbios_ver[16];
  56        u8 driver_ver[16];
  57        u32 mboxes;
  58        u8 reserved[164];
  59 } __attribute__((packed));
  60
  61 /* OpRegion mailbox #1: public ACPI methods */
  62 struct opregion_acpi {
  63        u32 drdy;       /* driver readiness */
  64        u32 csts;       /* notification status */
  65        u32 cevt;       /* current event */
  66        u8 rsvd1[20];
  67        u32 didl[8];    /* supported display devices ID list */
  68        u32 cpdl[8];    /* currently presented display list */
  69        u32 cadl[8];    /* currently active display list */
  70        u32 nadl[8];    /* next active devices list */
  71        u32 aslp;       /* ASL sleep time-out */
  72        u32 tidx;       /* toggle table index */
  73        u32 chpd;       /* current hotplug enable indicator */
  74        u32 clid;       /* current lid state*/
  75        u32 cdck;       /* current docking state */
  76        u32 sxsw;       /* Sx state resume */
  77        u32 evts;       /* ASL supported events */
  78        u32 cnot;       /* current OS notification */
  79        u32 nrdy;       /* driver status */
  80        u8 rsvd2[60];
  81 } __attribute__((packed));
  82
  83 /* OpRegion mailbox #2: SWSCI */
  84 struct opregion_swsci {
  85        u32 scic;       /* SWSCI command|status|data */
  86        u32 parm;       /* command parameters */
  87        u32 dslp;       /* driver sleep time-out */
  88        u8 rsvd[244];
  89 } __attribute__((packed));
  90
  91 /* OpRegion mailbox #3: ASLE */
  92 struct opregion_asle {
  93        u32 ardy;       /* driver readiness */
  94        u32 aslc;       /* ASLE interrupt command */
  95        u32 tche;       /* technology enabled indicator */
  96        u32 alsi;       /* current ALS illuminance reading */
  97        u32 bclp;       /* backlight brightness to set */
  98        u32 pfit;       /* panel fitting state */
  99        u32 cblv;       /* current brightness level */
 100        u16 bclm[20];   /* backlight level duty cycle mapping table */
 101        u32 cpfm;       /* current panel fitting mode */
 102        u32 epfm;       /* enabled panel fitting modes */
 103        u8 plut[74];    /* panel LUT and identifier */
 104        u32 pfmb;       /* PWM freq and min brightness */
 105        u8 rsvd[102];
 106 } __attribute__((packed));
 107
 108 /* ASLE irq request bits */
 109 #define ASLE_SET_ALS_ILLUM     (1 << 0)
 110 #define ASLE_SET_BACKLIGHT     (1 << 1)
 111 #define ASLE_SET_PFIT          (1 << 2)
 112 #define ASLE_SET_PWM_FREQ      (1 << 3)
 113 #define ASLE_REQ_MSK           0xf
 114
 115 /* response bits of ASLE irq request */
 116 #define ASLE_ALS_ILLUM_FAILED   (1<<10)
 117 #define ASLE_BACKLIGHT_FAILED   (1<<12)
 118 #define ASLE_PFIT_FAILED        (1<<14)
 119 #define ASLE_PWM_FREQ_FAILED    (1<<16)
 120
 121 /* ASLE backlight brightness to set */
 122 #define ASLE_BCLP_VALID                (1<<31)
 123 #define ASLE_BCLP_MSK          (~(1<<31))
 124
 125 /* ASLE panel fitting request */
 126 #define ASLE_PFIT_VALID         (1<<31)
 127 #define ASLE_PFIT_CENTER (1<<0)
 128 #define ASLE_PFIT_STRETCH_TEXT (1<<1)
 129 #define ASLE_PFIT_STRETCH_GFX (1<<2)
 130
 131 /* PWM frequency and minimum brightness */
 132 #define ASLE_PFMB_BRIGHTNESS_MASK (0xff)
 133 #define ASLE_PFMB_BRIGHTNESS_VALID (1<<8)
 134 #define ASLE_PFMB_PWM_MASK (0x7ffffe00)
 135 #define ASLE_PFMB_PWM_VALID (1<<31)
 136
 137 #define ASLE_CBLV_VALID         (1<<31)
 138
 139 #define ACPI_OTHER_OUTPUT (0<<8)
 140 #define ACPI_VGA_OUTPUT (1<<8)
 141 #define ACPI_TV_OUTPUT (2<<8)
 142 #define ACPI_DIGITAL_OUTPUT (3<<8)
 143 #define ACPI_LVDS_OUTPUT (4<<8)
 144
 145 #ifdef CONFIG_ACPI
 146 static u32 asle_set_backlight(struct drm_device *dev, u32 bclp)
 147 {
 148         struct drm_i915_private *dev_priv = dev->dev_private;
 149         struct opregion_asle *asle = dev_priv->opregion.asle;
 150         u32 blc_pwm_ctl, blc_pwm_ctl2;
 151         u32 max_backlight, level, shift;
 152
 153         if (!(bclp & ASLE_BCLP_VALID))
 154                 return ASLE_BACKLIGHT_FAILED;
 155
 156         bclp &= ASLE_BCLP_MSK;
 157         if (bclp < 0 || bclp > 255)
 158                 return ASLE_BACKLIGHT_FAILED;
 159
 160         blc_pwm_ctl = I915_READ(BLC_PWM_CTL);
 161         blc_pwm_ctl2 = I915_READ(BLC_PWM_CTL2);
 162
 163         if (IS_I965G(dev) && (blc_pwm_ctl2 & BLM_COMBINATION_MODE))
 164                 pci_write_config_dword(dev->pdev, PCI_LBPC, bclp);
 165         else {
 166                 if (IS_PINEVIEW(dev)) {
 167                         blc_pwm_ctl &= ~(BACKLIGHT_DUTY_CYCLE_MASK - 1);
 168                         max_backlight = (blc_pwm_ctl & BACKLIGHT_MODULATION_FREQ_MASK) >>
 169                                         BACKLIGHT_MODULATION_FREQ_SHIFT;
 170                         shift = BACKLIGHT_DUTY_CYCLE_SHIFT + 1;
 171                 } else {
 172                         blc_pwm_ctl &= ~BACKLIGHT_DUTY_CYCLE_MASK;
 173                         max_backlight = ((blc_pwm_ctl & BACKLIGHT_MODULATION_FREQ_MASK) >>
 174                                         BACKLIGHT_MODULATION_FREQ_SHIFT) * 2;
 175                         shift = BACKLIGHT_DUTY_CYCLE_SHIFT;
 176                 }
 177                 level = (bclp * max_backlight) / 255;
 178                 I915_WRITE(BLC_PWM_CTL, blc_pwm_ctl | (level << shift));
 179         }
 180         asle->cblv = (bclp*0x64)/0xff | ASLE_CBLV_VALID;
 181
 182         return 0;
 183 }
 184
 185 static u32 asle_set_als_illum(struct drm_device *dev, u32 alsi)
 186 {
 187         /* alsi is the current ALS reading in lux. 0 indicates below sensor
 188            range, 0xffff indicates above sensor range. 1-0xfffe are valid */
 189         return 0;
 190 }
 191
 192 static u32 asle_set_pwm_freq(struct drm_device *dev, u32 pfmb)
 193 {
 194         struct drm_i915_private *dev_priv = dev->dev_private;
 195         if (pfmb & ASLE_PFMB_PWM_VALID) {
 196                 u32 blc_pwm_ctl = I915_READ(BLC_PWM_CTL);
 197                 u32 pwm = pfmb & ASLE_PFMB_PWM_MASK;
 198                 blc_pwm_ctl &= BACKLIGHT_DUTY_CYCLE_MASK;
 199                 pwm = pwm >> 9;
 200                 /* FIXME - what do we do with the PWM? */
 201         }
 202         return 0;
 203 }
 204
 205 static u32 asle_set_pfit(struct drm_device *dev, u32 pfit)
 206 {
 207         /* Panel fitting is currently controlled by the X code, so this is a
 208            noop until modesetting support works fully */
 209         if (!(pfit & ASLE_PFIT_VALID))
 210                 return ASLE_PFIT_FAILED;
 211         return 0;
 212 }
 213
 214 void intel_opregion_asle_intr(struct drm_device *dev)
 215 {
 216         struct drm_i915_private *dev_priv = dev->dev_private;
 217         struct opregion_asle *asle = dev_priv->opregion.asle;
 218         u32 asle_stat = 0;
 219         u32 asle_req;
 220
 221         if (!asle)
 222                 return;
 223
 224         asle_req = asle->aslc & ASLE_REQ_MSK;
 225
 226         if (!asle_req) {
 227                 DRM_DEBUG_DRIVER("non asle set request??\n");
 228                 return;
 229         }
 230
 231         if (asle_req & ASLE_SET_ALS_ILLUM)
 232                 asle_stat |= asle_set_als_illum(dev, asle->alsi);
 233
 234         if (asle_req & ASLE_SET_BACKLIGHT)
 235                 asle_stat |= asle_set_backlight(dev, asle->bclp);
 236
 237         if (asle_req & ASLE_SET_PFIT)
 238                 asle_stat |= asle_set_pfit(dev, asle->pfit);
 239
 240         if (asle_req & ASLE_SET_PWM_FREQ)
 241                 asle_stat |= asle_set_pwm_freq(dev, asle->pfmb);
 242
 243         asle->aslc = asle_stat;
 244 }
 245
 246 static u32 asle_set_backlight_ironlake(struct drm_device *dev, u32 bclp)
 247 {
 248         struct drm_i915_private *dev_priv = dev->dev_private;
 249         struct opregion_asle *asle = dev_priv->opregion.asle;
 250         u32 cpu_pwm_ctl, pch_pwm_ctl2;
 251         u32 max_backlight, level;
 252
 253         if (!(bclp & ASLE_BCLP_VALID))
 254                 return ASLE_BACKLIGHT_FAILED;
 255
 256         bclp &= ASLE_BCLP_MSK;
 257         if (bclp < 0 || bclp > 255)
 258                 return ASLE_BACKLIGHT_FAILED;
 259
 260         cpu_pwm_ctl = I915_READ(BLC_PWM_CPU_CTL);
 261         pch_pwm_ctl2 = I915_READ(BLC_PWM_PCH_CTL2);
 262         /* get the max PWM frequency */
 263         max_backlight = (pch_pwm_ctl2 >> 16) & BACKLIGHT_DUTY_CYCLE_MASK;
 264         /* calculate the expected PMW frequency */
 265         level = (bclp * max_backlight) / 255;
 266         /* reserve the high 16 bits */
 267         cpu_pwm_ctl &= ~(BACKLIGHT_DUTY_CYCLE_MASK);
 268         /* write the updated PWM frequency */
 269         I915_WRITE(BLC_PWM_CPU_CTL, cpu_pwm_ctl | level);
 270
 271         asle->cblv = (bclp*0x64)/0xff | ASLE_CBLV_VALID;
 272
 273         return 0;
 274 }
 275
 276 /* Only present on Ironlake+ */
 277 void intel_opregion_gse_intr(struct drm_device *dev)
 278 {
 279         struct drm_i915_private *dev_priv = dev->dev_private;
 280         struct opregion_asle *asle = dev_priv->opregion.asle;
 281         u32 asle_stat = 0;
 282         u32 asle_req;
 283
 284         if (!asle)
 285                 return;
 286
 287         asle_req = asle->aslc & ASLE_REQ_MSK;
 288
 289         if (!asle_req) {
 290                 DRM_DEBUG_DRIVER("non asle set request??\n");
 291                 return;
 292         }
 293
 294         if (asle_req & ASLE_SET_ALS_ILLUM) {
 295                 DRM_DEBUG_DRIVER("Illum is not supported\n");
 296                 asle_stat |= ASLE_ALS_ILLUM_FAILED;
 297         }
 298
 299         if (asle_req & ASLE_SET_BACKLIGHT)
 300                 asle_stat |= asle_set_backlight_ironlake(dev, asle->bclp);
 301
 302         if (asle_req & ASLE_SET_PFIT) {
 303                 DRM_DEBUG_DRIVER("Pfit is not supported\n");
 304                 asle_stat |= ASLE_PFIT_FAILED;
 305         }
 306
 307         if (asle_req & ASLE_SET_PWM_FREQ) {
 308                 DRM_DEBUG_DRIVER("PWM freq is not supported\n");
 309                 asle_stat |= ASLE_PWM_FREQ_FAILED;
 310         }
 311
 312         asle->aslc = asle_stat;
 313 }
 314 #define ASLE_ALS_EN    (1<<0)
 315 #define ASLE_BLC_EN    (1<<1)
 316 #define ASLE_PFIT_EN   (1<<2)
 317 #define ASLE_PFMB_EN   (1<<3)
 318
 319 void intel_opregion_enable_asle(struct drm_device *dev)
 320 {
 321         struct drm_i915_private *dev_priv = dev->dev_private;
 322         struct opregion_asle *asle = dev_priv->opregion.asle;
 323
 324         if (asle) {
 325                 if (IS_MOBILE(dev)) {
 326                         unsigned long irqflags;
 327
 328                         spin_lock_irqsave(&dev_priv->user_irq_lock, irqflags);
 329                         intel_enable_asle(dev);
 330                         spin_unlock_irqrestore(&dev_priv->user_irq_lock,
 331                                                irqflags);
 332                 }
 333
 334                 asle->tche = ASLE_ALS_EN | ASLE_BLC_EN | ASLE_PFIT_EN |
 335                         ASLE_PFMB_EN;
 336                 asle->ardy = 1;
 337         }
 338 }
 339
 340 #define ACPI_EV_DISPLAY_SWITCH (1<<0)
 341 #define ACPI_EV_LID            (1<<1)
 342 #define ACPI_EV_DOCK           (1<<2)
 343
 344 static struct intel_opregion *system_opregion;
 345
 346 static int intel_opregion_video_event(struct notifier_block *nb,
 347                                       unsigned long val, void *data)
 348 {
 349         /* The only video events relevant to opregion are 0x80. These indicate
 350            either a docking event, lid switch or display switch request. In
 351            Linux, these are handled by the dock, button and video drivers.
 352            We might want to fix the video driver to be opregion-aware in
 353            future, but right now we just indicate to the firmware that the
 354            request has been handled */
 355
 356         struct opregion_acpi *acpi;
 357
 358         if (!system_opregion)
 359                 return NOTIFY_DONE;
 360
 361         acpi = system_opregion->acpi;
 362         acpi->csts = 0;
 363
 364         return NOTIFY_OK;
 365 }
 366
 367 static struct notifier_block intel_opregion_notifier = {
 368         .notifier_call = intel_opregion_video_event,
 369 };
 370
 371 /*
 372  * Initialise the DIDL field in opregion. This passes a list of devices to
 373  * the firmware. Values are defined by section B.4.2 of the ACPI specification
 374  * (version 3)
 375  */
 376
 377 static void intel_didl_outputs(struct drm_device *dev)
 378 {
 379         struct drm_i915_private *dev_priv = dev->dev_private;
 380         struct intel_opregion *opregion = &dev_priv->opregion;
 381         struct drm_connector *connector;
 382         acpi_handle handle;
 383         struct acpi_device *acpi_dev, *acpi_cdev, *acpi_video_bus = NULL;
 384         unsigned long long device_id;
 385         acpi_status status;
 386         int i = 0;
 387
 388         handle = DEVICE_ACPI_HANDLE(&dev->pdev->dev);
 389         if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &acpi_dev)))
 390                 return;
 391
 392         if (acpi_is_video_device(acpi_dev))
 393                 acpi_video_bus = acpi_dev;
 394         else {
 395                 list_for_each_entry(acpi_cdev, &acpi_dev->children, node) {
 396                         if (acpi_is_video_device(acpi_cdev)) {
 397                                 acpi_video_bus = acpi_cdev;
 398                                 break;
 399                         }
 400                 }
 401         }
 402
 403         if (!acpi_video_bus) {
 404                 printk(KERN_WARNING "No ACPI video bus found\n");
 405                 return;
 406         }
 407
 408         list_for_each_entry(acpi_cdev, &acpi_video_bus->children, node) {
 409                 if (i >= 8) {
 410                         dev_printk (KERN_ERR, &dev->pdev->dev,
 411                                     "More than 8 outputs detected\n");
 412                         return;
 413                 }
 414                 status =
 415                         acpi_evaluate_integer(acpi_cdev->handle, "_ADR",
 416                                                 NULL, &device_id);
 417                 if (ACPI_SUCCESS(status)) {
 418                         if (!device_id)
 419                                 goto blind_set;
 420                         opregion->acpi->didl[i] = (u32)(device_id & 0x0f0f);
 421                         i++;
 422                 }
 423         }
 424
 425 end:
 426         /* If fewer than 8 outputs, the list must be null terminated */
 427         if (i < 8)
 428                 opregion->acpi->didl[i] = 0;
 429         return;
 430
 431 blind_set:
 432         i = 0;
 433         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
 434                 int output_type = ACPI_OTHER_OUTPUT;
 435                 if (i >= 8) {
 436                         dev_printk (KERN_ERR, &dev->pdev->dev,
 437                                     "More than 8 outputs detected\n");
 438                         return;
 439                 }
 440                 switch (connector->connector_type) {
 441                 case DRM_MODE_CONNECTOR_VGA:
 442                 case DRM_MODE_CONNECTOR_DVIA:
 443                         output_type = ACPI_VGA_OUTPUT;
 444                         break;
 445                 case DRM_MODE_CONNECTOR_Composite:
 446                 case DRM_MODE_CONNECTOR_SVIDEO:
 447                 case DRM_MODE_CONNECTOR_Component:
 448                 case DRM_MODE_CONNECTOR_9PinDIN:
 449                         output_type = ACPI_TV_OUTPUT;
 450                         break;
 451                 case DRM_MODE_CONNECTOR_DVII:
 452                 case DRM_MODE_CONNECTOR_DVID:
 453                 case DRM_MODE_CONNECTOR_DisplayPort:
 454                 case DRM_MODE_CONNECTOR_HDMIA:
 455                 case DRM_MODE_CONNECTOR_HDMIB:
 456                         output_type = ACPI_DIGITAL_OUTPUT;
 457                         break;
 458                 case DRM_MODE_CONNECTOR_LVDS:
 459                         output_type = ACPI_LVDS_OUTPUT;
 460                         break;
 461                 }
 462                 opregion->acpi->didl[i] |= (1<<31) | output_type | i;
 463                 i++;
 464         }
 465         goto end;
 466 }
 467
 468 void intel_opregion_init(struct drm_device *dev)
 469 {
 470         struct drm_i915_private *dev_priv = dev->dev_private;
 471         struct intel_opregion *opregion = &dev_priv->opregion;
 472
 473         if (!opregion->header)
 474                 return;
 475
 476         if (opregion->acpi) {
 477                 if (drm_core_check_feature(dev, DRIVER_MODESET))
 478                         intel_didl_outputs(dev);
 479
 480                 /* Notify BIOS we are ready to handle ACPI video ext notifs.
 481                  * Right now, all the events are handled by the ACPI video module.
 482                  * We don't actually need to do anything with them. */
 483                 opregion->acpi->csts = 0;
 484                 opregion->acpi->drdy = 1;
 485
 486                 system_opregion = opregion;
 487                 register_acpi_notifier(&intel_opregion_notifier);
 488         }
 489
 490         if (opregion->asle)
 491                 intel_opregion_enable_asle(dev);
 492 }
 493
 494 void intel_opregion_fini(struct drm_device *dev)
 495 {
 496         struct drm_i915_private *dev_priv = dev->dev_private;
 497         struct intel_opregion *opregion = &dev_priv->opregion;
 498
 499         if (!opregion->header)
 500                 return;
 501
 502         if (opregion->acpi) {
 503                 opregion->acpi->drdy = 0;
 504
 505                 system_opregion = NULL;
 506                 unregister_acpi_notifier(&intel_opregion_notifier);
 507         }
 508
 509         /* just clear all opregion memory pointers now */
 510         iounmap(opregion->header);
 511         opregion->header = NULL;
 512         opregion->acpi = NULL;
 513         opregion->swsci = NULL;
 514         opregion->asle = NULL;
 515         opregion->vbt = NULL;
 516 }
 517 #endif
 518
 519 int intel_opregion_setup(struct drm_device *dev)
 520 {
 521         struct drm_i915_private *dev_priv = dev->dev_private;
 522         struct intel_opregion *opregion = &dev_priv->opregion;
 523         void *base;
 524         u32 asls, mboxes;
 525         int err = 0;
 526
 527         pci_read_config_dword(dev->pdev, PCI_ASLS, &asls);
 528         DRM_DEBUG_DRIVER("graphic opregion physical addr: 0x%x\n", asls);
 529         if (asls == 0) {
 530                 DRM_DEBUG_DRIVER("ACPI OpRegion not supported!\n");
 531                 return -ENOTSUPP;
 532         }
 533
 534         base = ioremap(asls, OPREGION_SIZE);
 535         if (!base)
 536                 return -ENOMEM;
 537
 538         if (memcmp(base, OPREGION_SIGNATURE, 16)) {
 539                 DRM_DEBUG_DRIVER("opregion signature mismatch\n");
 540                 err = -EINVAL;
 541                 goto err_out;
 542         }
 543         opregion->header = base;
 544         opregion->vbt = base + OPREGION_VBT_OFFSET;
 545
 546         mboxes = opregion->header->mboxes;
 547         if (mboxes & MBOX_ACPI) {
 548                 DRM_DEBUG_DRIVER("Public ACPI methods supported\n");
 549                 opregion->acpi = base + OPREGION_ACPI_OFFSET;
 550         }
 551
 552         if (mboxes & MBOX_SWSCI) {
 553                 DRM_DEBUG_DRIVER("SWSCI supported\n");
 554                 opregion->swsci = base + OPREGION_SWSCI_OFFSET;
 555         }
 556         if (mboxes & MBOX_ASLE) {
 557                 DRM_DEBUG_DRIVER("ASLE supported\n");
 558                 opregion->asle = base + OPREGION_ASLE_OFFSET;
 559         }
 560
 561         return 0;
 562
 563 err_out:
 564         iounmap(opregion->header);
 565         return err;
 566 }