Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
66 kB · 2563 lines
C
at master
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564// SPDX-License-Identifier: GPL-2.0/* * Debugfs interface * * Copyright (C) 2020, Intel Corporation * Authors: Gil Fine <gil.fine@intel.com> * Mika Westerberg <mika.westerberg@linux.intel.com> */
#include <linux/array_size.h>#include <linux/bitfield.h>#include <linux/debugfs.h>#include <linux/delay.h>#include <linux/pm_runtime.h>#include <linux/string_choices.h>#include <linux/uaccess.h>
#include "tb.h"#include "sb_regs.h"
#define PORT_CAP_V1_PCIE_LEN 1#define PORT_CAP_V2_PCIE_LEN 2#define PORT_CAP_POWER_LEN 2#define PORT_CAP_LANE_LEN 3#define PORT_CAP_USB3_LEN 5#define PORT_CAP_DP_V1_LEN 9#define PORT_CAP_DP_V2_LEN 14#define PORT_CAP_TMU_V1_LEN 8#define PORT_CAP_TMU_V2_LEN 10#define PORT_CAP_BASIC_LEN 9#define PORT_CAP_USB4_LEN 20
#define SWITCH_CAP_TMU_LEN 26#define SWITCH_CAP_BASIC_LEN 27
#define PATH_LEN 2
#define COUNTER_SET_LEN 3
/* * USB4 spec doesn't specify dwell range, the range of 100 ms to 500 ms * probed to give good results. */#define MIN_DWELL_TIME 100 /* ms */#define MAX_DWELL_TIME 500 /* ms */#define DWELL_SAMPLE_INTERVAL 10
enum usb4_margin_cap_voltage_indp { USB4_MARGIN_CAP_VOLTAGE_INDP_GEN_2_3_MIN, USB4_MARGIN_CAP_VOLTAGE_INDP_GEN_2_3_HL, USB4_MARGIN_CAP_VOLTAGE_INDP_GEN_2_3_BOTH, USB4_MARGIN_CAP_VOLTAGE_INDP_GEN_4_MIN, USB4_MARGIN_CAP_VOLTAGE_INDP_GEN_4_BOTH, USB4_MARGIN_CAP_VOLTAGE_INDP_UNKNOWN,};
enum usb4_margin_cap_time_indp { USB4_MARGIN_CAP_TIME_INDP_GEN_2_3_MIN, USB4_MARGIN_CAP_TIME_INDP_GEN_2_3_LR, USB4_MARGIN_CAP_TIME_INDP_GEN_2_3_BOTH, USB4_MARGIN_CAP_TIME_INDP_GEN_4_MIN, USB4_MARGIN_CAP_TIME_INDP_GEN_4_BOTH, USB4_MARGIN_CAP_TIME_INDP_UNKNOWN,};
/* Sideband registers and their sizes as defined in the USB4 spec */struct sb_reg { unsigned int reg; unsigned int size;};
#define SB_MAX_SIZE 64
/* Sideband registers for router */static const struct sb_reg port_sb_regs[] = { { USB4_SB_VENDOR_ID, 4 }, { USB4_SB_PRODUCT_ID, 4 }, { USB4_SB_DEBUG_CONF, 4 }, { USB4_SB_DEBUG, 54 }, { USB4_SB_LRD_TUNING, 4 }, { USB4_SB_OPCODE, 4 }, { USB4_SB_METADATA, 4 }, { USB4_SB_LINK_CONF, 3 }, { USB4_SB_GEN23_TXFFE, 4 }, { USB4_SB_GEN4_TXFFE, 4 }, { USB4_SB_VERSION, 4 }, { USB4_SB_DATA, 64 },};
/* Sideband registers for retimer */static const struct sb_reg retimer_sb_regs[] = { { USB4_SB_VENDOR_ID, 4 }, { USB4_SB_PRODUCT_ID, 4 }, { USB4_SB_FW_VERSION, 4 }, { USB4_SB_LRD_TUNING, 4 }, { USB4_SB_OPCODE, 4 }, { USB4_SB_METADATA, 4 }, { USB4_SB_GEN23_TXFFE, 4 }, { USB4_SB_GEN4_TXFFE, 4 }, { USB4_SB_VERSION, 4 }, { USB4_SB_DATA, 64 },};
#define DEBUGFS_ATTR(__space, __write) \static int __space ## _open(struct inode *inode, struct file *file) \{ \ return single_open(file, __space ## _show, inode->i_private); \} \ \static const struct file_operations __space ## _fops = { \ .owner = THIS_MODULE, \ .open = __space ## _open, \ .release = single_release, \ .read = seq_read, \ .write = __write, \ .llseek = seq_lseek, \}
#define DEBUGFS_ATTR_RO(__space) \ DEBUGFS_ATTR(__space, NULL)
#define DEBUGFS_ATTR_RW(__space) \ DEBUGFS_ATTR(__space, __space ## _write)
static struct dentry *tb_debugfs_root;
static void *validate_and_copy_from_user(const void __user *user_buf, size_t *count){ size_t nbytes; void *buf;
if (!*count) return ERR_PTR(-EINVAL);
if (!access_ok(user_buf, *count)) return ERR_PTR(-EFAULT);
buf = (void *)get_zeroed_page(GFP_KERNEL); if (!buf) return ERR_PTR(-ENOMEM);
nbytes = min_t(size_t, *count, PAGE_SIZE); if (copy_from_user(buf, user_buf, nbytes)) { free_page((unsigned long)buf); return ERR_PTR(-EFAULT); }
*count = nbytes; return buf;}
static bool parse_line(char **line, u32 *offs, u32 *val, int short_fmt_len, int long_fmt_len){ char *token; u32 v[5]; int ret;
token = strsep(line, "\n"); if (!token) return false;
/* * For Adapter/Router configuration space: * Short format is: offset value\n * v[0] v[1] * Long format as produced from the read side: * offset relative_offset cap_id vs_cap_id value\n * v[0] v[1] v[2] v[3] v[4] * * For Path configuration space: * Short format is: offset value\n * v[0] v[1] * Long format as produced from the read side: * offset relative_offset in_hop_id value\n * v[0] v[1] v[2] v[3] * * For Counter configuration space: * Short format is: offset\n * v[0] * Long format as produced from the read side: * offset relative_offset counter_id value\n * v[0] v[1] v[2] v[3] */ ret = sscanf(token, "%i %i %i %i %i", &v[0], &v[1], &v[2], &v[3], &v[4]); /* In case of Counters, clear counter, "val" content is NA */ if (ret == short_fmt_len) { *offs = v[0]; *val = v[short_fmt_len - 1]; return true; } else if (ret == long_fmt_len) { *offs = v[0]; *val = v[long_fmt_len - 1]; return true; }
return false;}
#if IS_ENABLED(CONFIG_USB4_DEBUGFS_WRITE)/* * Path registers need to be written in double word pairs and they both must be * read before written. This writes one double word in path config space * following the spec flow. */static int path_write_one(struct tb_port *port, u32 val, u32 offset){ u32 index = offset % PATH_LEN; u32 offs = offset - index; u32 data[PATH_LEN]; int ret;
ret = tb_port_read(port, data, TB_CFG_HOPS, offs, PATH_LEN); if (ret) return ret; data[index] = val; return tb_port_write(port, data, TB_CFG_HOPS, offs, PATH_LEN);}
static ssize_t regs_write(struct tb_switch *sw, struct tb_port *port, enum tb_cfg_space space, const char __user *user_buf, size_t count, loff_t *ppos){ int long_fmt_len, ret = 0; struct tb *tb = sw->tb; char *line, *buf; u32 val, offset;
buf = validate_and_copy_from_user(user_buf, &count); if (IS_ERR(buf)) return PTR_ERR(buf);
pm_runtime_get_sync(&sw->dev);
if (mutex_lock_interruptible(&tb->lock)) { ret = -ERESTARTSYS; goto out; }
/* User did hardware changes behind the driver's back */ add_taint(TAINT_USER, LOCKDEP_STILL_OK);
if (space == TB_CFG_HOPS) long_fmt_len = 4; else long_fmt_len = 5;
line = buf; while (parse_line(&line, &offset, &val, 2, long_fmt_len)) { if (port) { if (space == TB_CFG_HOPS) ret = path_write_one(port, val, offset); else ret = tb_port_write(port, &val, space, offset, 1); } else { ret = tb_sw_write(sw, &val, TB_CFG_SWITCH, offset, 1); } if (ret) break; }
mutex_unlock(&tb->lock);
out: pm_runtime_mark_last_busy(&sw->dev); pm_runtime_put_autosuspend(&sw->dev); free_page((unsigned long)buf);
return ret < 0 ? ret : count;}
static ssize_t port_regs_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos){ struct seq_file *s = file->private_data; struct tb_port *port = s->private;
return regs_write(port->sw, port, TB_CFG_PORT, user_buf, count, ppos);}
static ssize_t path_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos){ struct seq_file *s = file->private_data; struct tb_port *port = s->private;
return regs_write(port->sw, port, TB_CFG_HOPS, user_buf, count, ppos);}
static ssize_t switch_regs_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos){ struct seq_file *s = file->private_data; struct tb_switch *sw = s->private;
return regs_write(sw, NULL, TB_CFG_SWITCH, user_buf, count, ppos);}
static bool parse_sb_line(char **line, u8 *reg, u8 *data, size_t data_size, size_t *bytes_read){ char *field, *token; int i;
token = strsep(line, "\n"); if (!token) return false;
/* Parse the register first */ field = strsep(&token, " "); if (!field) return false; if (kstrtou8(field, 0, reg)) return false;
/* Then the values for the register, up to data_size */ for (i = 0; i < data_size; i++) { field = strsep(&token, " "); if (!field) break; if (kstrtou8(field, 0, &data[i])) return false; }
*bytes_read = i; return true;}
static ssize_t sb_regs_write(struct tb_port *port, const struct sb_reg *sb_regs, size_t size, enum usb4_sb_target target, u8 index, char *buf, size_t count, loff_t *ppos){ u8 reg, data[SB_MAX_SIZE]; size_t bytes_read; char *line = buf;
/* User did hardware changes behind the driver's back */ add_taint(TAINT_USER, LOCKDEP_STILL_OK);
/* * For sideband registers we accept: * reg b0 b1 b2...\n * * Here "reg" is the byte offset of the sideband register and "b0".. * are the byte values. There can be less byte values than the register * size. The leftovers will not be overwritten. */ while (parse_sb_line(&line, ®, data, ARRAY_SIZE(data), &bytes_read)) { const struct sb_reg *sb_reg; int ret;
/* At least one byte must be passed */ if (bytes_read < 1) return -EINVAL;
/* Find the register */ sb_reg = NULL; for (int i = 0; i < size; i++) { if (sb_regs[i].reg == reg) { sb_reg = &sb_regs[i]; break; } }
if (!sb_reg) return -EINVAL;
if (bytes_read > sb_reg->size) return -E2BIG;
ret = usb4_port_sb_write(port, target, index, sb_reg->reg, data, bytes_read); if (ret) return ret; }
return 0;}
static ssize_t port_sb_regs_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos){ struct seq_file *s = file->private_data; struct tb_port *port = s->private; struct tb_switch *sw = port->sw; struct tb *tb = sw->tb; char *buf; int ret;
buf = validate_and_copy_from_user(user_buf, &count); if (IS_ERR(buf)) return PTR_ERR(buf);
pm_runtime_get_sync(&sw->dev);
if (mutex_lock_interruptible(&tb->lock)) { ret = -ERESTARTSYS; goto out; }
ret = sb_regs_write(port, port_sb_regs, ARRAY_SIZE(port_sb_regs), USB4_SB_TARGET_ROUTER, 0, buf, count, ppos);
mutex_unlock(&tb->lock);out: pm_runtime_mark_last_busy(&sw->dev); pm_runtime_put_autosuspend(&sw->dev); free_page((unsigned long)buf);
return ret < 0 ? ret : count;}
static ssize_t retimer_sb_regs_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos){ struct seq_file *s = file->private_data; struct tb_retimer *rt = s->private; struct tb *tb = rt->tb; char *buf; int ret;
buf = validate_and_copy_from_user(user_buf, &count); if (IS_ERR(buf)) return PTR_ERR(buf);
pm_runtime_get_sync(&rt->dev);
if (mutex_lock_interruptible(&tb->lock)) { ret = -ERESTARTSYS; goto out; }
ret = sb_regs_write(rt->port, retimer_sb_regs, ARRAY_SIZE(retimer_sb_regs), USB4_SB_TARGET_RETIMER, rt->index, buf, count, ppos);
mutex_unlock(&tb->lock);out: pm_runtime_mark_last_busy(&rt->dev); pm_runtime_put_autosuspend(&rt->dev); free_page((unsigned long)buf);
return ret < 0 ? ret : count;}#define DEBUGFS_MODE 0600#else#define port_regs_write NULL#define path_write NULL#define switch_regs_write NULL#define port_sb_regs_write NULL#define retimer_sb_regs_write NULL#define DEBUGFS_MODE 0400#endif
#if IS_ENABLED(CONFIG_USB4_DEBUGFS_MARGINING)/** * struct tb_margining - Lane margining support * @port: USB4 port through which the margining operations are run * @target: Sideband target * @index: Retimer index if taget is %USB4_SB_TARGET_RETIMER * @dev: Pointer to the device that is the target (USB4 port or retimer) * @gen: Link generation * @asym_rx: %true% if @port supports asymmetric link with 3 Rx * @caps: Port lane margining capabilities * @results: Last lane margining results * @lanes: %0, %1 or %7 (all) * @min_ber_level: Minimum supported BER level contour value * @max_ber_level: Maximum supported BER level contour value * @ber_level: Current BER level contour value * @voltage_steps: Number of mandatory voltage steps * @max_voltage_offset: Maximum mandatory voltage offset (in mV) * @voltage_steps_optional_range: Number of voltage steps for optional range * @max_voltage_offset_optional_range: Maximum voltage offset for the optional * range (in mV). * @time_steps: Number of time margin steps * @max_time_offset: Maximum time margin offset (in mUI) * @voltage_time_offset: Offset for voltage / time for software margining * @dwell_time: Dwell time for software margining (in ms) * @error_counter: Error counter operation for software margining * @optional_voltage_offset_range: Enable optional extended voltage range * @software: %true if software margining is used instead of hardware * @time: %true if time margining is used instead of voltage * @right_high: %false if left/low margin test is performed, %true if * right/high * @upper_eye: %false if the lower PAM3 eye is used, %true if the upper * eye is used */struct tb_margining { struct tb_port *port; enum usb4_sb_target target; u8 index; struct device *dev; unsigned int gen; bool asym_rx; u32 caps[3]; u32 results[3]; enum usb4_margining_lane lanes; unsigned int min_ber_level; unsigned int max_ber_level; unsigned int ber_level; unsigned int voltage_steps; unsigned int max_voltage_offset; unsigned int voltage_steps_optional_range; unsigned int max_voltage_offset_optional_range; unsigned int time_steps; unsigned int max_time_offset; unsigned int voltage_time_offset; unsigned int dwell_time; enum usb4_margin_sw_error_counter error_counter; bool optional_voltage_offset_range; bool software; bool time; bool right_high; bool upper_eye;};
static int margining_modify_error_counter(struct tb_margining *margining, u32 lanes, enum usb4_margin_sw_error_counter error_counter){ struct usb4_port_margining_params params = { 0 }; struct tb_port *port = margining->port; u32 result;
if (error_counter != USB4_MARGIN_SW_ERROR_COUNTER_CLEAR && error_counter != USB4_MARGIN_SW_ERROR_COUNTER_STOP) return -EOPNOTSUPP;
params.error_counter = error_counter; params.lanes = lanes;
return usb4_port_sw_margin(port, margining->target, margining->index, ¶ms, &result);}
static bool supports_software(const struct tb_margining *margining){ if (margining->gen < 4) return margining->caps[0] & USB4_MARGIN_CAP_0_MODES_SW; return margining->caps[2] & USB4_MARGIN_CAP_2_MODES_SW;}
static bool supports_hardware(const struct tb_margining *margining){ if (margining->gen < 4) return margining->caps[0] & USB4_MARGIN_CAP_0_MODES_HW; return margining->caps[2] & USB4_MARGIN_CAP_2_MODES_HW;}
static bool all_lanes(const struct tb_margining *margining){ return margining->caps[0] & USB4_MARGIN_CAP_0_ALL_LANES;}
static enum usb4_margin_cap_voltage_indpindependent_voltage_margins(const struct tb_margining *margining){ if (margining->gen < 4) { switch (FIELD_GET(USB4_MARGIN_CAP_0_VOLTAGE_INDP_MASK, margining->caps[0])) { case USB4_MARGIN_CAP_0_VOLTAGE_MIN: return USB4_MARGIN_CAP_VOLTAGE_INDP_GEN_2_3_MIN; case USB4_MARGIN_CAP_0_VOLTAGE_HL: return USB4_MARGIN_CAP_VOLTAGE_INDP_GEN_2_3_HL; case USB4_MARGIN_CAP_1_TIME_BOTH: return USB4_MARGIN_CAP_VOLTAGE_INDP_GEN_2_3_BOTH; } } else { switch (FIELD_GET(USB4_MARGIN_CAP_2_VOLTAGE_INDP_MASK, margining->caps[2])) { case USB4_MARGIN_CAP_2_VOLTAGE_MIN: return USB4_MARGIN_CAP_VOLTAGE_INDP_GEN_4_MIN; case USB4_MARGIN_CAP_2_VOLTAGE_BOTH: return USB4_MARGIN_CAP_VOLTAGE_INDP_GEN_4_BOTH; } } return USB4_MARGIN_CAP_VOLTAGE_INDP_UNKNOWN;}
static bool supports_time(const struct tb_margining *margining){ if (margining->gen < 4) return margining->caps[0] & USB4_MARGIN_CAP_0_TIME; return margining->caps[2] & USB4_MARGIN_CAP_2_TIME;}
/* Only applicable if supports_time() returns true */static enum usb4_margin_cap_time_indpindependent_time_margins(const struct tb_margining *margining){ if (margining->gen < 4) { switch (FIELD_GET(USB4_MARGIN_CAP_1_TIME_INDP_MASK, margining->caps[1])) { case USB4_MARGIN_CAP_1_TIME_MIN: return USB4_MARGIN_CAP_TIME_INDP_GEN_2_3_MIN; case USB4_MARGIN_CAP_1_TIME_LR: return USB4_MARGIN_CAP_TIME_INDP_GEN_2_3_LR; case USB4_MARGIN_CAP_1_TIME_BOTH: return USB4_MARGIN_CAP_TIME_INDP_GEN_2_3_BOTH; } } else { switch (FIELD_GET(USB4_MARGIN_CAP_2_TIME_INDP_MASK, margining->caps[2])) { case USB4_MARGIN_CAP_2_TIME_MIN: return USB4_MARGIN_CAP_TIME_INDP_GEN_4_MIN; case USB4_MARGIN_CAP_2_TIME_BOTH: return USB4_MARGIN_CAP_TIME_INDP_GEN_4_BOTH; } } return USB4_MARGIN_CAP_TIME_INDP_UNKNOWN;}
static boolsupports_optional_voltage_offset_range(const struct tb_margining *margining){ return margining->caps[0] & USB4_MARGIN_CAP_0_OPT_VOLTAGE_SUPPORT;}
static ssize_tmargining_ber_level_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos){ struct seq_file *s = file->private_data; struct tb_margining *margining = s->private; struct tb *tb = margining->port->sw->tb; unsigned int val; int ret = 0; char *buf;
if (mutex_lock_interruptible(&tb->lock)) return -ERESTARTSYS;
if (margining->software) { ret = -EINVAL; goto out_unlock; }
buf = validate_and_copy_from_user(user_buf, &count); if (IS_ERR(buf)) { ret = PTR_ERR(buf); goto out_unlock; }
buf[count - 1] = '\0';
ret = kstrtouint(buf, 10, &val); if (ret) goto out_free;
if (val < margining->min_ber_level || val > margining->max_ber_level) { ret = -EINVAL; goto out_free; }
margining->ber_level = val;
out_free: free_page((unsigned long)buf);out_unlock: mutex_unlock(&tb->lock);
return ret < 0 ? ret : count;}
static void ber_level_show(struct seq_file *s, unsigned int val){ if (val % 2) seq_printf(s, "3 * 1e%d (%u)\n", -12 + (val + 1) / 2, val); else seq_printf(s, "1e%d (%u)\n", -12 + val / 2, val);}
static int margining_ber_level_show(struct seq_file *s, void *not_used){ const struct tb_margining *margining = s->private;
if (margining->software) return -EINVAL; ber_level_show(s, margining->ber_level); return 0;}DEBUGFS_ATTR_RW(margining_ber_level);
static int margining_caps_show(struct seq_file *s, void *not_used){ struct tb_margining *margining = s->private; struct tb *tb = margining->port->sw->tb; int ret = 0;
if (mutex_lock_interruptible(&tb->lock)) return -ERESTARTSYS;
/* Dump the raw caps first */ for (int i = 0; i < ARRAY_SIZE(margining->caps); i++) seq_printf(s, "0x%08x\n", margining->caps[i]);
seq_printf(s, "# software margining: %s\n", str_yes_no(supports_software(margining))); if (supports_hardware(margining)) { seq_puts(s, "# hardware margining: yes\n"); seq_puts(s, "# minimum BER level contour: "); ber_level_show(s, margining->min_ber_level); seq_puts(s, "# maximum BER level contour: "); ber_level_show(s, margining->max_ber_level); } else { seq_puts(s, "# hardware margining: no\n"); }
seq_printf(s, "# all lanes simultaneously: %s\n", str_yes_no(all_lanes(margining))); seq_printf(s, "# voltage margin steps: %u\n", margining->voltage_steps); seq_printf(s, "# maximum voltage offset: %u mV\n", margining->max_voltage_offset); seq_printf(s, "# optional voltage offset range support: %s\n", str_yes_no(supports_optional_voltage_offset_range(margining))); if (supports_optional_voltage_offset_range(margining)) { seq_printf(s, "# voltage margin steps, optional range: %u\n", margining->voltage_steps_optional_range); seq_printf(s, "# maximum voltage offset, optional range: %u mV\n", margining->max_voltage_offset_optional_range); }
switch (independent_voltage_margins(margining)) { case USB4_MARGIN_CAP_VOLTAGE_INDP_GEN_2_3_MIN: seq_puts(s, "# returns minimum between high and low voltage margins\n"); break; case USB4_MARGIN_CAP_VOLTAGE_INDP_GEN_2_3_HL: seq_puts(s, "# returns high or low voltage margin\n"); break; case USB4_MARGIN_CAP_VOLTAGE_INDP_GEN_2_3_BOTH: seq_puts(s, "# returns both high and low margins\n"); break; case USB4_MARGIN_CAP_VOLTAGE_INDP_GEN_4_MIN: seq_puts(s, "# returns minimum between high and low voltage margins in both lower and upper eye\n"); break; case USB4_MARGIN_CAP_VOLTAGE_INDP_GEN_4_BOTH: seq_puts(s, "# returns both high and low margins of both upper and lower eye\n"); break; case USB4_MARGIN_CAP_VOLTAGE_INDP_UNKNOWN: tb_port_warn(margining->port, "failed to parse independent voltage margining capabilities\n"); ret = -EIO; goto out; }
if (supports_time(margining)) { seq_puts(s, "# time margining: yes\n"); seq_printf(s, "# time margining is destructive: %s\n", str_yes_no(margining->caps[1] & USB4_MARGIN_CAP_1_TIME_DESTR));
switch (independent_time_margins(margining)) { case USB4_MARGIN_CAP_TIME_INDP_GEN_2_3_MIN: seq_puts(s, "# returns minimum between left and right time margins\n"); break; case USB4_MARGIN_CAP_TIME_INDP_GEN_2_3_LR: seq_puts(s, "# returns left or right margin\n"); break; case USB4_MARGIN_CAP_TIME_INDP_GEN_2_3_BOTH: seq_puts(s, "# returns both left and right margins\n"); break; case USB4_MARGIN_CAP_TIME_INDP_GEN_4_MIN: seq_puts(s, "# returns minimum between left and right time margins in both lower and upper eye\n"); break; case USB4_MARGIN_CAP_TIME_INDP_GEN_4_BOTH: seq_puts(s, "# returns both left and right margins of both upper and lower eye\n"); break; case USB4_MARGIN_CAP_TIME_INDP_UNKNOWN: tb_port_warn(margining->port, "failed to parse independent time margining capabilities\n"); ret = -EIO; goto out; }
seq_printf(s, "# time margin steps: %u\n", margining->time_steps); seq_printf(s, "# maximum time offset: %u mUI\n", margining->max_time_offset); } else { seq_puts(s, "# time margining: no\n"); }
out: mutex_unlock(&tb->lock); return ret;}DEBUGFS_ATTR_RO(margining_caps);
static const struct { enum usb4_margining_lane lane; const char *name;} lane_names[] = { { .lane = USB4_MARGINING_LANE_RX0, .name = "0", }, { .lane = USB4_MARGINING_LANE_RX1, .name = "1", }, { .lane = USB4_MARGINING_LANE_RX2, .name = "2", }, { .lane = USB4_MARGINING_LANE_ALL, .name = "all", },};
static ssize_tmargining_lanes_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos){ struct seq_file *s = file->private_data; struct tb_margining *margining = s->private; struct tb_port *port = margining->port; struct tb *tb = port->sw->tb; int lane = -1; char *buf;
buf = validate_and_copy_from_user(user_buf, &count); if (IS_ERR(buf)) return PTR_ERR(buf);
buf[count - 1] = '\0';
for (int i = 0; i < ARRAY_SIZE(lane_names); i++) { if (!strcmp(buf, lane_names[i].name)) { lane = lane_names[i].lane; break; } }
free_page((unsigned long)buf);
if (lane == -1) return -EINVAL;
scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &tb->lock) { if (lane == USB4_MARGINING_LANE_ALL && !all_lanes(margining)) return -EINVAL; /* * Enabling on RX2 requires that it is supported by the * USB4 port. */ if (lane == USB4_MARGINING_LANE_RX2 && !margining->asym_rx) return -EINVAL;
margining->lanes = lane; }
return count;}
static int margining_lanes_show(struct seq_file *s, void *not_used){ struct tb_margining *margining = s->private; struct tb_port *port = margining->port; struct tb *tb = port->sw->tb;
scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &tb->lock) { for (int i = 0; i < ARRAY_SIZE(lane_names); i++) { if (lane_names[i].lane == USB4_MARGINING_LANE_ALL && !all_lanes(margining)) continue; if (lane_names[i].lane == USB4_MARGINING_LANE_RX2 && !margining->asym_rx) continue;
if (i != 0) seq_putc(s, ' ');
if (lane_names[i].lane == margining->lanes) seq_printf(s, "[%s]", lane_names[i].name); else seq_printf(s, "%s", lane_names[i].name); } seq_puts(s, "\n"); }
return 0;}DEBUGFS_ATTR_RW(margining_lanes);
static ssize_tmargining_voltage_time_offset_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos){ struct seq_file *s = file->private_data; struct tb_margining *margining = s->private; struct tb *tb = margining->port->sw->tb; unsigned int max_margin; unsigned int val; int ret;
ret = kstrtouint_from_user(user_buf, count, 10, &val); if (ret) return ret;
scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &tb->lock) { if (!margining->software) return -EOPNOTSUPP;
if (margining->time) max_margin = margining->time_steps; else if (margining->optional_voltage_offset_range) max_margin = margining->voltage_steps_optional_range; else max_margin = margining->voltage_steps;
margining->voltage_time_offset = clamp(val, 0, max_margin); }
return count;}
static int margining_voltage_time_offset_show(struct seq_file *s, void *not_used){ const struct tb_margining *margining = s->private; struct tb *tb = margining->port->sw->tb;
scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &tb->lock) { if (!margining->software) return -EOPNOTSUPP;
seq_printf(s, "%d\n", margining->voltage_time_offset); }
return 0;}DEBUGFS_ATTR_RW(margining_voltage_time_offset);
static ssize_tmargining_error_counter_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos){ enum usb4_margin_sw_error_counter error_counter; struct seq_file *s = file->private_data; struct tb_margining *margining = s->private; struct tb *tb = margining->port->sw->tb; char *buf;
buf = validate_and_copy_from_user(user_buf, &count); if (IS_ERR(buf)) return PTR_ERR(buf);
buf[count - 1] = '\0';
if (!strcmp(buf, "nop")) error_counter = USB4_MARGIN_SW_ERROR_COUNTER_NOP; else if (!strcmp(buf, "clear")) error_counter = USB4_MARGIN_SW_ERROR_COUNTER_CLEAR; else if (!strcmp(buf, "start")) error_counter = USB4_MARGIN_SW_ERROR_COUNTER_START; else if (!strcmp(buf, "stop")) error_counter = USB4_MARGIN_SW_ERROR_COUNTER_STOP; else goto err_free;
free_page((unsigned long)buf);
scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &tb->lock) { if (!margining->software) return -EOPNOTSUPP;
margining->error_counter = error_counter; }
return count;
err_free: free_page((unsigned long)buf); return -EINVAL;}
static int margining_error_counter_show(struct seq_file *s, void *not_used){ const struct tb_margining *margining = s->private; struct tb *tb = margining->port->sw->tb;
scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &tb->lock) { if (!margining->software) return -EOPNOTSUPP;
switch (margining->error_counter) { case USB4_MARGIN_SW_ERROR_COUNTER_NOP: seq_puts(s, "[nop] clear start stop\n"); break; case USB4_MARGIN_SW_ERROR_COUNTER_CLEAR: seq_puts(s, "nop [clear] start stop\n"); break; case USB4_MARGIN_SW_ERROR_COUNTER_START: seq_puts(s, "nop clear [start] stop\n"); break; case USB4_MARGIN_SW_ERROR_COUNTER_STOP: seq_puts(s, "nop clear start [stop]\n"); break; } }
return 0;}DEBUGFS_ATTR_RW(margining_error_counter);
static ssize_tmargining_dwell_time_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos){ struct seq_file *s = file->private_data; struct tb_margining *margining = s->private; struct tb *tb = margining->port->sw->tb; unsigned int val; int ret;
ret = kstrtouint_from_user(user_buf, count, 10, &val); if (ret) return ret;
scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &tb->lock) { if (!margining->software) return -EOPNOTSUPP;
margining->dwell_time = clamp(val, MIN_DWELL_TIME, MAX_DWELL_TIME); }
return count;}
static int margining_dwell_time_show(struct seq_file *s, void *not_used){ struct tb_margining *margining = s->private; struct tb *tb = margining->port->sw->tb;
scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &tb->lock) { if (!margining->software) return -EOPNOTSUPP;
seq_printf(s, "%d\n", margining->dwell_time); }
return 0;}DEBUGFS_ATTR_RW(margining_dwell_time);
static ssize_tmargining_optional_voltage_offset_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos){ struct seq_file *s = file->private_data; struct tb_margining *margining = s->private; struct tb *tb = margining->port->sw->tb; bool val; int ret;
ret = kstrtobool_from_user(user_buf, count, &val); if (ret) return ret;
scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &tb->lock) { margining->optional_voltage_offset_range = val; }
return count;}
static int margining_optional_voltage_offset_show(struct seq_file *s, void *not_used){ struct tb_margining *margining = s->private; struct tb *tb = margining->port->sw->tb;
scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &tb->lock) { seq_printf(s, "%u\n", margining->optional_voltage_offset_range); }
return 0;}DEBUGFS_ATTR_RW(margining_optional_voltage_offset);
static ssize_t margining_mode_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos){ struct seq_file *s = file->private_data; struct tb_margining *margining = s->private; struct tb *tb = margining->port->sw->tb; int ret = 0; char *buf;
buf = validate_and_copy_from_user(user_buf, &count); if (IS_ERR(buf)) return PTR_ERR(buf);
buf[count - 1] = '\0';
if (mutex_lock_interruptible(&tb->lock)) { ret = -ERESTARTSYS; goto out_free; }
if (!strcmp(buf, "software")) { if (supports_software(margining)) margining->software = true; else ret = -EINVAL; } else if (!strcmp(buf, "hardware")) { if (supports_hardware(margining)) margining->software = false; else ret = -EINVAL; } else { ret = -EINVAL; }
mutex_unlock(&tb->lock);
out_free: free_page((unsigned long)buf); return ret ? ret : count;}
static int margining_mode_show(struct seq_file *s, void *not_used){ struct tb_margining *margining = s->private; struct tb *tb = margining->port->sw->tb; const char *space = "";
if (mutex_lock_interruptible(&tb->lock)) return -ERESTARTSYS;
if (supports_software(margining)) { if (margining->software) seq_puts(s, "[software]"); else seq_puts(s, "software"); space = " "; } if (supports_hardware(margining)) { if (margining->software) seq_printf(s, "%shardware", space); else seq_printf(s, "%s[hardware]", space); }
mutex_unlock(&tb->lock);
seq_puts(s, "\n"); return 0;}DEBUGFS_ATTR_RW(margining_mode);
static int margining_run_sw(struct tb_margining *margining, struct usb4_port_margining_params *params){ u32 nsamples = margining->dwell_time / DWELL_SAMPLE_INTERVAL; int ret, i;
ret = usb4_port_sw_margin(margining->port, margining->target, margining->index, params, margining->results); if (ret) goto out_stop;
for (i = 0; i <= nsamples; i++) { u32 errors = 0;
ret = usb4_port_sw_margin_errors(margining->port, margining->target, margining->index, &margining->results[1]); if (ret) break;
if (margining->lanes == USB4_MARGINING_LANE_RX0) errors = FIELD_GET(USB4_MARGIN_SW_ERR_COUNTER_LANE_0_MASK, margining->results[1]); else if (margining->lanes == USB4_MARGINING_LANE_RX1) errors = FIELD_GET(USB4_MARGIN_SW_ERR_COUNTER_LANE_1_MASK, margining->results[1]); else if (margining->lanes == USB4_MARGINING_LANE_RX2) errors = FIELD_GET(USB4_MARGIN_SW_ERR_COUNTER_LANE_2_MASK, margining->results[1]); else if (margining->lanes == USB4_MARGINING_LANE_ALL) errors = margining->results[1];
/* Any errors stop the test */ if (errors) break;
fsleep(DWELL_SAMPLE_INTERVAL * USEC_PER_MSEC); }
out_stop: /* * Stop the counters but don't clear them to allow the * different error counter configurations. */ margining_modify_error_counter(margining, margining->lanes, USB4_MARGIN_SW_ERROR_COUNTER_STOP); return ret;}
static int validate_margining(struct tb_margining *margining){ /* * For running on RX2 the link must be asymmetric with 3 * receivers. Because this can change dynamically, check it * here before we start the margining and report back error if * expectations are not met. */ if (margining->lanes == USB4_MARGINING_LANE_RX2) { int ret;
ret = tb_port_get_link_width(margining->port); if (ret < 0) return ret; if (ret != TB_LINK_WIDTH_ASYM_RX) { tb_port_warn(margining->port, "link is %s expected %s", tb_width_name(ret), tb_width_name(TB_LINK_WIDTH_ASYM_RX)); return -EINVAL; } }
return 0;}
static int margining_run_write(void *data, u64 val){ struct tb_margining *margining = data; struct tb_port *port = margining->port; struct device *dev = margining->dev; struct tb_switch *sw = port->sw; struct tb_switch *down_sw; struct tb *tb = sw->tb; int ret, clx;
if (val != 1) return -EINVAL;
pm_runtime_get_sync(dev);
if (mutex_lock_interruptible(&tb->lock)) { ret = -ERESTARTSYS; goto out_rpm_put; }
ret = validate_margining(margining); if (ret) goto out_unlock;
if (tb_is_upstream_port(port)) down_sw = sw; else if (port->remote) down_sw = port->remote->sw; else down_sw = NULL;
if (down_sw) { /* * CL states may interfere with lane margining so * disable them temporarily now. */ ret = tb_switch_clx_disable(down_sw); if (ret < 0) { tb_sw_warn(down_sw, "failed to disable CL states\n"); goto out_unlock; } clx = ret; }
/* Clear the results */ memset(margining->results, 0, sizeof(margining->results));
if (margining->software) { struct usb4_port_margining_params params = { .error_counter = USB4_MARGIN_SW_ERROR_COUNTER_CLEAR, .lanes = margining->lanes, .time = margining->time, .voltage_time_offset = margining->voltage_time_offset, .right_high = margining->right_high, .upper_eye = margining->upper_eye, .optional_voltage_offset_range = margining->optional_voltage_offset_range, };
tb_port_dbg(port, "running software %s lane margining for %s lanes %u\n", margining->time ? "time" : "voltage", dev_name(dev), margining->lanes);
ret = margining_run_sw(margining, ¶ms); } else { struct usb4_port_margining_params params = { .ber_level = margining->ber_level, .lanes = margining->lanes, .time = margining->time, .right_high = margining->right_high, .upper_eye = margining->upper_eye, .optional_voltage_offset_range = margining->optional_voltage_offset_range, };
tb_port_dbg(port, "running hardware %s lane margining for %s lanes %u\n", margining->time ? "time" : "voltage", dev_name(dev), margining->lanes);
ret = usb4_port_hw_margin(port, margining->target, margining->index, ¶ms, margining->results, ARRAY_SIZE(margining->results)); }
if (down_sw) tb_switch_clx_enable(down_sw, clx);out_unlock: mutex_unlock(&tb->lock);out_rpm_put: pm_runtime_mark_last_busy(dev); pm_runtime_put_autosuspend(dev);
return ret;}DEFINE_DEBUGFS_ATTRIBUTE(margining_run_fops, NULL, margining_run_write, "%llu\n");
static ssize_t margining_results_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos){ struct seq_file *s = file->private_data; struct tb_margining *margining = s->private; struct tb *tb = margining->port->sw->tb;
if (mutex_lock_interruptible(&tb->lock)) return -ERESTARTSYS;
/* Just clear the results */ memset(margining->results, 0, sizeof(margining->results));
if (margining->software) { /* Clear the error counters */ margining_modify_error_counter(margining, USB4_MARGINING_LANE_ALL, USB4_MARGIN_SW_ERROR_COUNTER_CLEAR); }
mutex_unlock(&tb->lock); return count;}
static void voltage_margin_show(struct seq_file *s, const struct tb_margining *margining, u8 val){ unsigned int tmp, voltage;
tmp = FIELD_GET(USB4_MARGIN_HW_RES_MARGIN_MASK, val); voltage = tmp * margining->max_voltage_offset / margining->voltage_steps; seq_printf(s, "%u mV (%u)", voltage, tmp); if (val & USB4_MARGIN_HW_RES_EXCEEDS) seq_puts(s, " exceeds maximum"); seq_puts(s, "\n"); if (margining->optional_voltage_offset_range) seq_puts(s, " optional voltage offset range enabled\n");}
static void time_margin_show(struct seq_file *s, const struct tb_margining *margining, u8 val){ unsigned int tmp, interval;
tmp = FIELD_GET(USB4_MARGIN_HW_RES_MARGIN_MASK, val); interval = tmp * margining->max_time_offset / margining->time_steps; seq_printf(s, "%u mUI (%u)", interval, tmp); if (val & USB4_MARGIN_HW_RES_EXCEEDS) seq_puts(s, " exceeds maximum"); seq_puts(s, "\n");}
static u8 margining_hw_result_val(const u32 *results, enum usb4_margining_lane lane, bool right_high){ u32 val;
if (lane == USB4_MARGINING_LANE_RX0) val = results[1]; else if (lane == USB4_MARGINING_LANE_RX1) val = results[1] >> USB4_MARGIN_HW_RES_LANE_SHIFT; else if (lane == USB4_MARGINING_LANE_RX2) val = results[2]; else val = 0;
return right_high ? val : val >> USB4_MARGIN_HW_RES_LL_SHIFT;}
static void margining_hw_result_format(struct seq_file *s, const struct tb_margining *margining, enum usb4_margining_lane lane){ u8 val;
if (margining->time) { val = margining_hw_result_val(margining->results, lane, true); seq_printf(s, "# lane %u right time margin: ", lane); time_margin_show(s, margining, val); val = margining_hw_result_val(margining->results, lane, false); seq_printf(s, "# lane %u left time margin: ", lane); time_margin_show(s, margining, val); } else { val = margining_hw_result_val(margining->results, lane, true); seq_printf(s, "# lane %u high voltage margin: ", lane); voltage_margin_show(s, margining, val); val = margining_hw_result_val(margining->results, lane, false); seq_printf(s, "# lane %u low voltage margin: ", lane); voltage_margin_show(s, margining, val); }}
static int margining_results_show(struct seq_file *s, void *not_used){ struct tb_margining *margining = s->private; struct tb *tb = margining->port->sw->tb;
if (mutex_lock_interruptible(&tb->lock)) return -ERESTARTSYS;
/* Dump the raw results first */ seq_printf(s, "0x%08x\n", margining->results[0]); /* Only the hardware margining has two result dwords */ if (!margining->software) { for (int i = 1; i < ARRAY_SIZE(margining->results); i++) seq_printf(s, "0x%08x\n", margining->results[i]);
if (margining->lanes == USB4_MARGINING_LANE_ALL) { margining_hw_result_format(s, margining, USB4_MARGINING_LANE_RX0); margining_hw_result_format(s, margining, USB4_MARGINING_LANE_RX1); if (margining->asym_rx) margining_hw_result_format(s, margining, USB4_MARGINING_LANE_RX2); } else { margining_hw_result_format(s, margining, margining->lanes); } } else { u32 lane_errors, result;
seq_printf(s, "0x%08x\n", margining->results[1]);
result = FIELD_GET(USB4_MARGIN_SW_LANES_MASK, margining->results[0]); if (result == USB4_MARGINING_LANE_RX0 || result == USB4_MARGINING_LANE_ALL) { lane_errors = FIELD_GET(USB4_MARGIN_SW_ERR_COUNTER_LANE_0_MASK, margining->results[1]); seq_printf(s, "# lane 0 errors: %u\n", lane_errors); } if (result == USB4_MARGINING_LANE_RX1 || result == USB4_MARGINING_LANE_ALL) { lane_errors = FIELD_GET(USB4_MARGIN_SW_ERR_COUNTER_LANE_1_MASK, margining->results[1]); seq_printf(s, "# lane 1 errors: %u\n", lane_errors); } if (margining->asym_rx && (result == USB4_MARGINING_LANE_RX2 || result == USB4_MARGINING_LANE_ALL)) { lane_errors = FIELD_GET(USB4_MARGIN_SW_ERR_COUNTER_LANE_2_MASK, margining->results[1]); seq_printf(s, "# lane 2 errors: %u\n", lane_errors); } }
mutex_unlock(&tb->lock); return 0;}DEBUGFS_ATTR_RW(margining_results);
static ssize_t margining_test_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos){ struct seq_file *s = file->private_data; struct tb_margining *margining = s->private; struct tb *tb = margining->port->sw->tb; int ret = 0; char *buf;
buf = validate_and_copy_from_user(user_buf, &count); if (IS_ERR(buf)) return PTR_ERR(buf);
buf[count - 1] = '\0';
if (mutex_lock_interruptible(&tb->lock)) { ret = -ERESTARTSYS; goto out_free; }
if (!strcmp(buf, "time") && supports_time(margining)) margining->time = true; else if (!strcmp(buf, "voltage")) margining->time = false; else ret = -EINVAL;
mutex_unlock(&tb->lock);
out_free: free_page((unsigned long)buf); return ret ? ret : count;}
static int margining_test_show(struct seq_file *s, void *not_used){ struct tb_margining *margining = s->private; struct tb *tb = margining->port->sw->tb;
if (mutex_lock_interruptible(&tb->lock)) return -ERESTARTSYS;
if (supports_time(margining)) { if (margining->time) seq_puts(s, "voltage [time]\n"); else seq_puts(s, "[voltage] time\n"); } else { seq_puts(s, "[voltage]\n"); }
mutex_unlock(&tb->lock); return 0;}DEBUGFS_ATTR_RW(margining_test);
static ssize_t margining_margin_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos){ struct seq_file *s = file->private_data; struct tb_margining *margining = s->private; struct tb *tb = margining->port->sw->tb; int ret = 0; char *buf;
buf = validate_and_copy_from_user(user_buf, &count); if (IS_ERR(buf)) return PTR_ERR(buf);
buf[count - 1] = '\0';
if (mutex_lock_interruptible(&tb->lock)) { ret = -ERESTARTSYS; goto out_free; }
if (margining->time) { if (!strcmp(buf, "left")) margining->right_high = false; else if (!strcmp(buf, "right")) margining->right_high = true; else ret = -EINVAL; } else { if (!strcmp(buf, "low")) margining->right_high = false; else if (!strcmp(buf, "high")) margining->right_high = true; else ret = -EINVAL; }
mutex_unlock(&tb->lock);
out_free: free_page((unsigned long)buf); return ret ? ret : count;}
static int margining_margin_show(struct seq_file *s, void *not_used){ struct tb_margining *margining = s->private; struct tb *tb = margining->port->sw->tb;
if (mutex_lock_interruptible(&tb->lock)) return -ERESTARTSYS;
if (margining->time) { if (margining->right_high) seq_puts(s, "left [right]\n"); else seq_puts(s, "[left] right\n"); } else { if (margining->right_high) seq_puts(s, "low [high]\n"); else seq_puts(s, "[low] high\n"); }
mutex_unlock(&tb->lock); return 0;}DEBUGFS_ATTR_RW(margining_margin);
static ssize_t margining_eye_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos){ struct seq_file *s = file->private_data; struct tb_port *port = s->private; struct usb4_port *usb4 = port->usb4; struct tb *tb = port->sw->tb; int ret = 0; char *buf;
buf = validate_and_copy_from_user(user_buf, &count); if (IS_ERR(buf)) return PTR_ERR(buf);
buf[count - 1] = '\0';
scoped_cond_guard(mutex_intr, ret = -ERESTARTSYS, &tb->lock) { if (!strcmp(buf, "lower")) usb4->margining->upper_eye = false; else if (!strcmp(buf, "upper")) usb4->margining->upper_eye = true; else ret = -EINVAL; }
free_page((unsigned long)buf); return ret ? ret : count;}
static int margining_eye_show(struct seq_file *s, void *not_used){ struct tb_port *port = s->private; struct usb4_port *usb4 = port->usb4; struct tb *tb = port->sw->tb;
scoped_guard(mutex_intr, &tb->lock) { if (usb4->margining->upper_eye) seq_puts(s, "lower [upper]\n"); else seq_puts(s, "[lower] upper\n");
return 0; }
return -ERESTARTSYS;}DEBUGFS_ATTR_RW(margining_eye);
static struct tb_margining *margining_alloc(struct tb_port *port, struct device *dev, enum usb4_sb_target target, u8 index, struct dentry *parent){ struct tb_margining *margining; struct dentry *dir; unsigned int val; int ret;
ret = tb_port_get_link_generation(port); if (ret < 0) { tb_port_warn(port, "failed to read link generation\n"); return NULL; }
margining = kzalloc_obj(*margining); if (!margining) return NULL;
margining->port = port; margining->target = target; margining->index = index; margining->dev = dev; margining->gen = ret; margining->asym_rx = tb_port_width_supported(port, TB_LINK_WIDTH_ASYM_RX);
ret = usb4_port_margining_caps(port, target, index, margining->caps, ARRAY_SIZE(margining->caps)); if (ret) { kfree(margining); return NULL; }
/* Set the initial mode */ if (supports_software(margining)) margining->software = true;
if (margining->gen < 4) { val = FIELD_GET(USB4_MARGIN_CAP_0_VOLTAGE_STEPS_MASK, margining->caps[0]); margining->voltage_steps = val; val = FIELD_GET(USB4_MARGIN_CAP_0_MAX_VOLTAGE_OFFSET_MASK, margining->caps[0]); margining->max_voltage_offset = 74 + val * 2; } else { val = FIELD_GET(USB4_MARGIN_CAP_2_VOLTAGE_STEPS_MASK, margining->caps[2]); margining->voltage_steps = val; val = FIELD_GET(USB4_MARGIN_CAP_2_MAX_VOLTAGE_OFFSET_MASK, margining->caps[2]); margining->max_voltage_offset = 74 + val * 2; }
if (supports_optional_voltage_offset_range(margining)) { val = FIELD_GET(USB4_MARGIN_CAP_0_VOLT_STEPS_OPT_MASK, margining->caps[0]); margining->voltage_steps_optional_range = val; val = FIELD_GET(USB4_MARGIN_CAP_1_MAX_VOLT_OFS_OPT_MASK, margining->caps[1]); margining->max_voltage_offset_optional_range = 74 + val * 2; }
if (supports_time(margining)) { val = FIELD_GET(USB4_MARGIN_CAP_1_TIME_STEPS_MASK, margining->caps[1]); margining->time_steps = val; val = FIELD_GET(USB4_MARGIN_CAP_1_TIME_OFFSET_MASK, margining->caps[1]); /* * Store it as mUI (milli Unit Interval) because we want * to keep it as integer. */ margining->max_time_offset = 200 + 10 * val; }
dir = debugfs_create_dir("margining", parent); if (supports_hardware(margining)) { val = FIELD_GET(USB4_MARGIN_CAP_1_MIN_BER_MASK, margining->caps[1]); margining->min_ber_level = val; val = FIELD_GET(USB4_MARGIN_CAP_1_MAX_BER_MASK, margining->caps[1]); margining->max_ber_level = val;
/* Set the default to minimum */ margining->ber_level = margining->min_ber_level;
debugfs_create_file("ber_level_contour", 0400, dir, margining, &margining_ber_level_fops); } debugfs_create_file("caps", 0400, dir, margining, &margining_caps_fops); debugfs_create_file("lanes", 0600, dir, margining, &margining_lanes_fops); debugfs_create_file("mode", 0600, dir, margining, &margining_mode_fops); debugfs_create_file("run", 0600, dir, margining, &margining_run_fops); debugfs_create_file("results", 0600, dir, margining, &margining_results_fops); debugfs_create_file("test", 0600, dir, margining, &margining_test_fops); if (independent_voltage_margins(margining) == USB4_MARGIN_CAP_VOLTAGE_INDP_GEN_2_3_HL || (supports_time(margining) && independent_time_margins(margining) == USB4_MARGIN_CAP_TIME_INDP_GEN_2_3_LR)) debugfs_create_file("margin", 0600, dir, margining, &margining_margin_fops);
margining->error_counter = USB4_MARGIN_SW_ERROR_COUNTER_CLEAR; margining->dwell_time = MIN_DWELL_TIME;
if (supports_optional_voltage_offset_range(margining)) debugfs_create_file("optional_voltage_offset", DEBUGFS_MODE, dir, margining, &margining_optional_voltage_offset_fops);
if (supports_software(margining)) { debugfs_create_file("voltage_time_offset", DEBUGFS_MODE, dir, margining, &margining_voltage_time_offset_fops); debugfs_create_file("error_counter", DEBUGFS_MODE, dir, margining, &margining_error_counter_fops); debugfs_create_file("dwell_time", DEBUGFS_MODE, dir, margining, &margining_dwell_time_fops); }
if (margining->gen >= 4) debugfs_create_file("eye", 0600, dir, port, &margining_eye_fops);
return margining;}
static void margining_port_init(struct tb_port *port){ struct dentry *parent; char dir_name[10];
if (!port->usb4) return;
snprintf(dir_name, sizeof(dir_name), "port%d", port->port); parent = debugfs_lookup(dir_name, port->sw->debugfs_dir); port->usb4->margining = margining_alloc(port, &port->usb4->dev, USB4_SB_TARGET_ROUTER, 0, parent);}
static void margining_port_remove(struct tb_port *port){ struct dentry *parent; char dir_name[10];
if (!port->usb4) return; if (!port->usb4->margining) return;
snprintf(dir_name, sizeof(dir_name), "port%d", port->port); parent = debugfs_lookup(dir_name, port->sw->debugfs_dir); if (parent) debugfs_lookup_and_remove("margining", parent);
kfree(port->usb4->margining); port->usb4->margining = NULL;}
static void margining_switch_init(struct tb_switch *sw){ struct tb_port *upstream, *downstream; struct tb_switch *parent_sw; u64 route = tb_route(sw);
if (!route) return;
upstream = tb_upstream_port(sw); parent_sw = tb_switch_parent(sw); downstream = tb_port_at(route, parent_sw);
margining_port_init(downstream); margining_port_init(upstream);}
static void margining_switch_remove(struct tb_switch *sw){ struct tb_port *upstream, *downstream; struct tb_switch *parent_sw; u64 route = tb_route(sw);
if (!route) return;
upstream = tb_upstream_port(sw); parent_sw = tb_switch_parent(sw); downstream = tb_port_at(route, parent_sw);
margining_port_remove(upstream); margining_port_remove(downstream);}
static void margining_xdomain_init(struct tb_xdomain *xd){ struct tb_switch *parent_sw; struct tb_port *downstream;
parent_sw = tb_xdomain_parent(xd); downstream = tb_port_at(xd->route, parent_sw);
margining_port_init(downstream);}
static void margining_xdomain_remove(struct tb_xdomain *xd){ struct tb_switch *parent_sw; struct tb_port *downstream;
parent_sw = tb_xdomain_parent(xd); downstream = tb_port_at(xd->route, parent_sw); margining_port_remove(downstream);}
static void margining_retimer_init(struct tb_retimer *rt, struct dentry *debugfs_dir){ rt->margining = margining_alloc(rt->port, &rt->dev, USB4_SB_TARGET_RETIMER, rt->index, debugfs_dir);}
static void margining_retimer_remove(struct tb_retimer *rt){ kfree(rt->margining); rt->margining = NULL;}#elsestatic inline void margining_switch_init(struct tb_switch *sw) { }static inline void margining_switch_remove(struct tb_switch *sw) { }static inline void margining_xdomain_init(struct tb_xdomain *xd) { }static inline void margining_xdomain_remove(struct tb_xdomain *xd) { }static inline void margining_retimer_init(struct tb_retimer *rt, struct dentry *debugfs_dir) { }static inline void margining_retimer_remove(struct tb_retimer *rt) { }#endif
static int port_clear_all_counters(struct tb_port *port){ u32 *buf; int ret;
buf = kcalloc(COUNTER_SET_LEN * port->config.max_counters, sizeof(u32), GFP_KERNEL); if (!buf) return -ENOMEM;
ret = tb_port_write(port, buf, TB_CFG_COUNTERS, 0, COUNTER_SET_LEN * port->config.max_counters); kfree(buf);
return ret;}
static ssize_t counters_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos){ struct seq_file *s = file->private_data; struct tb_port *port = s->private; struct tb_switch *sw = port->sw; struct tb *tb = port->sw->tb; char *buf; int ret;
buf = validate_and_copy_from_user(user_buf, &count); if (IS_ERR(buf)) return PTR_ERR(buf);
pm_runtime_get_sync(&sw->dev);
if (mutex_lock_interruptible(&tb->lock)) { ret = -ERESTARTSYS; goto out; }
/* If written delimiter only, clear all counters in one shot */ if (buf[0] == '\n') { ret = port_clear_all_counters(port); } else { char *line = buf; u32 val, offset;
ret = -EINVAL; while (parse_line(&line, &offset, &val, 1, 4)) { ret = tb_port_write(port, &val, TB_CFG_COUNTERS, offset, 1); if (ret) break; } }
mutex_unlock(&tb->lock);
out: pm_runtime_mark_last_busy(&sw->dev); pm_runtime_put_autosuspend(&sw->dev); free_page((unsigned long)buf);
return ret < 0 ? ret : count;}
static void cap_show_by_dw(struct seq_file *s, struct tb_switch *sw, struct tb_port *port, unsigned int cap, unsigned int offset, u8 cap_id, u8 vsec_id, int dwords){ int i, ret; u32 data;
for (i = 0; i < dwords; i++) { if (port) ret = tb_port_read(port, &data, TB_CFG_PORT, cap + offset + i, 1); else ret = tb_sw_read(sw, &data, TB_CFG_SWITCH, cap + offset + i, 1); if (ret) { seq_printf(s, "0x%04x <not accessible>\n", cap + offset + i); continue; }
seq_printf(s, "0x%04x %4d 0x%02x 0x%02x 0x%08x\n", cap + offset + i, offset + i, cap_id, vsec_id, data); }}
static void cap_show(struct seq_file *s, struct tb_switch *sw, struct tb_port *port, unsigned int cap, u8 cap_id, u8 vsec_id, int length){ int ret, offset = 0;
while (length > 0) { int i, dwords = min(length, TB_MAX_CONFIG_RW_LENGTH); u32 data[TB_MAX_CONFIG_RW_LENGTH];
if (port) ret = tb_port_read(port, data, TB_CFG_PORT, cap + offset, dwords); else ret = tb_sw_read(sw, data, TB_CFG_SWITCH, cap + offset, dwords); if (ret) { cap_show_by_dw(s, sw, port, cap, offset, cap_id, vsec_id, length); return; }
for (i = 0; i < dwords; i++) { seq_printf(s, "0x%04x %4d 0x%02x 0x%02x 0x%08x\n", cap + offset + i, offset + i, cap_id, vsec_id, data[i]); }
length -= dwords; offset += dwords; }}
static void port_cap_show(struct tb_port *port, struct seq_file *s, unsigned int cap){ struct tb_cap_any header; u8 vsec_id = 0; size_t length; int ret;
ret = tb_port_read(port, &header, TB_CFG_PORT, cap, 1); if (ret) { seq_printf(s, "0x%04x <capability read failed>\n", cap); return; }
switch (header.basic.cap) { case TB_PORT_CAP_PHY: length = PORT_CAP_LANE_LEN; break;
case TB_PORT_CAP_TIME1: if (usb4_switch_version(port->sw) < 2) length = PORT_CAP_TMU_V1_LEN; else length = PORT_CAP_TMU_V2_LEN; break;
case TB_PORT_CAP_POWER: length = PORT_CAP_POWER_LEN; break;
case TB_PORT_CAP_ADAP: if (tb_port_is_pcie_down(port) || tb_port_is_pcie_up(port)) { if (usb4_switch_version(port->sw) < 2) length = PORT_CAP_V1_PCIE_LEN; else length = PORT_CAP_V2_PCIE_LEN; } else if (tb_port_is_dpin(port)) { if (usb4_switch_version(port->sw) < 2) length = PORT_CAP_DP_V1_LEN; else length = PORT_CAP_DP_V2_LEN; } else if (tb_port_is_dpout(port)) { length = PORT_CAP_DP_V1_LEN; } else if (tb_port_is_usb3_down(port) || tb_port_is_usb3_up(port)) { length = PORT_CAP_USB3_LEN; } else { seq_printf(s, "0x%04x <unsupported capability 0x%02x>\n", cap, header.basic.cap); return; } break;
case TB_PORT_CAP_VSE: if (!header.extended_short.length) { ret = tb_port_read(port, (u32 *)&header + 1, TB_CFG_PORT, cap + 1, 1); if (ret) { seq_printf(s, "0x%04x <capability read failed>\n", cap + 1); return; } length = header.extended_long.length; vsec_id = header.extended_short.vsec_id; } else { length = header.extended_short.length; vsec_id = header.extended_short.vsec_id; } break;
case TB_PORT_CAP_USB4: length = PORT_CAP_USB4_LEN; break;
default: seq_printf(s, "0x%04x <unsupported capability 0x%02x>\n", cap, header.basic.cap); return; }
cap_show(s, NULL, port, cap, header.basic.cap, vsec_id, length);}
static void port_caps_show(struct tb_port *port, struct seq_file *s){ int cap;
cap = tb_port_next_cap(port, 0); while (cap > 0) { port_cap_show(port, s, cap); cap = tb_port_next_cap(port, cap); }}
static int port_basic_regs_show(struct tb_port *port, struct seq_file *s){ u32 data[PORT_CAP_BASIC_LEN]; int ret, i;
ret = tb_port_read(port, data, TB_CFG_PORT, 0, ARRAY_SIZE(data)); if (ret) return ret;
for (i = 0; i < ARRAY_SIZE(data); i++) seq_printf(s, "0x%04x %4d 0x00 0x00 0x%08x\n", i, i, data[i]);
return 0;}
static int port_regs_show(struct seq_file *s, void *not_used){ struct tb_port *port = s->private; struct tb_switch *sw = port->sw; struct tb *tb = sw->tb; int ret;
pm_runtime_get_sync(&sw->dev);
if (mutex_lock_interruptible(&tb->lock)) { ret = -ERESTARTSYS; goto out_rpm_put; }
seq_puts(s, "# offset relative_offset cap_id vs_cap_id value\n");
ret = port_basic_regs_show(port, s); if (ret) goto out_unlock;
port_caps_show(port, s);
out_unlock: mutex_unlock(&tb->lock);out_rpm_put: pm_runtime_mark_last_busy(&sw->dev); pm_runtime_put_autosuspend(&sw->dev);
return ret;}DEBUGFS_ATTR_RW(port_regs);
static void switch_cap_show(struct tb_switch *sw, struct seq_file *s, unsigned int cap){ struct tb_cap_any header; int ret, length; u8 vsec_id = 0;
ret = tb_sw_read(sw, &header, TB_CFG_SWITCH, cap, 1); if (ret) { seq_printf(s, "0x%04x <capability read failed>\n", cap); return; }
if (header.basic.cap == TB_SWITCH_CAP_VSE) { if (!header.extended_short.length) { ret = tb_sw_read(sw, (u32 *)&header + 1, TB_CFG_SWITCH, cap + 1, 1); if (ret) { seq_printf(s, "0x%04x <capability read failed>\n", cap + 1); return; } length = header.extended_long.length; } else { length = header.extended_short.length; } vsec_id = header.extended_short.vsec_id; } else { if (header.basic.cap == TB_SWITCH_CAP_TMU) { length = SWITCH_CAP_TMU_LEN; } else { seq_printf(s, "0x%04x <unknown capability 0x%02x>\n", cap, header.basic.cap); return; } }
cap_show(s, sw, NULL, cap, header.basic.cap, vsec_id, length);}
static void switch_caps_show(struct tb_switch *sw, struct seq_file *s){ int cap;
cap = tb_switch_next_cap(sw, 0); while (cap > 0) { switch_cap_show(sw, s, cap); cap = tb_switch_next_cap(sw, cap); }}
static int switch_basic_regs_show(struct tb_switch *sw, struct seq_file *s){ u32 data[SWITCH_CAP_BASIC_LEN]; size_t dwords; int ret, i;
/* Only USB4 has the additional registers */ if (tb_switch_is_usb4(sw)) dwords = ARRAY_SIZE(data); else dwords = 5;
ret = tb_sw_read(sw, data, TB_CFG_SWITCH, 0, dwords); if (ret) return ret;
for (i = 0; i < dwords; i++) seq_printf(s, "0x%04x %4d 0x00 0x00 0x%08x\n", i, i, data[i]);
return 0;}
static int switch_regs_show(struct seq_file *s, void *not_used){ struct tb_switch *sw = s->private; struct tb *tb = sw->tb; int ret;
pm_runtime_get_sync(&sw->dev);
if (mutex_lock_interruptible(&tb->lock)) { ret = -ERESTARTSYS; goto out_rpm_put; }
seq_puts(s, "# offset relative_offset cap_id vs_cap_id value\n");
ret = switch_basic_regs_show(sw, s); if (ret) goto out_unlock;
switch_caps_show(sw, s);
out_unlock: mutex_unlock(&tb->lock);out_rpm_put: pm_runtime_mark_last_busy(&sw->dev); pm_runtime_put_autosuspend(&sw->dev);
return ret;}DEBUGFS_ATTR_RW(switch_regs);
static int path_show_one(struct tb_port *port, struct seq_file *s, int hopid){ u32 data[PATH_LEN]; int ret, i;
ret = tb_port_read(port, data, TB_CFG_HOPS, hopid * PATH_LEN, ARRAY_SIZE(data)); if (ret) { seq_printf(s, "0x%04x <not accessible>\n", hopid * PATH_LEN); return ret; }
for (i = 0; i < ARRAY_SIZE(data); i++) { seq_printf(s, "0x%04x %4d 0x%02x 0x%08x\n", hopid * PATH_LEN + i, i, hopid, data[i]); }
return 0;}
static int path_show(struct seq_file *s, void *not_used){ struct tb_port *port = s->private; struct tb_switch *sw = port->sw; struct tb *tb = sw->tb; int start, i, ret = 0;
pm_runtime_get_sync(&sw->dev);
if (mutex_lock_interruptible(&tb->lock)) { ret = -ERESTARTSYS; goto out_rpm_put; }
seq_puts(s, "# offset relative_offset in_hop_id value\n");
/* NHI and lane adapters have entry for path 0 */ if (tb_port_is_null(port) || tb_port_is_nhi(port)) { ret = path_show_one(port, s, 0); if (ret) goto out_unlock; }
start = tb_port_is_nhi(port) ? 1 : TB_PATH_MIN_HOPID;
for (i = start; i <= port->config.max_in_hop_id; i++) { ret = path_show_one(port, s, i); if (ret) break; }
out_unlock: mutex_unlock(&tb->lock);out_rpm_put: pm_runtime_mark_last_busy(&sw->dev); pm_runtime_put_autosuspend(&sw->dev);
return ret;}DEBUGFS_ATTR_RW(path);
static int counter_set_regs_show(struct tb_port *port, struct seq_file *s, int counter){ u32 data[COUNTER_SET_LEN]; int ret, i;
ret = tb_port_read(port, data, TB_CFG_COUNTERS, counter * COUNTER_SET_LEN, ARRAY_SIZE(data)); if (ret) { seq_printf(s, "0x%04x <not accessible>\n", counter * COUNTER_SET_LEN); return ret; }
for (i = 0; i < ARRAY_SIZE(data); i++) { seq_printf(s, "0x%04x %4d 0x%02x 0x%08x\n", counter * COUNTER_SET_LEN + i, i, counter, data[i]); }
return 0;}
static int counters_show(struct seq_file *s, void *not_used){ struct tb_port *port = s->private; struct tb_switch *sw = port->sw; struct tb *tb = sw->tb; int i, ret = 0;
pm_runtime_get_sync(&sw->dev);
if (mutex_lock_interruptible(&tb->lock)) { ret = -ERESTARTSYS; goto out; }
seq_puts(s, "# offset relative_offset counter_id value\n");
for (i = 0; i < port->config.max_counters; i++) { ret = counter_set_regs_show(port, s, i); if (ret) break; }
mutex_unlock(&tb->lock);
out: pm_runtime_mark_last_busy(&sw->dev); pm_runtime_put_autosuspend(&sw->dev);
return ret;}DEBUGFS_ATTR_RW(counters);
static int sb_regs_show(struct tb_port *port, const struct sb_reg *sb_regs, size_t size, enum usb4_sb_target target, u8 index, struct seq_file *s){ int ret, i;
seq_puts(s, "# register value\n");
for (i = 0; i < size; i++) { const struct sb_reg *regs = &sb_regs[i]; u8 data[64]; int j;
memset(data, 0, sizeof(data)); ret = usb4_port_sb_read(port, target, index, regs->reg, data, regs->size); if (ret) { seq_printf(s, "0x%02x <not accessible>\n", regs->reg); continue; }
seq_printf(s, "0x%02x", regs->reg); for (j = 0; j < regs->size; j++) seq_printf(s, " 0x%02x", data[j]); seq_puts(s, "\n"); }
return 0;}
static int port_sb_regs_show(struct seq_file *s, void *not_used){ struct tb_port *port = s->private; struct tb_switch *sw = port->sw; struct tb *tb = sw->tb; int ret;
pm_runtime_get_sync(&sw->dev);
if (mutex_lock_interruptible(&tb->lock)) { ret = -ERESTARTSYS; goto out_rpm_put; }
ret = sb_regs_show(port, port_sb_regs, ARRAY_SIZE(port_sb_regs), USB4_SB_TARGET_ROUTER, 0, s);
mutex_unlock(&tb->lock);out_rpm_put: pm_runtime_mark_last_busy(&sw->dev); pm_runtime_put_autosuspend(&sw->dev);
return ret;}DEBUGFS_ATTR_RW(port_sb_regs);
/** * tb_switch_debugfs_init() - Add debugfs entries for router * @sw: Pointer to the router * * Adds debugfs directories and files for given router. */void tb_switch_debugfs_init(struct tb_switch *sw){ struct dentry *debugfs_dir; struct tb_port *port;
debugfs_dir = debugfs_create_dir(dev_name(&sw->dev), tb_debugfs_root); sw->debugfs_dir = debugfs_dir; debugfs_create_file("regs", DEBUGFS_MODE, debugfs_dir, sw, &switch_regs_fops); if (sw->drom) debugfs_create_blob("drom", 0400, debugfs_dir, &sw->drom_blob);
tb_switch_for_each_port(sw, port) { struct dentry *debugfs_dir; char dir_name[10];
if (port->disabled) continue; if (port->config.type == TB_TYPE_INACTIVE) continue;
snprintf(dir_name, sizeof(dir_name), "port%d", port->port); debugfs_dir = debugfs_create_dir(dir_name, sw->debugfs_dir); debugfs_create_file("regs", DEBUGFS_MODE, debugfs_dir, port, &port_regs_fops); debugfs_create_file("path", 0400, debugfs_dir, port, &path_fops); if (port->config.counters_support) debugfs_create_file("counters", 0600, debugfs_dir, port, &counters_fops); if (port->usb4) debugfs_create_file("sb_regs", DEBUGFS_MODE, debugfs_dir, port, &port_sb_regs_fops); }
margining_switch_init(sw);}
/** * tb_switch_debugfs_remove() - Remove all router debugfs entries * @sw: Pointer to the router * * Removes all previously added debugfs entries under this router. */void tb_switch_debugfs_remove(struct tb_switch *sw){ margining_switch_remove(sw); debugfs_remove_recursive(sw->debugfs_dir);}
void tb_xdomain_debugfs_init(struct tb_xdomain *xd){ margining_xdomain_init(xd);}
void tb_xdomain_debugfs_remove(struct tb_xdomain *xd){ margining_xdomain_remove(xd);}
/** * tb_service_debugfs_init() - Add debugfs directory for service * @svc: Thunderbolt service pointer * * Adds debugfs directory for service. */void tb_service_debugfs_init(struct tb_service *svc){ svc->debugfs_dir = debugfs_create_dir(dev_name(&svc->dev), tb_debugfs_root);}
/** * tb_service_debugfs_remove() - Remove service debugfs directory * @svc: Thunderbolt service pointer * * Removes the previously created debugfs directory for @svc. */void tb_service_debugfs_remove(struct tb_service *svc){ debugfs_remove_recursive(svc->debugfs_dir); svc->debugfs_dir = NULL;}
static int retimer_sb_regs_show(struct seq_file *s, void *not_used){ struct tb_retimer *rt = s->private; struct tb *tb = rt->tb; int ret;
pm_runtime_get_sync(&rt->dev);
if (mutex_lock_interruptible(&tb->lock)) { ret = -ERESTARTSYS; goto out_rpm_put; }
ret = sb_regs_show(rt->port, retimer_sb_regs, ARRAY_SIZE(retimer_sb_regs), USB4_SB_TARGET_RETIMER, rt->index, s);
mutex_unlock(&tb->lock);out_rpm_put: pm_runtime_mark_last_busy(&rt->dev); pm_runtime_put_autosuspend(&rt->dev);
return ret;}DEBUGFS_ATTR_RW(retimer_sb_regs);
/** * tb_retimer_debugfs_init() - Add debugfs directory for retimer * @rt: Pointer to retimer structure * * Adds and populates retimer debugfs directory. */void tb_retimer_debugfs_init(struct tb_retimer *rt){ struct dentry *debugfs_dir;
debugfs_dir = debugfs_create_dir(dev_name(&rt->dev), tb_debugfs_root); debugfs_create_file("sb_regs", DEBUGFS_MODE, debugfs_dir, rt, &retimer_sb_regs_fops); margining_retimer_init(rt, debugfs_dir);}
/** * tb_retimer_debugfs_remove() - Remove retimer debugfs directory * @rt: Pointer to retimer structure * * Removes the retimer debugfs directory along with its contents. */void tb_retimer_debugfs_remove(struct tb_retimer *rt){ debugfs_lookup_and_remove(dev_name(&rt->dev), tb_debugfs_root); margining_retimer_remove(rt);}
void tb_debugfs_init(void){ tb_debugfs_root = debugfs_create_dir("thunderbolt", NULL);}
void tb_debugfs_exit(void){ debugfs_remove_recursive(tb_debugfs_root);}