@@ -159,6 +159,8 @@ int drm_dp_bw_code_to_link_rate(u8 link_bw)
159
159
}
160
160
EXPORT_SYMBOL (drm_dp_bw_code_to_link_rate );
161
161
162
+ #define AUX_RETRY_INTERVAL 500 /* us */
163
+
162
164
/**
163
165
* DOC: dp helpers
164
166
*
@@ -213,7 +215,7 @@ static int drm_dp_dpcd_access(struct drm_dp_aux *aux, u8 request,
213
215
return - EIO ;
214
216
215
217
case DP_AUX_NATIVE_REPLY_DEFER :
216
- usleep_range (400 , 500 );
218
+ usleep_range (AUX_RETRY_INTERVAL , AUX_RETRY_INTERVAL + 100 );
217
219
break ;
218
220
}
219
221
}
@@ -422,6 +424,90 @@ static u32 drm_dp_i2c_functionality(struct i2c_adapter *adapter)
422
424
I2C_FUNC_10BIT_ADDR ;
423
425
}
424
426
427
+ #define AUX_PRECHARGE_LEN 10 /* 10 to 16 */
428
+ #define AUX_SYNC_LEN (16 + 4) /* preamble + AUX_SYNC_END */
429
+ #define AUX_STOP_LEN 4
430
+ #define AUX_CMD_LEN 4
431
+ #define AUX_ADDRESS_LEN 20
432
+ #define AUX_REPLY_PAD_LEN 4
433
+ #define AUX_LENGTH_LEN 8
434
+
435
+ /*
436
+ * Calculate the duration of the AUX request/reply in usec. Gives the
437
+ * "best" case estimate, ie. successful while as short as possible.
438
+ */
439
+ static int drm_dp_aux_req_duration (const struct drm_dp_aux_msg * msg )
440
+ {
441
+ int len = AUX_PRECHARGE_LEN + AUX_SYNC_LEN + AUX_STOP_LEN +
442
+ AUX_CMD_LEN + AUX_ADDRESS_LEN + AUX_LENGTH_LEN ;
443
+
444
+ if ((msg -> request & DP_AUX_I2C_READ ) == 0 )
445
+ len += msg -> size * 8 ;
446
+
447
+ return len ;
448
+ }
449
+
450
+ static int drm_dp_aux_reply_duration (const struct drm_dp_aux_msg * msg )
451
+ {
452
+ int len = AUX_PRECHARGE_LEN + AUX_SYNC_LEN + AUX_STOP_LEN +
453
+ AUX_CMD_LEN + AUX_REPLY_PAD_LEN ;
454
+
455
+ /*
456
+ * For read we expect what was asked. For writes there will
457
+ * be 0 or 1 data bytes. Assume 0 for the "best" case.
458
+ */
459
+ if (msg -> request & DP_AUX_I2C_READ )
460
+ len += msg -> size * 8 ;
461
+
462
+ return len ;
463
+ }
464
+
465
+ #define I2C_START_LEN 1
466
+ #define I2C_STOP_LEN 1
467
+ #define I2C_ADDR_LEN 9 /* ADDRESS + R/W + ACK/NACK */
468
+ #define I2C_DATA_LEN 9 /* DATA + ACK/NACK */
469
+
470
+ /*
471
+ * Calculate the length of the i2c transfer in usec, assuming
472
+ * the i2c bus speed is as specified. Gives the the "worst"
473
+ * case estimate, ie. successful while as long as possible.
474
+ * Doesn't account the the "MOT" bit, and instead assumes each
475
+ * message includes a START, ADDRESS and STOP. Neither does it
476
+ * account for additional random variables such as clock stretching.
477
+ */
478
+ static int drm_dp_i2c_msg_duration (const struct drm_dp_aux_msg * msg ,
479
+ int i2c_speed_khz )
480
+ {
481
+ /* AUX bitrate is 1MHz, i2c bitrate as specified */
482
+ return DIV_ROUND_UP ((I2C_START_LEN + I2C_ADDR_LEN +
483
+ msg -> size * I2C_DATA_LEN +
484
+ I2C_STOP_LEN ) * 1000 , i2c_speed_khz );
485
+ }
486
+
487
+ /*
488
+ * Deterine how many retries should be attempted to successfully transfer
489
+ * the specified message, based on the estimated durations of the
490
+ * i2c and AUX transfers.
491
+ */
492
+ static int drm_dp_i2c_retry_count (const struct drm_dp_aux_msg * msg ,
493
+ int i2c_speed_khz )
494
+ {
495
+ int aux_time_us = drm_dp_aux_req_duration (msg ) +
496
+ drm_dp_aux_reply_duration (msg );
497
+ int i2c_time_us = drm_dp_i2c_msg_duration (msg , i2c_speed_khz );
498
+
499
+ return DIV_ROUND_UP (i2c_time_us , aux_time_us + AUX_RETRY_INTERVAL );
500
+ }
501
+
502
+ /*
503
+ * FIXME currently assumes 10 kHz as some real world devices seem
504
+ * to require it. We should query/set the speed via DPCD if supported.
505
+ */
506
+ static int dp_aux_i2c_speed_khz __read_mostly = 10 ;
507
+ module_param_unsafe (dp_aux_i2c_speed_khz , int , 0644 );
508
+ MODULE_PARM_DESC (dp_aux_i2c_speed_khz ,
509
+ "Assumed speed of the i2c bus in kHz, (1-400, default 10)" );
510
+
425
511
/*
426
512
* Transfer a single I2C-over-AUX message and handle various error conditions,
427
513
* retrying the transaction as appropriate. It is assumed that the
@@ -434,13 +520,16 @@ static int drm_dp_i2c_do_msg(struct drm_dp_aux *aux, struct drm_dp_aux_msg *msg)
434
520
{
435
521
unsigned int retry , defer_i2c ;
436
522
int ret ;
437
-
438
523
/*
439
524
* DP1.2 sections 2.7.7.1.5.6.1 and 2.7.7.1.6.6.1: A DP Source device
440
525
* is required to retry at least seven times upon receiving AUX_DEFER
441
526
* before giving up the AUX transaction.
527
+ *
528
+ * We also try to account for the i2c bus speed.
442
529
*/
443
- for (retry = 0 , defer_i2c = 0 ; retry < (7 + defer_i2c ); retry ++ ) {
530
+ int max_retries = max (7 , drm_dp_i2c_retry_count (msg , dp_aux_i2c_speed_khz ));
531
+
532
+ for (retry = 0 , defer_i2c = 0 ; retry < (max_retries + defer_i2c ); retry ++ ) {
444
533
mutex_lock (& aux -> hw_mutex );
445
534
ret = aux -> transfer (aux , msg );
446
535
mutex_unlock (& aux -> hw_mutex );
@@ -476,7 +565,7 @@ static int drm_dp_i2c_do_msg(struct drm_dp_aux *aux, struct drm_dp_aux_msg *msg)
476
565
* For now just defer for long enough to hopefully be
477
566
* safe for all use-cases.
478
567
*/
479
- usleep_range (500 , 600 );
568
+ usleep_range (AUX_RETRY_INTERVAL , AUX_RETRY_INTERVAL + 100 );
480
569
continue ;
481
570
482
571
default :
@@ -506,7 +595,7 @@ static int drm_dp_i2c_do_msg(struct drm_dp_aux *aux, struct drm_dp_aux_msg *msg)
506
595
aux -> i2c_defer_count ++ ;
507
596
if (defer_i2c < 7 )
508
597
defer_i2c ++ ;
509
- usleep_range (400 , 500 );
598
+ usleep_range (AUX_RETRY_INTERVAL , AUX_RETRY_INTERVAL + 100 );
510
599
continue ;
511
600
512
601
default :
0 commit comments